4. Java基础语法

Java基础语法是学习Java编程的基础，掌握好基础语法对于后续学习Java面向对象编程和Java进阶知识非常重要。

预备-创建一个类Java类

在学习Java语法之前，得知道怎么写一个程序。上一节已经装好了开发工具。这里IntelliJ IDEA为例子，编写一个Main方法。打开IntelliJ IDEA，创建一个项目，并创建一个类。先在本地创建一个文件夹，用于存放项目。

点击File -> New -> Project。
在New Project对话框中，选择Java作为项目类型。
点击Next。
在Project Name字段中输入项目名称，例如java-learn-1。
点击Finish。
在新建的项目中创建HelloWorld类。
在HelloWorld类中编写main方法。

java

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

控制台输出了一个Hello World!。

你学会了如何创建类，并运行类的主方法。关于类和类的主方法的内容将会在Java的面向对象编程中介绍。

4.1 Java注释

注释是用来解释代码的，它不会被编译器编译。在Java中，有三种注释方式：

4.1.1 单行注释

单行注释以//开头，用于注释单行代码。

java

// 这是一个单行注释
int age = 18; // 这也是一个单行注释，注释变量age的作用

4.1.2 多行注释

多行注释以/*开头，以*/结尾，用于注释多行代码。

java

/*
这是一个多行注释
可以注释多行代码
用于解释复杂的代码块
*/
int sum = 0;
for (int i = 0; i < 10; i++) {
    sum += i;
}

4.1.3 文档注释

文档注释以/**开头，以*/结尾，用于生成API文档。

java

/**
 * 这是一个文档注释
 * 用于生成API文档
 * @param a 第一个参数
 * @param b 第二个参数
 * @return 两个参数的和
 */
public int add(int a, int b) {
    return a + b;
}

4.2 Java标识符与关键字

4.2.1 标识符

标识符是用来给类、方法、变量等命名的符号。在Java中，标识符的命名规则如下：

标识符由字母、数字、下划线（_）和美元符号（$）组成
标识符不能以数字开头
标识符不能是Java关键字
标识符区分大小写
标识符的长度没有限制

命名规范：

类名：首字母大写，采用驼峰命名法（如：HelloWorld、UserInfo）
方法名：首字母小写，采用驼峰命名法（如：getName、setAge）
变量名：首字母小写，采用驼峰命名法（如：userName、password）
常量名：全部大写，单词之间用下划线分隔（如：MAX_VALUE、PI）

4.2.2 关键字

关键字是Java语言中已经被赋予特定含义的单词，不能用作标识符。Java中的关键字如下：

类别	关键字
访问控制	private, protected, public
类、方法和变量修饰符	abstract, class, extends, final, implements, interface, native, new, static, strictfp, synchronized, transient, volatile
程序控制语句	break, case, catch, continue, default, do, else, finally, for, if, instanceof, return, switch, throw, throws, try, while
异常处理	assert
包相关	import, package
基本数据类型	boolean, byte, char, double, float, int, long, short
变量引用	super, this, void
保留字	goto, const

以上只是部分关键字，随着java版本更新，还有新的关键字，比如java 11新增的关键字var， java17新增的record等。

4.3 Java数据类型

Java中的数据类型分为两大类：基本数据类型和引用数据类型。

4.3.1 基本数据类型

基本数据类型是Java内置的数据类型，包括：

数据类型	大小	范围	默认值	示例
byte	1字节	-128 ~ 127	0	byte b = 100;
short	2字节	-32768 ~ 32767	0	short s = 1000;
int	4字节	-2^31 ~ 2^31-1	0	int i = 100000;
long	8字节	-2^63 ~ 2^63-1	0L	long l = 100000L;
float	4字节	3.4e-038 ~ 3.4e+038	0.0f	float f = 3.14f;
double	8字节	1.7e-308 ~ 1.7e+308	0.0d	double d = 3.14;
char	2字节	0 ~ 65535	'\u0000'	char c = 'A';
boolean	1位	true / false	false	boolean b = true;

4.3.2 引用数据类型

引用数据类型是指指向对象的引用，包括：

类（如：String、ArrayList等）
接口（如：Runnable、Comparable等）
数组

引用数据类型的默认值是null。

4.3.3 数据类型转换

在Java中，数据类型转换分为两种：自动类型转换和强制类型转换。

4.3.3.1 自动类型转换

自动类型转换是指将小范围的数据类型转换为大范围的数据类型，不需要显式转换。

java

byte b = 100;
int i = b; // 自动类型转换，byte -> int
long l = i; // 自动类型转换，int -> long
float f = l; // 自动类型转换，long -> float
double d = f; // 自动类型转换，float -> double

4.3.3.2 强制类型转换

强制类型转换是指将大范围的数据类型转换为小范围的数据类型，需要显式转换。

java

int i = 100;
byte b = (byte) i; // 强制类型转换，int -> byte

double d = 3.14;
int num = (int) d; // 强制类型转换，double -> int，结果为3，小数部分被截断

注意： 强制类型转换可能会导致数据丢失或溢出，因此在使用时需要谨慎。

4.4 变量与常量

4.4.1 变量

变量是用来存储数据的容器，它的值可以改变。在Java中，变量的声明和初始化如下：

4.4.1.1 变量的声明

java

// 声明一个int类型的变量age
int age;

// 声明多个同类型的变量
int a, b, c;

4.4.1.2 变量的初始化

java

// 声明并初始化变量
int age = 18;

// 先声明，后初始化
int score;
score = 90;

// 声明多个变量并初始化
int x = 10, y = 20, z = 30;

4.4.1.3 变量的作用域

变量的作用域是指变量可以被访问的范围，主要分为：

局部变量：在方法或代码块中声明的变量，作用域仅限于方法或代码块内部
成员变量：在类中声明的变量，作用域仅限于类内部
静态变量：在类中使用static关键字声明的变量，作用域为整个类

java

public class VariableScope {
    // 成员变量
    int memberVar = 100;
    
    // 静态变量
    static int staticVar = 200;
    
    public void method() {
        // 局部变量
        int localVar = 300;
        System.out.println(localVar); // 可以访问
    }
    
    public void anotherMethod() {
        System.out.println(memberVar); // 可以访问
        System.out.println(staticVar); // 可以访问
        // System.out.println(localVar); // 无法访问，因为localVar是method()方法的局部变量
    }
}

4.4.2 常量

常量是指一旦初始化后，其值就不能改变的变量。在Java中，使用final关键字来声明常量。

java

// 声明一个常量PI
final double PI = 3.14159;

// 常量名通常全部大写，单词之间用下划线分隔
final int MAX_VALUE = 100;
final String COMPANY_NAME = "Java Company";

4.5 运算符

运算符是用来对数据进行操作的符号。在Java中，运算符主要分为以下几类：

4.5.1 算术运算符

算术运算符用于进行算术运算，包括：

运算符	描述	示例
+	加法	a + b
-	减法	a - b
*	乘法	a * b
/	除法	a / b
%	取模（余数）	a % b
++	自增	a++ 或 ++a
--	自减	a-- 或 --a

示例：

java

int a = 10, b = 3;
System.out.println(a + b); // 输出13
System.out.println(a - b); // 输出7
System.out.println(a * b); // 输出30
System.out.println(a / b); // 输出3，整数除法，小数部分被截断
System.out.println(a % b); // 输出1，余数

int c = 5;
System.out.println(c++); // 输出5，先输出c的值，再自增
System.out.println(++c); // 输出7，先自增，再输出c的值

4.5.2 赋值运算符

赋值运算符用于给变量赋值，包括：

运算符	描述	示例
=	简单赋值	a = b
+=	加法赋值	a += b 等价于 a = a + b
-=	减法赋值	a -= b 等价于 a = a - b
*=	乘法赋值	a = b 等价于 a = a b
/=	除法赋值	a /= b 等价于 a = a / b
%=	取模赋值	a %= b 等价于 a = a % b

示例：

java

int a = 10;
a += 5; // 等价于 a = a + 5，结果为15
a -= 3; // 等价于 a = a - 3，结果为12
a *= 2; // 等价于 a = a * 2，结果为24
a /= 4; // 等价于 a = a / 4，结果为6
a %= 2; // 等价于 a = a % 2，结果为0

4.5.3 比较运算符

比较运算符用于比较两个值的大小，返回布尔类型的结果（true或false）。

运算符	描述	示例
==	等于	a == b
!=	不等于	a != b
>	大于	a > b
<	小于	a < b
>=	大于等于	a >= b
<=	小于等于	a <= b

示例：

java

int a = 10, b = 20;
System.out.println(a == b); // 输出false
System.out.println(a != b); // 输出true
System.out.println(a > b); // 输出false
System.out.println(a < b); // 输出true
System.out.println(a >= b); // 输出false
System.out.println(a <= b); // 输出true

4.5.4 逻辑运算符

逻辑运算符用于连接布尔表达式，返回布尔类型的结果。

运算符	描述	示例	短路特性
&&	逻辑与	a && b	如果a为false，则不执行b
\|\|	逻辑或	a \|\| b	如果a为true，则不执行b
!	逻辑非	!a	无

示例：

java

boolean a = true, b = false;
System.out.println(a && b); // 输出false
System.out.println(a || b); // 输出true
System.out.println(!a); // 输出false
System.out.println(!b); // 输出true

4.5.5 位运算符

位运算符用于对二进制位进行操作，包括：

运算符	描述	示例
&	按位与	a & b
\|	按位或	a \| b
^	按位异或	a ^ b
~	按位取反	~a
<<	左移	a << b
>>	右移	a >> b
>>>	无符号右移	a >>> b

示例：

java

int a = 6; // 二进制：0110
int b = 3; // 二进制：0011

System.out.println(a & b); // 输出2，二进制：0010
System.out.println(a | b); // 输出7，二进制：0111
System.out.println(a ^ b); // 输出5，二进制：0101
System.out.println(~a); // 输出-7，二进制：11111111111111111111111111111001
System.out.println(a << 1); // 输出12，二进制：1100，左移1位相当于乘以2
System.out.println(a >> 1); // 输出3，二进制：0011，右移1位相当于除以2

4.5 控制流程

控制流程用于控制程序的执行顺序，包括条件语句和循环语句。

4.5.1 条件语句

4.5.1.1 if-else语句

if-else语句用于根据条件执行不同的代码块。

java

int score = 85;

if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 80) {
    System.out.println("良好");
} else if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}

4.5.1.2 switch-case语句

switch-case语句用于根据表达式的值执行不同的代码块。

java

int day = 3;

switch (day) {
    case 1:
        System.out.println("星期一");
        break;
    case 2:
        System.out.println("星期二");
        break;
    case 3:
        System.out.println("星期三");
        break;
    case 4:
        System.out.println("星期四");
        break;
    case 5:
        System.out.println("星期五");
        break;
    case 6:
        System.out.println("星期六");
        break;
    case 7:
        System.out.println("星期日");
        break;
    default:
        System.out.println("无效的星期");
        break;
}

注意： 在switch-case语句中，每个case后面都需要添加break语句，否则会发生穿透现象，即执行完当前case后，会继续执行下一个case，直到遇到break语句或switch语句结束。

4.5.2 循环语句

4.5.2.1 for循环

for循环用于重复执行一段代码，适合已知循环次数的情况。

java

// 输出1到10的数字
for (int i = 1; i <= 10; i++) {
    System.out.println(i);
}

// 输出1到100的和
int sum = 0;
for (int i = 1; i <= 100; i++) {
    sum += i;
}
System.out.println("1到100的和为：" + sum);

4.5.2.2 while循环

while循环用于重复执行一段代码，适合未知循环次数的情况。

java

// 输出1到10的数字
int i = 1;
while (i <= 10) {
    System.out.println(i);
    i++;
}

// 猜数字游戏
int randomNum = (int) (Math.random() * 100) + 1;
int guess = 0;
while (guess != randomNum) {
    // 假设这里有输入代码
    guess = 50; // 示例输入
}

4.5.2.3 do-while循环

do-while循环用于重复执行一段代码，至少执行一次，适合未知循环次数的情况。

java

// 输出1到10的数字
int i = 1;
do {
    System.out.println(i);
    i++;
} while (i <= 10);

// 猜数字游戏
int randomNum = (int) (Math.random() * 100) + 1;
int guess = 0;
do {
    // 假设这里有输入代码
    guess = 50; // 示例输入
} while (guess != randomNum);

4.5.3 跳转语句

跳转语句用于改变程序的执行流程，包括：

4.5.3.1 break语句

break语句用于跳出循环或switch语句。

java

// 输出1到5的数字，当i等于6时跳出循环
for (int i = 1; i <= 10; i++) {
    if (i == 6) {
        break;
    }
    System.out.println(i);
}

4.5.3.2 continue语句

continue语句用于跳过当前循环的剩余部分，继续执行下一次循环。

java

// 输出1到10中的奇数
for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
        continue;
    }
    System.out.println(i);
}

4.5.3.3 return语句

return语句用于结束方法的执行，并返回一个值（如果方法有返回值）。

java

public int add(int a, int b) {
    return a + b; // 结束方法的执行，并返回a + b的值
}

4.6 数组

数组是用来存储相同类型数据的集合。在Java中，数组的声明、初始化和访问如下：

4.6.1 数组的声明

java

// 声明一个int类型的数组
int[] arr1;

// 另一种声明方式
int arr2[];

4.6.2 数组的初始化

4.6.2.1 静态初始化

java

// 静态初始化数组
int[] arr1 = {1, 2, 3, 4, 5};

// 另一种静态初始化方式
int[] arr2 = new int[]{1, 2, 3, 4, 5};

4.6.2.2 动态初始化

java

// 动态初始化数组，指定数组长度为5，默认值为0
int[] arr = new int[5];

4.6.3 数组的访问

java

int[] arr = {1, 2, 3, 4, 5};

// 访问数组元素，数组索引从0开始
System.out.println(arr[0]); // 输出1
System.out.println(arr[1]); // 输出2
System.out.println(arr[2]); // 输出3

// 修改数组元素
arr[0] = 10;
System.out.println(arr[0]); // 输出10

// 获取数组长度
System.out.println(arr.length); // 输出5

4.6.4 数组的遍历

4.6.4.1 for循环遍历

java

int[] arr = {1, 2, 3, 4, 5};

// 使用for循环遍历数组
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

4.6.4.2 增强for循环遍历

java

int[] arr = {1, 2, 3, 4, 5};

// 使用增强for循环遍历数组
for (int num : arr) {
    System.out.println(num);
}

4.6.5 多维数组

多维数组是指数组的数组，最常见的是二维数组。

4.6.5.1 二维数组的声明与初始化

java

// 静态初始化二维数组
int[][] arr1 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

// 动态初始化二维数组，指定行数为3，列数为3
int[][] arr2 = new int[3][3];

// 动态初始化二维数组，指定行数为3，列数不指定
int[][] arr3 = new int[3][];
arr3[0] = new int[2];
arr3[1] = new int[3];
arr3[2] = new int[4];

4.6.5.2 二维数组的遍历

java

int[][] arr = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

// 使用for循环遍历二维数组
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        System.out.print(arr[i][j] + " ");
    }
    System.out.println();
}

// 使用增强for循环遍历二维数组
for (int[] row : arr) {
    for (int num : row) {
        System.out.print(num + " ");
    }
    System.out.println();
}

4.7 小结

Java注释包括单行注释、多行注释和文档注释
标识符是用来给类、方法、变量等命名的符号，需要遵循命名规则
Java关键字是已经被赋予特定含义的单词，不能用作标识符
Java数据类型分为基本数据类型和引用数据类型
变量是用来存储数据的容器，它的值可以改变
常量是指一旦初始化后，其值就不能改变的变量
Java运算符包括算术运算符、赋值运算符、比较运算符、逻辑运算符和位运算符
控制流程包括条件语句（if-else、switch-case）和循环语句（for、while、do-while）
数组是用来存储相同类型数据的集合，可以是一维数组或多维数组

通过学习本章，你已经掌握了Java基础语法的核心内容。以上是Java的基本功，可以不熟练，但是一定得知道有这个东西，要能写出来，才能进行后续学习。当然熟练更好。接下来，我们将介绍Java面向对象编程，这是Java编程的核心思想。

4. Java基础语法 ​

预备-创建一个类Java类 ​

4.1 Java注释 ​

4.1.1 单行注释 ​

4.1.2 多行注释 ​

4.1.3 文档注释 ​

4.2 Java标识符与关键字 ​

4.2.1 标识符 ​

4.2.2 关键字 ​

4.3 Java数据类型 ​

4.3.1 基本数据类型 ​

4.3.2 引用数据类型 ​

4.3.3 数据类型转换 ​

4.3.3.1 自动类型转换 ​

4.3.3.2 强制类型转换 ​

4.4 变量与常量 ​

4.4.1 变量 ​

4.4.1.1 变量的声明 ​

4.4.1.2 变量的初始化 ​

4.4.1.3 变量的作用域 ​

4.4.2 常量 ​

4.5 运算符 ​

4.5.1 算术运算符 ​

4.5.2 赋值运算符 ​

4.5.3 比较运算符 ​

4.5.4 逻辑运算符 ​

4.5.5 位运算符 ​

4.5 控制流程 ​

4.5.1 条件语句 ​

4.5.1.1 if-else语句 ​

4.5.1.2 switch-case语句 ​

4.5.2 循环语句 ​

4.5.2.1 for循环 ​

4.5.2.2 while循环 ​

4.5.2.3 do-while循环 ​

4.5.3 跳转语句 ​

4.5.3.1 break语句 ​

4.5.3.2 continue语句 ​

4.5.3.3 return语句 ​

4.6 数组 ​

4.6.1 数组的声明 ​

4.6.2 数组的初始化 ​

4.6.2.1 静态初始化 ​

4.6.2.2 动态初始化 ​

4.6.3 数组的访问 ​

4.6.4 数组的遍历 ​

4.6.4.1 for循环遍历 ​

4.6.4.2 增强for循环遍历 ​

4.6.5 多维数组 ​

4.6.5.1 二维数组的声明与初始化 ​

4.6.5.2 二维数组的遍历 ​

4.7 小结 ​

4. Java基础语法

预备-创建一个类Java类

4.1 Java注释

4.1.1 单行注释

4.1.2 多行注释

4.1.3 文档注释

4.2 Java标识符与关键字

4.2.1 标识符

4.2.2 关键字

4.3 Java数据类型

4.3.1 基本数据类型

4.3.2 引用数据类型

4.3.3 数据类型转换

4.3.3.1 自动类型转换

4.3.3.2 强制类型转换

4.4 变量与常量

4.4.1 变量

4.4.1.1 变量的声明

4.4.1.2 变量的初始化

4.4.1.3 变量的作用域

4.4.2 常量

4.5 运算符

4.5.1 算术运算符

4.5.2 赋值运算符

4.5.3 比较运算符

4.5.4 逻辑运算符

4.5.5 位运算符

4.5 控制流程

4.5.1 条件语句

4.5.1.1 if-else语句

4.5.1.2 switch-case语句

4.5.2 循环语句

4.5.2.1 for循环

4.5.2.2 while循环

4.5.2.3 do-while循环

4.5.3 跳转语句

4.5.3.1 break语句

4.5.3.2 continue语句

4.5.3.3 return语句

4.6 数组

4.6.1 数组的声明

4.6.2 数组的初始化

4.6.2.1 静态初始化

4.6.2.2 动态初始化

4.6.3 数组的访问

4.6.4 数组的遍历

4.6.4.1 for循环遍历

4.6.4.2 增强for循环遍历

4.6.5 多维数组

4.6.5.1 二维数组的声明与初始化

4.6.5.2 二维数组的遍历

4.7 小结