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

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

Java的数据类型

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

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

  • 整数类型：byte（1字节）、short（2字节）、int（4字节）、long（8字节）
  • 浮点数类型：float（4字节）、double（8字节）
  • 字符类型：char（2字节，用于存储Unicode字符）
  • 布尔类型：boolean（1位，用于存储true或false）

  示例：

  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;
  

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

  示例：

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

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

数据类型转换

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

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

  • 转换规则：byte → short → int → long → float → double
  • char → int

  示例：

  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
  

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

  • 转换格式：目标数据类型 变量名 = (目标数据类型)源数据;

  示例：

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

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

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

运算符

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

算术运算符

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

示例：

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

关系运算符

用于比较两个表达式的值，返回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（比较内容）

逻辑运算符

用于进行逻辑运算，返回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

赋值运算符

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

示例：

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

条件运算符

条件运算符是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

流程控制

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

顺序结构

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

示例：

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

分支结构

分支结构用于根据条件执行不同的代码块，包括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不匹配的情况。

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

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穿透'）。

循环结构

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

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

for循环示例：

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

while循环示例：

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

do-while循环示例：

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

循环控制语句

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

• 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
  

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

  示例：

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

• 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
  

常见问题与解决方案

变量未初始化

问题：编译时提示'错误: 可能尚未初始化变量'。 解决方案：在使用变量之前，必须先声明并初始化。例如：

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

数据类型转换错误

问题1：编译时提示'错误: 不兼容的类型: 从double转换到int可能会有损失'。 解决方案：使用强制类型转换。例如：

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

问题2：运行时出现数据溢出。 解决方案：使用更大范围的数据类型。例如：

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

循环死循环

问题：程序运行时陷入死循环，无法结束。 解决方案：检查循环条件和迭代语句，确保循环能够正常结束。例如：

// 死循环：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);
}

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的面向对象编程。