Java基本语法（变量，数据类型，关键字、）

变量是内存中的一块存储区域，用于存储程序运行时的数据。变量的值可以在同一个类型之间不断变化，即变量的值可以在同一类型中随时变化。变量是程序中最基本的存储单元，由变量名、变量类型和变量值三要素组成。
在Java编程中，变量是存储数据的一种方式，它可以存储各种基本类型的数据，如整数、浮点数、字符等。了解如何声明和使用变量，以及如何为变量命名，是编写Java程序的基础。

声明

声明方式

在Java中声明变量的语法格式如下：

类型 变量名;

例如，声明一个整型变量 age：

int age;

赋值方式

给变量赋值的语法格式如下：

变量名 = 变量值;

例如，给已声明的变量 age 赋值：

age = 10;

声明的同时进行赋值

在Java中，还可以在声明变量的同时给它赋一个初始值：

类型 变量名 = 变量值;

例如，声明一个整型变量 num 并赋值为10：

int num = 10;

举例

// 类型 变量名 变量值
// 声明方式: 类型 变量名
// 分号表示一个语句的结束, 每一段Java代码基本上都以分号结尾
int age;
// 赋值方式: 变量名 = 变量值
// 赋值前提: 必须已经声明过该变量
age = 23;
// 可以改变当前变量的值
age = 24;
// 声明的同时进行赋值
// 类型 变量名 = 变量值;
int num = 10;
num = 20;
// 打印对应的变量,在控制台输出
// System.out.println():表示在控制台输出一段数据
// 输出的数据即为括号中的值
// 其值可以是具体值, 也可以是变量名
// 如果是变量名, 打印的是变量所对应的变量值
System.out.println(age);
System.out.println(num);

变量命名规范

字符组成：变量名可以包含以下字符：

26个英文字母（区分大小写）
数字0-9
下划线 _
美元符号 $

开头限制：

变量名不能以数字开头。

空格禁止：

变量名不能包含空格。

关键字/保留字：

变量名不能是Java的关键字或保留字。不过，可以在变量名中包含关键字和保留字，只要它们不是变量名的全部。

大小写敏感：

Java语言是大小写敏感的，这意味着age和Age被视为两个不同的变量。

长度限制：

变量名的长度没有限制。

常见的Java关键字：

数据类型关键字：int, float, double, char, boolean, byte, short, long。
控制流关键字：if, else, while, for, do, switch, case, default。
访问修饰符关键字：public, protected, private。
其他关键字：class, interface, extends, implements, new, this, super, try, catch, finally, throw, throws, package, import。

举例

int a1_2$b = 1; // 合法
// int 1a = 2; // 不合法,编译报错
// int a 2 = 3; // 不合法,编译报错
// int class = 4; // 不合法, 编译报错
// int goto = 5; // 不合法,编译报错
int aclass = 1; // 合法
int bgoto = 2; // 合法
int NUMBER = 10;
System.out.println(NUMBER);
// System.out.println(number); // 编译报错,区分大小写
int age = 20;
int maxAge = 100;

关键字

在Java编程语言中，关键字是被赋予了特殊含义的保留字，它们在Java语言中扮演着重要的角色，用于定义数据类型、流程控制、访问修饰、类与类之间的关系、实例化对象、异常处理等多个方面。

用于定义数据类型的关键字：
class: 用于定义类。
interface: 用于定义接口。
enum: 用于定义枚举类型。
void: 表示无返回值的类型。
基本数据类型：byte、short、int、long、float、double、char、boolean。
用于定义流程控制语句的关键字：
if、else: 条件分支控制。
switch、case、default: 多分支选择结构。
while: 循环结构。
do、for: 循环结构，for循环可以是固定次数或者遍历集合。
break: 跳出当前循环。
return: 方法返回值。
continue: 跳过当前循环的剩余部分，继续下一次循环。
用于定义访问修饰符的关键字：
private: 私有访问修饰符，限制成员的访问范围。
protected: 受保护的访问修饰符，允许子类访问。
public: 公共访问修饰符，无限制访问。
用于定义类、方法、变量修饰符的关键字：
abstract: 抽象修饰符，用于声明抽象类或方法。
final: 最终修饰符，用于声明常量或最终方法和类。
static: 静态修饰符，用于声明类变量和方法。
synchronized: 同步修饰符，用于声明同步方法或代码块。
用于定义类与类之间关系的关键字：
extends: 继承关键字，用于子类继承父类。
implements: 实现关键字，用于类实现接口。
用于建立实例、引用实例以及判断实例的关键字：
new: 创建对象实例。
this: 引用当前对象。
super: 引用父类。
instanceof: 判断对象是否是某个类的实例。
用于异常处理的关键字：
try: 定义异常处理代码块。
catch: 捕获异常。
finally: 无论是否发生异常，都会执行的代码块。
throw: 抛出异常。
throws: 方法声明可能抛出的异常。
用于包的关键字：
package: 定义包名。
import: 导入其他包中的类或接口。
用于修饰符的关键字：
native: 表示方法在本地实现。
strictfp: 严格浮点计算修饰符。
transient: 表示字段不是序列化的一部分。
volatile: 表示变量可能会被多个线程同时访问。
assert: 断言，用于调试。
用于数据值的关键字：
true: 布尔值真。
false: 布尔值假。
null: 表示空引用。
在Java中，关键字是大小写敏感的，因此Number和number是不同的标识符。例如，NUMBER是一个合法的变量名，而number则是一个关键字，不能用作变量名。此外，关键字一旦被定义，就不能用作类名、方法名或变量名，以免与Java语言的内置含义冲突。例如，age是一个合法的变量名，而public则是一个关键字，不能用作变量名。

保留字

在Java编程语言中，保留字是指那些当前版本尚未使用，但可能会在未来版本中被赋予特殊含义的单词。这些保留字是出于安全考虑而预留的，以确保语言的向后兼容性和未来的扩展性。开发者在为变量、方法或类命名时应避免使用这些保留字，以免在将来的Java版本中引起冲突。

以下是Java中的一些保留字：

goto：尽管在许多其他编程语言中，goto 作为一个跳转语句被广泛使用，但在Java中，goto 并未被实现。然而，它被保留作为未来可能的关键字。
const：在很多编程语言中，const 用于声明一个常量，即其值在初始化后不可更改。Java目前使用 final 关键字来实现这一功能。const 被保留，可能是为了未来可能引入类似的功能。

需要注意的是，保留字和关键字都是Java语言的一部分，但它们之间存在区别。关键字是当前已经被使用并具有特定语义的单词，而保留字则是尚未使用但可能在未来版本中获得特殊含义的单词。

数据类型

在Java编程语言中，数据类型的分类是程序设计的基础，它决定了数据在内存中的存储方式以及可以进行的操作。Java中的数据类型主要分为两大类：基本数据类型和引用数据类型，另外还有一个特殊的空类型。

基本数据类型

基本数据类型是Java语言内置的、占用固定内存空间的数据类型。它们包括：

数值型：用于表示各种数值，包括整数型和浮点型。
整数型：用于表示整数值，包括：
- byte：占用1个字节，范围从-128到127（有符号）。
- short：占用2个字节，范围从-32,768到32,767（有符号）。
- int：占用4个字节，范围从-2,147,483,648到2,147,483,647（有符号）。
- long：占用8个字节，范围从-9,223,372,036,854,775,808到9,223,372,036,854,775,807（有符号）。
浮点型：用于表示实数（小数），包括：
- float：占用4个字节，有效数字大约6到7位小数。
- double：占用8个字节，有效数字大约15到16位小数，是浮点型数据的默认类型。
字符型：用于表示单个字符。
char：占用2个字节，可以表示Unicode字符集中的任意字符。
布尔类型：用于表示逻辑上的真或假。
boolean：只有两个值，true和false。

引用数据类型

引用数据类型是指那些不是Java基本数据类型的数据类型。它们包括类（Class）、接口（Interface）、数组（Array）等。引用类型的变量实际上存储的是对象的引用（内存地址），而不是对象本身。

空类型

空类型只有一个值，即null。null是所有引用数据类型的默认值，它表示一个空的或者不存在的引用。在使用引用类型的变量之前，通常需要将其初始化为一个具体的对象或者地址，否则如果直接使用null，可能会导致运行时错误。

数据类型转换

自动类型转化

从小容器到大容器，从低精度到高精度
byte（1）→ short(2) →int(4);char(2) →long(8) →float(4) → double(8)
boolean(1bit) 不参与
强制类型转化
如果一定要转的话，可以使用强制类型转换
byte b = (byte) i;在需要转型的变量前用括号写出目标类型

举例

自动转换

public class Test {
  public static void main(String[] args) {
    byte b = 100;
    short s = 100;
    int i = 100;
    long l = 100l;
    // 此时byte与int做运算,会自动转换成int类型
    // 如果使用byte进行接受, 则编译报错
    // 运行报错的信息:不兼容的类型, 从int转换到byte可能会有损失
    // byte sum = b+i;
    int sum = b + i;
    System.out.println(sum);
    // 当short与int运算时,自动转换成int类型
    // short sum2 = s + i; // 报错
    sum = s + i;
    System.out.println(sum);
    // 当int与long进行运算时,自动转换成long类型
    // int sum3 = i+l;
    long sum3 = i + l;
    // byte与short进行运算时,既不能使用short,也不能使用byte接收
    // 此时可以通过int接收
    int sum4 = b + s;
    System.out.println(sum4);
    float f = 3.14f;
    double d = 5.12;
    // long与float进行运算,使用float进行接收
    // long sum5 = l + f;
    float sum5 = l + f;
    System.out.println(sum5);
    // float与double进行运算, 使用double进行接收
    // float sum6 = f + d;
    double sum6 = f + d;
    System.out.println(sum6);
    // char类型转换成数字,是根据ASCII码进行转换
    char c1 = 'A';
    char c2 = 'a';
    // char可以自动转换成int
    int i1 = c1;
    int i2 = c2;
    System.out.println(i1);
    System.out.println(i2);
    // char类型与short、byte运算时可以使用int接收
    // 此时的char会先转换成数字,再参与运算
    // 此处相当于100+65
    int sum7 = s + c1;
    System.out.println(sum7);
  }
}

强制类型转换

语法

强制类型转换的基本语法如下：

(目标类型) 数据;

这里，目标类型是你希望转换到的数据类型，而数据是要转换的原始数据。

强制类型转换的示例

以下是一些强制类型转换的示例，包括可能导致的数据丢失和精度损失情况：

当值的大小在目标类型的范围内时，转换不会有任何损失。例如：

long l = 1000L;
int i = (int) l; // 正确的转换，不会有数据丢失
System.out.println(i); // 输出结果为1000

当值的范围超出了目标类型时，可能会导致数据丢失。例如：

byte b = (byte) l; // 错误的转换，会发生数据丢失
// 此时的值不是1000，而是-24（由于byte类型的有符号性质和二进制补码运算）
System.out.println(b); // 输出结果为-24

小数转换成整数时，如果整数在目标类型范围内，则会自动截取掉小数部分。例如：

double d = 123.45;
int i2 = (int) d; // 正确的转换，小数部分被截取
System.out.println(i2); // 输出结果为123

如果小数转换成整数，且整数不在目标类型范围内，则整数也会发生变化。例如：

double d2 = 1234.56;
byte b2 = (byte) d2; // 错误的转换，整数部分发生变化
// 由于d2的值超出了byte类型的表示范围，转换后得到的结果不是预期的1234
System.out.println(b2); // 输出结果为84（由于二进制运算的结果）

获取用户输入

在Java中，Scanner类是一个非常有用的工具，它可以用来获取用户的输入。这个类位于java.util包中，因此在使用之前需要先导入这个类。以下是使用Scanner类获取用户输入的基本用法，以及一些相关的练习。

基本用法

导入Scanner类：

import java.util.Scanner;

这行代码应该放在Java文件的顶部，位于package声明之后。

创建Scanner对象：

Scanner sc = new Scanner(System.in);

这行代码创建了一个Scanner对象，用于从标准输入（通常是键盘）读取数据。

使用Scanner获取输入：
next()：获取输入的字符串数据。
nextInt()：获取输入的int类型的数据。
nextDouble()：获取输入的double类型的数据。
nextXxx()：获取输入的xxx类型的数据，其中Xxx是其他基本数据类型的名称，如nextLong()、nextFloat()、nextBoolean()等。

示例代码

import java.util.Scanner; // 导入Scanner类

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in); // 创建Scanner对象

        System.out.println("请输入一个整数：");
        int number = sc.nextInt(); // 获取输入的整数

        System.out.println("请输入一个小数：");
        double decimal = sc.nextDouble(); // 获取输入的小数

        System.out.println("您输入的整数是：" + number);
        System.out.println("您输入的小数是：" + decimal);

        sc.close(); // 关闭Scanner对象
    }
}

练习

以下是一个练习，用于演示如何导入Scanner类，并使用它来获取不同类型的用户输入。

import java.util.Scanner; // 导入Scanner类

public class InputExample {
    public static void main(String[] args) {
        // 创建Scanner对象
        Scanner scanner = new Scanner(System.in);

        // 获取用户输入的不同类型的数据
        System.out.println("请输入一个整数：");
        int intInput = scanner.nextInt();

        System.out.println("请输入一个字符：");
        char charInput = scanner.next().charAt(0); // next()获取字符串，charAt(0)获取第一个字符

        System.out.println("请输入一个布尔值（true/false）：");
        boolean boolInput = scanner.nextBoolean();

        // 打印用户输入的数据
        System.out.println("您输入的整数是：" + intInput);
        System.out.println("您输入的字符是：" + charInput);
        System.out.println("您输入的布尔值是：" + boolInput);

        // 关闭Scanner对象
        scanner.close();
    }
}

在这个练习中，我们首先导入了Scanner类，然后创建了一个Scanner对象来获取用户的输入。我们使用了nextInt()、next()（对于字符输入，需要通过charAt(0)获取第一个字符），以及nextBoolean()方法来分别获取整数、字符和布尔值类型的输入。最后，不要忘记在使用完Scanner对象后关闭它，以释放相关资源。这可以通过调用Scanner对象的close()方法来实现。