Java 核心语法：从变量到流程控制

示例：

int age; // 定义一个 int 类型的变量
age = 18; // 给变量 age 赋值为 18
int height = 175; // 定义并初始化一个 int 类型的变量 height

⚠️ 注意：在使用变量之前，必须先声明并初始化，否则会导致编译错误。

2.2.2 Java 的数据类型

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

• 整数类型：byte（1 字节）、short（2 字节）、int（4 字节）、long（8 字节）
• 浮点数类型：float（4 字节）、double（8 字节）
• 字符类型：char（2 字节，用于存储 Unicode 字符）
• 布尔类型：boolean（1 位，用于存储 true 或 false）
• 引用类型：类（如 String、HelloWorld 等）、接口（如 Runnable、Serializable 等）、数组（如 int[]、String[] 等）

引用数据类型：存储的是数据的引用（即内存地址），包括类、接口、数组等。

示例：

String name = "张三"; // String 是一个类，name 是引用变量
int[] nums = {1, 2, 3}; // nums 是数组引用变量

基本数据类型：直接存储数据的值，包括 8 种类型。

示例：

byte b = 10;
short s = 200;
int i = 1000;
long l = 1000000L; // 注意：long 类型的字面量后面要加 L 或 l
float f = 3.14F; // 注意：float 类型的字面量后面要加 F 或 f
double d = 3.1415926;
char c = 'A';
boolean flag = true;

💡 基本数据类型与引用数据类型的区别：

2.2.3 数据类型转换

在 Java 中，当将一种数据类型转换为另一种数据类型时，需要遵循一定的规则。数据类型转换分为自动类型转换和强制类型转换。

• 转换规则：byte → short → int → long → float → double
• char → int
• 转换格式：目标数据类型 变量名 = (目标数据类型) 源数据;

强制类型转换：当将一个大范围的数据类型转换为小范围的数据类型时，需要显式指定，否则会导致编译错误。

示例：

int i = 1000;
byte b = (byte)i; // 强制将 int 转换为 byte

⚠️ 注意：强制类型转换可能会导致数据溢出或精度丢失，应谨慎使用。例如：

int i = 128;
byte b = (byte)i; // byte 的范围是 -128 到 127，转换后 b 的值为 -128（溢出）

自动类型转换：当将一个小范围的数据类型转换为大范围的数据类型时，会自动进行转换，无需显式指定。

示例：

byte b = 10;
short s = b; // 自动将 byte 转换为 short
int i = s; // 自动将 short 转换为 int
long l = i; // 自动将 int 转换为 long
float f = l; // 自动将 long 转换为 float
double d = f; // 自动将 float 转换为 double

2.3 运算符

运算符是用于对数据进行运算的符号。Java 支持多种运算符：

2.3.1 算术运算符

用于进行算术运算，包括：+（加）、-（减）、*（乘）、/（除）、%（取模）、++（自增）、--（自减）。

示例：

int a = 10;
int 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（取模运算，即余数）
a++; // 相当于 a = a + 1
System.out.println(a); // 输出 11
--b; // 相当于 b = b - 1
System.out.println(b); // 输出 2

⚠️ 注意：++ 和 -- 运算符可以放在变量的前面或后面，放在前面表示先自增/自减，再使用变量的值；放在后面表示先使用变量的值，再自增/自减。例如：

int a = 10;
int b = ++a; // a 先自增为 11，然后 b 赋值为 11
System.out.println(b); // 输出 11
int c = 10;
int d = c++; // c 先赋值给 d（d 为 10），然后 c 自增为 11
System.out.println(d); // 输出 10

2.3.2 关系运算符

用于比较两个表达式的值，返回 boolean 类型的结果，包括：==（等于）、!=（不等于）、>（大于）、<（小于）、>=（大于等于）、<=（小于等于）。

示例：

int a = 10;
int 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

⚠️ 注意：不要将==用于比较引用数据类型的内容，应该使用 equals() 方法。例如：

String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");
System.out.println(s1 == s2); // 输出 true（因为字符串常量池的原因）
System.out.println(s1 == s3); // 输出 false（s3 指向堆内存中的对象）
System.out.println(s1.equals(s3)); // 输出 true（比较内容）

2.3.3 逻辑运算符

用于进行逻辑运算，返回 boolean 类型的结果，包括：&&（逻辑与）、||（逻辑或）、!（逻辑非）。

• &&：当两个操作数都为 true 时，结果为 true，否则为 false。如果第一个操作数为 false，第二个操作数不会被执行（短路与）。
• ||：当两个操作数都为 false 时，结果为 false，否则为 true。如果第一个操作数为 true，第二个操作数不会被执行（短路或）。
• !：当操作数为 true 时，结果为 false；当操作数为 false 时，结果为 true。

示例：

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

2.3.4 赋值运算符

用于给变量赋值，包括：=（简单赋值）、+=（加赋值）、-=（减赋值）、*=（乘赋值）、/=（除赋值）、%=（取模赋值）。

示例：

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 %= 5; // 相当于 a = a % 5，结果为 1

2.3.5 条件运算符

条件运算符是 Java 中唯一的三元运算符，格式为：条件表达式 ? 表达式 1 : 表达式 2。当条件表达式为 true 时，执行表达式 1；当条件表达式为 false 时，执行表达式 2。

示例：

int a = 10;
int b = 20;
int max = a > b ? a : b; // 如果 a > b 为 true，max = a；否则 max = b
System.out.println(max); // 输出 20

2.4 流程控制

流程控制用于控制程序的执行顺序，包括顺序结构、分支结构和循环结构。

2.4.1 顺序结构

顺序结构是程序默认的执行顺序，即按照代码的编写顺序从上到下依次执行。

示例：

int a = 10;
int b = 20;
int sum = a + b;
System.out.println("sum = " + sum); // 输出 sum = 30

2.4.2 分支结构

分支结构用于根据条件执行不同的代码块，包括 if-else 语句和 switch 语句。

• if 语句：当条件为 true 时，执行 if 块中的代码。
• if-else 语句：当条件为 true 时，执行 if 块中的代码；否则，执行 else 块中的代码。
• if-else if-else 语句：用于处理多个条件。
• switch 语句：用于根据表达式的值执行不同的代码块。表达式的值可以是 byte、short、int、char、String（JDK 7 及以后）或枚举类型。
• case：后面跟表达式可能的值，break 用于跳出 switch 语句。
• default：用于处理所有 case 不匹配的情况。

switch 语句示例：

String day = "Monday";
switch(day){
    case "Monday":
        System.out.println("星期一");
        break;
    case "Tuesday":
        System.out.println("星期二");
        break;
    case "Wednesday":
        System.out.println("星期三");
        break;
    case "Thursday":
        System.out.println("星期四");
        break;
    case "Friday":
        System.out.println("星期五");
        break;
    case "Saturday":
    case "Sunday":
        System.out.println("周末");
        break;
    default:
        System.out.println("无效的星期");
        break;
}
// 输出：星期一

⚠️ 注意：如果 case 后面没有 break 语句，程序会继续执行下一个 case 中的代码，直到遇到 break 或 switch 语句结束（称为'case 穿透'）。

if-else 语句示例：

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("不及格");
}
// 输出：良好

2.4.3 循环结构

循环结构用于重复执行一段代码，包括 for 循环、while 循环和 do-while 循环。

• for 循环：用于已知循环次数的情况。格式：for (初始化语句; 循环条件; 迭代语句) { 循环体 }
• while 循环：用于未知循环次数的情况。格式：while (循环条件) { 循环体; 迭代语句 }
• do-while 循环：与 while 循环类似，但会先执行一次循环体，然后再判断循环条件。格式：do { 循环体; 迭代语句 } while (循环条件);

do-while 循环示例：

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

while 循环示例：

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

for 循环示例：

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

2.4.4 循环控制语句

循环控制语句用于控制循环的执行流程，包括 break、continue 和 return。

return：用于从当前方法中返回，结束方法的执行。

示例：

// 输出 1 到 5 的整数，当 i 等于 6 时返回
public static void main(String[] args){
    for(int i = 1; i <= 10; i++){
        if(i == 6){
            return;
        }
        System.out.println(i);
    }
}
// 输出：1 2 3 4 5

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

示例：

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

break：用于跳出当前循环（如 for、while、do-while）或 switch 语句。

示例：

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

2.5 常见问题与解决方案

2.5.1 变量未初始化

问题：编译时提示'错误：可能尚未初始化变量'。

解决方案：在使用变量之前，必须先声明并初始化。例如：

int a; // 只声明未初始化
System.out.println(a); // 编译错误
int b = 0; // 声明并初始化
System.out.println(b); // 编译成功

2.5.2 数据类型转换错误

问题 1：编译时提示'错误：不兼容的类型：从 double 转换到 int 可能会有损失'。

解决方案：使用强制类型转换。例如：

double d = 3.14;
int i = (int)d; // 强制转换

问题 2：运行时出现数据溢出。

解决方案：使用更大范围的数据类型。例如：

int i = 128;
byte b = (byte)i; // 溢出，结果为 -128
long l = 128; // 使用 long 类型

2.5.3 循环死循环

问题：程序运行时陷入死循环，无法结束。

解决方案：检查循环条件和迭代语句，确保循环能够正常结束。例如：

// 死循环：i 的初始值为 1，循环条件 i <= 10，但迭代语句是 i--
for(int i = 1; i <= 10; i--){
    System.out.println(i);
}
// 正确的循环：迭代语句是 i++
for(int i = 1; i <= 10; i++){
    System.out.println(i);
}

2.5.4 switch 语句的 case 穿透

问题：执行 switch 语句时，多个 case 的代码都被执行。

解决方案：在每个 case 的代码块后面添加 break 语句。例如：

int num = 2;
switch(num){
    case 1:
        System.out.println("1");
    case 2:
        System.out.println("2");
    case 3:
        System.out.println("3");
        break;
}
// 输出：2 3（case 穿透）

// 正确的写法：添加 break 语句
switch(num){
    case 1:
        System.out.println("1");
        break;
    case 2:
        System.out.println("2");
        break;
    case 3:
        System.out.println("3");
        break;
}
// 输出：2

总结

本章我们学习了 Java 的核心语法，包括语法基础、变量与数据类型、运算符以及流程控制。其中，基本数据类型与引用数据类型的区别、自动类型转换与强制类型转换的规则、流程控制语句的使用是本章的重点内容。从下一章开始，我们将学习 Java 的面向对象编程。