Java 基本语法详解（三）

Java 基本语法详解（三）

七、数组的深入用法

数组是存储多个同类型数据的容器，在 Java 中属于引用数据类型，除了基础的一维数组遍历，还包括二维数组、数组常见操作（如排序、查找）等核心用法。

1. 二维数组（数组的数组）

二维数组用于存储 “表格型” 数据（如行和列的结构），本质是 “一维数组中的每个元素都是一个一维数组”。

（1）二维数组的定义与初始化

格式：

// 方式1：声明并初始化（不规则二维数组，每行长度可不同）
数据类型[][] 数组名 = {{元素1, 元素2}, {元素3}, {元素4, 元素5, 元素6}};

// 方式2：指定行数和列数，后续赋值（规则二维数组，每行长度相同）
数据类型[][] 数组名 = new 数据类型[行数][列数];

// 方式3：先指定行数，列数后续确定（不规则二维数组）
数据类型[][] 数组名 = new 数据类型[行数][];

示例 1：初始化并遍历规则二维数组（3 行 2 列）

public class TwoDArrayDemo1 {
    public static void main(String[] args) {
        // 初始化3行2列的二维数组（存储学生成绩：行=学生，列=科目）
        int[][] scores = {{85, 92}, {78, 88}, {95, 90}};
        
        // 遍历二维数组：外层循环控制行，内层循环控制列
        for (int i = 0; i < scores.length; i++) { // scores.length 是行数
            System.out.print("第" + (i+1) + "个学生成绩：");
            for (int j = 0; j < scores[i].length; j++) { // scores[i].length 是第i行的列数
                System.out.print(scores[i][j] + " ");
            }
            System.out.println(); // 换行
        }
    }
}

输出结果：

第1个学生成绩：85 92 
第2个学生成绩：78 88 
第3个学生成绩：95 90 

示例 2：初始化不规则二维数组

public class TwoDArrayDemo2 {
    public static void main(String[] args) {
        // 先指定3行，列数后续确定（每行长度不同）
        String[][] names = new String[3][];
        names[0] = new String[]{"Alice", "Bob"}; // 第1行2个元素
        names[1] = new String[]{"Charlie"};      // 第2行1个元素
        names[2] = new String[]{"David", "Eve", "Frank"}; // 第3行3个元素
        
        // 增强for循环遍历
        int row = 1;
        for (String[] rowArr : names) {
            System.out.print("第" + row + "行：");
            for (String name : rowArr) {
                System.out.print(name + " ");
            }
            System.out.println();
            row++;
        }
    }
}

输出结果：

第1行：Alice Bob 
第2行：Charlie 
第3行：David Eve Frank 

2. 数组的常见操作（工具类辅助）

Java 提供java.util.Arrays工具类，封装了数组排序、查找、填充等常用操作，无需手动实现复杂逻辑。

（1）数组排序（sort () 方法）

Arrays.sort(数组)：对数组进行升序排序（基本数据类型），对字符串按字典序排序。

示例：

import java.util.Arrays; // 导入Arrays工具类

public class ArraySortDemo {
    public static void main(String[] args) {
        int[] nums = {3, 1, 4, 1, 5, 9};
        System.out.println("排序前：" + Arrays.toString(nums)); // 打印数组（需用Arrays.toString()）
        
        Arrays.sort(nums); // 升序排序
        System.out.println("排序后：" + Arrays.toString(nums));
    }
}

输出结果：

排序前：[3, 1, 4, 1, 5, 9]
排序后：[1, 1, 3, 4, 5, 9]

（2）数组查找（binarySearch () 方法）

Arrays.binarySearch(数组, 目标值)：在已排序的数组中查找目标值，返回索引（若未找到，返回负数）。

示例：

import java.util.Arrays;

public class ArraySearchDemo {
    public static void main(String[] args) {
        int[] sortedNums = {1, 3, 5, 7, 9}; // 已排序数组
        int target = 5;
        
        // 查找目标值的索引
        int index = Arrays.binarySearch(sortedNums, target);
        if (index >= 0) {
            System.out.println("目标值" + target + "在索引" + index + "处");
        } else {
            System.out.println("目标值" + target + "未找到");
        }
    }
}

输出结果：

目标值5在索引2处

（3）数组填充（fill () 方法）

Arrays.fill(数组, 填充值)：将数组中所有元素替换为指定填充值。

示例：

import java.util.Arrays;

public class ArrayFillDemo {
    public static void main(String[] args) {
        int[] arr = new int[5]; // 初始化长度为5的数组（默认值0）
        System.out.println("填充前：" + Arrays.toString(arr));
        
        Arrays.fill(arr, 8); // 所有元素填充为8
        System.out.println("填充后：" + Arrays.toString(arr));
    }
}

输出结果：

填充前：[0, 0, 0, 0, 0]
填充后：[8, 8, 8, 8, 8]

八、面向对象基础（类与对象）

Java 是纯面向对象编程语言，“类” 是对事物的抽象描述，“对象” 是类的具体实例（如 “学生” 是类，“张三” 是对象）。

1. 类的定义（属性与方法）

类由 “成员变量”（属性，描述事物特征）和 “成员方法”（行为，描述事物功能）组成。

格式：

修饰符 class 类名 {
    // 成员变量（属性）：格式：数据类型 变量名;
    数据类型 变量名1;
    数据类型 变量名2;
    
    // 成员方法（行为）：格式：修饰符 返回值类型 方法名(参数列表) { 方法体 }
    修饰符 返回值类型 方法名1(参数列表) {
        // 方法体
    }
    
    修饰符 返回值类型 方法名2(参数列表) {
        // 方法体
    }
}

示例：定义 “学生” 类（Student）

// 学生类（抽象描述）
public class Student {
    // 成员变量（属性）：姓名、年龄、学号
    String name;
    int age;
    String studentId;
    
    // 成员方法（行为）：学习、自我介绍
    // 无参数无返回值方法：学习
    public void study() {
        System.out.println(name + "正在学习Java！");
    }
    
    // 无参数有返回值方法：获取自我介绍信息
    public String introduce() {
        return "大家好！我是" + name + "，今年" + age + "岁，学号是" + studentId;
    }
}

2. 对象的创建与使用

通过new关键字创建对象，格式：类名 对象名 = new 类名();，再通过 “对象名。成员变量”“对象名。成员方法 ()” 操作属性和调用方法。

示例：创建 Student 对象并使用

public class StudentObjectDemo {
    public static void main(String[] args) {
        // 1. 创建第一个Student对象（张三）
        Student zhangsan = new Student();
        // 给成员变量赋值
        zhangsan.name = "张三";
        zhangsan.age = 20;
        zhangsan.studentId = "2023001";
        // 调用成员方法
        zhangsan.study(); // 输出：张三正在学习Java！
        String intro1 = zhangsan.introduce();
        System.out.println(intro1); // 输出：大家好！我是张三，今年20岁，学号是2023001
        
        // 2. 创建第二个Student对象（李四）
        Student lisi = new Student();
        lisi.name = "李四";
        lisi.age = 19;
        lisi.studentId = "2023002";
        lisi.study(); // 输出：李四正在学习Java！
        String intro2 = lisi.introduce();
        System.out.println(intro2); // 输出：大家好！我是李四，今年19岁，学号是2023002
    }
}

3. 构造方法（初始化对象）

构造方法是类中特殊的方法，用于创建对象时初始化成员变量，方法名与类名完全一致，无返回值类型（连 void 都没有）。

（1）默认构造方法

若类中未显式定义构造方法，JVM 会自动提供一个 “无参数默认构造方法”（空方法体），如：

public Student() { // JVM自动生成的默认构造方法
}

（2）自定义构造方法

可显式定义构造方法，实现成员变量的初始化（支持重载）。

示例：自定义 Student 类的构造方法

public class Student {
    String name;
    int age;
    String studentId;
    
    // 1. 无参数构造方法（手动定义，覆盖默认构造）
    public Student() {
        name = "未知姓名";
        age = 0;
        studentId = "未知学号";
    }
    
    // 2. 有参数构造方法（初始化姓名和年龄，重载）
    public Student(String n, int a) {
        name = n;
        age = a;
        studentId = "未知学号";
    }
    
    // 3. 有参数构造方法（初始化所有属性，重载）
    public Student(String n, int a, String id) {
        name = n;
        age = a;
        studentId = id;
    }
    
    // 成员方法
    public String introduce() {
        return "大家好！我是" + name + "，今年" + age + "岁，学号是" + studentId;
    }
}

示例：通过构造方法创建对象

public class StudentConstructorDemo {
    public static void main(String[] args) {
        // 1. 调用无参数构造方法
        Student student1 = new Student();
        System.out.println(student1.introduce()); // 输出：大家好！我是未知姓名，今年0岁，学号是未知学号
        
        // 2. 调用两个参数的构造方法
        Student student2 = new Student("王五", 21);
        System.out.println(student2.introduce()); // 输出：大家好！我是王五，今年21岁，学号是未知学号
        
        // 3. 调用三个参数的构造方法
        Student student3 = new Student("赵六", 18, "2023003");
        System.out.println(student3.introduce()); // 输出：大家好！我是赵六，今年18岁，学号是2023003
    }
}

九、异常处理基础

异常是程序运行时出现的错误（如除以 0、数组下标越界），若不处理会导致程序崩溃。Java 通过try-catch-finally语句捕获并处理异常，保证程序正常运行。

1. 常见异常类型

• ArithmeticException：算术异常（如10 / 0）；

• ArrayIndexOutOfBoundsException：数组下标越界异常（如访问arr[5]，但数组长度为 5）；

• NullPointerException：空指针异常（如调用null对象的方法）；

• InputMismatchException：输入不匹配异常（如用scanner.nextInt()接收字符串）。

2. try-catch 捕获异常

格式：

try {
    // 可能出现异常的代码块（监控区域）
} catch (异常类型1 异常变量名) {
    // 异常类型1发生时的处理逻辑
} catch (异常类型2 异常变量名) {
    // 异常类型2发生时的处理逻辑（可多个catch，子类异常在前，父类异常在后）
}

示例：捕获算术异常

import java.util.Scanner;

public class TryCatchDemo1 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入被除数：");
        int num1 = scanner.nextInt();
        System.out.print("请输入除数：");
        int num2 = scanner.nextInt();
        
        try {
            // 可能出现异常的代码（除数为0时抛ArithmeticException）
            int result = num1 / num2;
            System.out.println(num1 + " / " + num2 + " = " + result);
        } catch (ArithmeticException e) {
            // 处理算术异常
            System.out.println("错误：除数不能为0！");
            e.printStackTrace(); // 打印异常详细信息（便于调试）
        }
        
        System.out.println("程序继续执行..."); // 异常处理后，程序不会崩溃
        scanner.close();
    }
}

输出结果（若除数输入 0）：

请输入被除数：10
请输入除数：0
错误：除数不能为0！
java.lang.ArithmeticException: / by zero
    at TryCatchDemo1.main(TryCatchDemo1.java:12)
程序继续执行...

3. finally 释放资源

finally块中的代码无论是否发生异常，都会执行，常用于释放资源（如关闭文件、关闭输入流）。

格式：

try {
    // 可能出现异常的代码
} catch (异常类型 异常变量名) {
    // 异常处理逻辑
} finally {
    // 必须执行的代码（释放资源）
}

示例：finally 释放输入流资源

import java.util.Scanner;

public class TryCatchFinallyDemo {
    public static void main(String[] args) {
        Scanner scanner = null; // 声明在try外，确保finally可访问
        try {
            scanner = new Scanner(System.in);
            System.out.print("请输入一个整数：");
            int num = scanner.nextInt();
            System.out.println("你输入的整数是：" + num);
        } catch (InputMismatchException e) {
            System.out.println("错误：输入的不是整数！");
        } finally {
            // 无论是否异常，都关闭输入流
            if (scanner != null) { // 避免空指针异常
                scanner.close();
                System.out.println("输入流已关闭");
            }
        }
    }
}

输出结果（若输入字符串 “abc”）：

请输入一个整数：abc
错误：输入的不是整数！
输入流已关闭