在前两天的学习中，我们已经掌握了前端开发的核心技术 HTML、CSS 和 JavaScript。从今天开始，正式进入 Java 的世界 —— 这是 JavaWeb 开发的核心语言。Java 凭借跨平台性、安全性和稳定性，被广泛应用于企业级开发，学好 Java 基础是掌握 JavaWeb 的前提。今天的重点是系统学习 Java 的基础语法，包括语言特点、基础语法结构、数组及方法等核心内容，为后续的 JavaWeb 学习搭建坚实基础。

---

一、认识 Java 语言

1. Java 的特点

Java 是由 Sun Microsystems（后被 Oracle 收购）于 1995 年推出的编程语言，具有以下显著特性：

• ​​跨平台性​​：这是 Java 最核心的优势之一。通过 "一次编写，到处运行"（Write Once, Run Anywhere）的理念，Java 程序可以在安装了 Java 虚拟机（JVM）的任何操作系统上运行，无需重新编译。
• ​​面向对象​​：Java 是纯面向对象的编程语言，支持封装、继承、多态三大特性，便于代码的复用和维护。
• ​​安全性​​：Java 取消了指针操作，提供了内存自动管理机制（垃圾回收），减少了内存泄漏和非法访问的风险，适合开发安全要求高的应用。
• ​​健壮性​​：Java 具有强大的异常处理机制，能在程序运行时捕获并处理错误，提高程序的稳定性。

2. 验证 Java 环境

在第一天我们已经安装了 JDK，现在验证 Java 环境是否正常工作：

• 打开命令提示符（Windows）或终端（Mac/Linux）。
• 输入 java -version 命令，若显示类似以下信息，说明 Java 环境安装成功：

java version "1.8.0_301"
Java(TM) SE Runtime Environment (build 1.8.0_301-b09)
Java HotSpot(TM) 64-Bit Server VM (build 25.301-b09, mixed mode)

---

二、Java 基础语法

1. 第一个 Java 程序

从经典的 "Hello World" 程序开始，感受 Java 的语法结构：

• 打开 IDE（如 IntelliJ IDEA），创建一个新的 Java 项目，然后新建一个名为 HelloWorld.java 的文件。
• 编写以下代码：

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

• 运行程序，控制台将输出 `Hello, JavaWeb!'。
• ​​代码解释​​：
  • public class HelloWorld：定义了一个公共类，类名必须与文件名一致（包括大小写）。
  • public static void main(String[] args)：这是 Java 程序的入口方法，程序从这里开始执行。其中 public 表示公共访问权限，static 表示静态方法，void 表示无返回值，String[] args 是方法的参数。
  • System.out.println("Hello, JavaWeb!")：用于在控制台输出指定内容，println 会自动换行。

2. 变量与数据类型

变量

变量是用于存储数据的容器，在使用前必须先声明。Java 是强类型语言，变量的类型在声明时就已确定，且不能随意更改。

• ​​声明与赋值语法​​：
  • 声明变量：数据类型 变量名;
  • 赋值：变量名 = 值;
  • 声明时直接赋值：数据类型 变量名 = 值;
• ​​示例​​：

int age; // 声明一个 int 类型的变量 age
age = 20; // 给 age 赋值
String name = "张三"; // 声明并赋值一个 String 类型的变量 name

数据类型

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

• ​​基本数据类型（8 种）​​：
  • 整数类型：byte（1 字节）、short（2 字节）、int（4 字节，最常用）、long（8 字节，赋值时需在数值后加 L，如 100L）。
  • 浮点类型：float（4 字节，赋值时需在数值后加 F，如 3.14F）、double（8 字节，最常用）。
  • 字符类型：char（2 字节，用于表示单个字符，用单引号包裹，如 'A'）。
  • 布尔类型：boolean（1 字节，只有 true 和 false 两个值）。
• ​​引用数据类型​​：包括类（如 String）、接口、数组等，它们指向对象在内存中的地址。

3. 运算符

Java 中的运算符用于执行各种运算，常见的运算符有：

• ​​算术运算符​​：+（加）、-（减）、*（乘）、/（除）、%（取余）、++（自增）、--（自减）。
  • ​​示例​​：

int a = 10;
int b = 3;
System.out.println(a + b); // 输出 13
System.out.println(a / b); // 输出 3（整数相除取整数部分）
System.out.println(a % b); // 输出 1
a++;
System.out.println(a); // 输出 11

• ​​赋值运算符​​：=、+=、-=、*=、/= 等。
  • ​​示例​​：

int c = 5;
c += 3; // 等价于 c = c + 3，结果为 8

• ​​关系运算符​​：==（等于）、!=（不等于）、>（大于）、<（小于）、>=（大于等于）、<=（小于等于），返回值为布尔类型。
  • ​​示例​​：

int d = 7;
int e = 7;
System.out.println(d == e); // 输出 true
System.out.println(d > e); // 输出 false

• ​​逻辑运算符​​：&&（逻辑与，短路与）、||（逻辑或，短路或）、!（逻辑非）。
  • ​​示例​​：

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

4. 流程控制语句

流程控制语句用于控制程序的执行顺序，主要包括分支语句和循环语句。

分支语句

• ​​if - else 语句​​：根据条件执行不同的代码块。
  • ​​示例​​：

int score = 85;
if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 60) {
    System.out.println("及格"); // 输出：及格
} else {
    System.out.println("不及格");
}

• ​​switch 语句​​：根据表达式的值选择执行对应的 case 分支，适用于判断条件为离散值的情况。
  • ​​示例​​：

int week = 3;
switch (week) {
    case 1:
        System.out.println("星期一");
        break;
    case 2:
        System.out.println("星期二");
        break;
    case 3:
        System.out.println("星期三"); // 输出：星期三
        break;
    default:
        System.out.println("其他星期");
}

• ​​注意​​：每个 case 分支后需要加 break 语句，否则会继续执行下一个 case 分支。default 分支用于处理所有未匹配的情况。

循环语句

• ​​for 循环​​：适用于已知循环次数的情况。
  • ​​示例​​：

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

• ​​while 循环​​：适用于未知循环次数，但已知循环条件的情况。
  • ​​示例​​：

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

• ​​do - while 循环​​：与 while 循环类似，但它会先执行一次循环体，再判断循环条件，因此循环体至少会执行一次。
  • ​​示例​​：

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

5. 数组：批量数据的高效管理

数组的定义与本质

数组是相同数据类型元素的有序集合，它在内存中占据一块连续的存储空间。数组的本质是一个容器，能够同时存储多个相同类型的数据，通过索引（下标）可以快速定位和访问元素。例如，存储一个班级 50 名学生的成绩，如果使用单独的变量需要定义 50 个变量，而使用数组只需一个数组即可完成，极大简化了代码。

数组的声明与初始化

• ​​声明数组​​：
  • ​​推荐方式​​：数据类型[] 数组名
  • ​​示例​​：

int[] scores; // 声明一个 int 类型数组，用于存储成绩
String[] names; // 声明一个 String 类型数组，用于存储姓名

• ​​初始化数组​​：数组必须初始化后才能使用，初始化分为动态初始化和静态初始化：
  • ​​动态初始化​​：只指定数组长度，系统自动为元素分配默认值（整数 0、浮点 0.0、布尔 false、引用类型 null）。
    • ​​格式​​：数组名 = new 数据类型[长度]
    • ​​示例​​：

scores = new int[30]; // 初始化一个长度为 30 的 int 数组
scores[0] = 95; // 为第一个元素赋值（索引从 0 开始）
scores[1] = 88;

• ​​静态初始化​​：直接指定元素值，系统自动计算数组长度。
  • ​​完整格式​​：数组名 = new 数据类型[]{元素1, 元素2,...}
  • ​​简化格式（声明时直接初始化）​​：数据类型[] 数组名 = {元素1, 元素2,...}
  • ​​示例​​：

// 完整格式
names = new String[]{"张三", "李四", "王五"};
// 简化格式（声明时直接初始化）
double[] weights = {65.5, 72.3, 58.9};

数组的访问与遍历

• ​​访问数组元素​​：通过 数组名[索引] 访问元素，索引范围是 0 ~ 数组长度 - 1。
  • ​​示例​​：

System.out.println(names[0]); // 输出 "张三"
System.out.println(weights[2]); // 输出 58.9

• ​​注意​​：访问超出范围的索引会抛出 ArrayIndexOutOfBoundsException 异常，这是初学者常见错误。
• ​​遍历数组​​：遍历是指依次访问数组中的所有元素，常用两种方式：
  • ​​普通 for 循环​​：适合需要索引的场景（如修改元素值）。
    • ​​示例​​：

int[] nums = {1, 2, 3, 4, 5};
for (int i = 0; i < nums.length; i++) { // length 是数组的长度属性
    System.out.print(nums[i] + " ");
}
// 输出：1 2 3 4 5

• ​​增强 for 循环（foreach）​​：适合单纯读取元素的场景，语法更简洁。
  • ​​示例​​：

for (int num : nums) { // 变量 num 依次接收数组中的元素
    System.out.print(num + " ");
}
// 输出：1 2 3 4 5

二维数组

二维数组可以理解为 "数组的数组"，常用于表示表格或矩阵结构。

• ​​示例​​：

// 声明并初始化一个 3 行 2 列的二维数组
int[][] matrix = {{1, 2}, {3, 4}, {5, 6}};

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

6. 方法：代码复用的核心

方法的定义与作用

方法（Method）是一段封装特定功能的代码块，定义后可以被多次调用，实现代码复用。例如，计算两个数的和这个功能，用方法实现后，每次需要计算时直接调用即可，无需重复编写代码。

方法的声明格式

修饰符 返回值类型 方法名(参数列表) {
    // 方法体（实现功能的代码）
    return 返回值; // 若返回值类型为 void，则无此句
}

• ​​修饰符​​：目前暂时使用 public static（公共静态）
• ​​返回值类型​​：方法执行后返回结果的类型，无返回值则用 void
• ​​方法名​​：遵循小驼峰命名法（如 calculateSum）
• ​​参数列表​​：方法接收的输入数据，格式为 数据类型 参数名，多个参数用逗号分隔

方法的调用

方法定义后不会自动执行，需要通过调用触发：

• ​​示例​​：

// 定义方法
public static int add(int a, int b) {
    return a + b;
}

// 调用方法
public static void main(String[] args) {
    int result = add(3, 5); // 传入实际参数 3 和 5
    System.out.println(result); // 输出 8
}

方法的参数与返回值

• ​​参数传递​​：
  • 基本数据类型的参数传递是值传递（传递副本，修改不影响原变量）。
  • ​​示例​​：

public static void change(int num) {
    num = 100;
}

public static void main(String[] args) {
    int x = 10;
    change(x);
    System.out.println(x); // 输出 10（原变量未改变）
}

• ​​返回值​​：方法通过 return 语句返回结果，执行到 return 后会立即结束方法。
  • ​​示例​​：

public static int max(int a, int b) {
    if (a > b) {
        return a; // 返回 a 并结束方法
    } else {
        return b; // 返回 b 并结束方法
    }
}

方法的重载

方法重载（Overload）指在同一个类中，多个方法具有相同的方法名，但参数列表（参数个数或类型）不同。重载的方法可以根据参数自动匹配调用。

• ​​示例​​：

// 计算两个 int 的和
public static int add(int a, int b) {
    return a + b;
}

// 计算三个 int 的和（参数个数不同）
public static int add(int a, int b, int c) {
    return a + b + c;
}

// 计算两个 double 的和（参数类型不同）
public static double add(double a, double b) {
    return a + b;
}

---

三、总结与实践

知识点回顾

今天我们学习了 Java 的基础语法，包括：

• Java 的特点和环境验证方法。
• 第一个 Java 程序的结构和运行方式。
• 变量的声明与赋值，以及 Java 的数据类型（基本数据类型和引用数据类型）。
• 常用运算符（算术运算符、赋值运算符、关系运算符、逻辑运算符）。
• 流程控制语句（if - else、switch 分支语句；for、while、do - while 循环语句）。
• 数组的声明、初始化、访问和遍历（普通 for 循环与 foreach）以及二维数组的基本使用。
• 方法的定义、调用、参数传递、返回值和方法重载的概念及应用。

实践任务

1. ​​基础计算器​​：编写一个 Java 程序，接收用户输入的两个整数（使用 Scanner 类，需要导入 java.util.Scanner 包），计算并输出它们的和、差、积、商（整数商）和余数。
2. ​​数字筛选​​：编写一个 Java 程序，使用循环语句输出 1 到 100 之间所有能被 3 整除的数，每行输出 5 个。
3. ​​数组操作​​：定义一个长度为 10 的 int 数组，随机生成 10 个 1 - 100 之间的整数存入数组，然后计算数组中所有元素的平均值、找出数组中的最大值和最小值、将数组元素按从小到大的顺序排序并输出。
4. ​​工具类​​：定义一个工具类 ArrayUtils，包含以下静态方法：
   • printArray(int[] arr)：打印数组元素，格式：[1, 2, 3]
   • sumArray(int[] arr)：计算数组元素总和
   • reverseArray(int[] arr)：反转数组元素，如 [1, 2, 3] 变为 [3, 2, 1]

​​提示​​：Scanner 类的使用示例：

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 后续代码...
    }
}