学习的好苗子

Appearance

Java 基础入门 ​

Java是一种广泛使用的面向对象编程语言，以其"一次编写，到处运行"的特性而闻名。本章节将带你从零开始学习Java的基础知识。

Java 入门 ​

了解 Java 语言特点与历史 ​

Java是由Sun Microsystems公司于1995年推出的编程语言，后来被Oracle公司收购。Java具有以下特点：

  1. 面向对象：Java是一门面向对象的语言，支持封装、继承、多态等特性
  2. 平台无关性：Java程序通过Java虚拟机(JVM)运行，实现"一次编写，到处运行"
  3. 安全性：Java提供了安全管理机制，防止恶意代码的攻击
  4. 多线程：Java内置了多线程支持，可以编写并发程序
  5. 分布式：Java为开发分布式应用提供了良好的支持

安装 JDK 与配置环境变量 ​

下载和安装JDK ​

  1. 访问Oracle官网或OpenJDK官网下载JDK
  2. 根据操作系统选择合适的版本（Windows、macOS、Linux）
  3. 运行安装程序，按照提示完成安装

配置环境变量 ​

Windows系统配置步骤：

  1. 右键"此电脑" -> "属性" -> "高级系统设置"
  2. 点击"环境变量"
  3. 在系统变量中找到"Path"，点击"编辑"
  4. 添加JDK的bin目录路径（例如：C:\Program Files\Java\jdk-17\bin）

验证安装：

bash
java -version
javac -version

Java 基本语法 ​

变量与数据类型 ​

Java是一种强类型语言，每个变量都必须声明其数据类型。

java
// 基本数据类型
// 整数类型
byte b = 127;           // 8位，范围：-128到127
short s = 32767;        // 16位，范围：-32,768到32,767
int i = 2147483647;     // 32位，范围：-2,147,483,648到2,147,483,647
long l = 9223372036854775807L; // 64位，需要加L后缀

// 浮点类型
float f = 3.14f;        // 32位，需要加f后缀
double d = 3.14159;     // 64位

// 字符类型
char c = 'A';           // 16位Unicode字符

// 布尔类型
boolean bool = true;    // true或false

// 引用数据类型
String str = "Hello World"; // 字符串

运算符 ​

java
public class Operators {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;
        
        // 算术运算符
        System.out.println("a + b = " + (a + b));  // 加法
        System.out.println("a - b = " + (a - b));  // 减法
        System.out.println("a * b = " + (a * b));  // 乘法
        System.out.println("a / b = " + (a / b));  // 除法
        System.out.println("a % b = " + (a % b));  // 取模
        
        // 关系运算符
        System.out.println("a > b = " + (a > b));  // 大于
        System.out.println("a < b = " + (a < b));  // 小于
        System.out.println("a >= b = " + (a >= b)); // 大于等于
        System.out.println("a <= b = " + (a <= b)); // 小于等于
        System.out.println("a == b = " + (a == b)); // 等于
        System.out.println("a != b = " + (a != b)); // 不等于
        
        // 逻辑运算符
        boolean x = true;
        boolean y = false;
        System.out.println("x && y = " + (x && y)); // 与
        System.out.println("x || y = " + (x || y)); // 或
        System.out.println("!x = " + (!x));         // 非
        
        // 赋值运算符
        int c = 20;
        c += 5;  // 等价于 c = c + 5
        System.out.println("c = " + c);
    }
}

第一个 Java 程序（Hello World） ​

java
// 定义一个公共类，类名必须与文件名一致
public class HelloWorld {
    // main方法是程序的入口点
    public static void main(String[] args) {
        // 输出Hello World到控制台
        System.out.println("Hello, World!");
    }
}

编译和运行：

bash
# 编译Java文件
javac HelloWorld.java

# 运行Java程序
java HelloWorld

流程控制 ​

条件语句 ​

if-else语句 ​

java
public class IfElseExample {
    public static void main(String[] args) {
        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语句 ​

java
public class SwitchExample {
    public static void main(String[] args) {
        int day = 3;
        String dayString;
        
        switch (day) {
            case 1:
                dayString = "星期一";
                break;
            case 2:
                dayString = "星期二";
                break;
            case 3:
                dayString = "星期三";
                break;
            case 4:
                dayString = "星期四";
                break;
            case 5:
                dayString = "星期五";
                break;
            case 6:
                dayString = "星期六";
                break;
            case 7:
                dayString = "星期日";
                break;
            default:
                dayString = "无效日期";
                break;
        }
        
        System.out.println(dayString);
    }
}

循环语句 ​

for循环 ​

java
public class ForExample {
    public static void main(String[] args) {
        // 基本for循环
        for (int i = 1; i <= 5; i++) {
            System.out.println("第" + i + "次循环");
        }
        
        // 增强for循环（for-each）
        int[] numbers = {1, 2, 3, 4, 5};
        for (int number : numbers) {
            System.out.println("数字: " + number);
        }
    }
}

while循环 ​

java
public class WhileExample {
    public static void main(String[] args) {
        int i = 1;
        
        while (i <= 5) {
            System.out.println("while循环第" + i + "次");
            i++;
        }
    }
}

do-while循环 ​

java
public class DoWhileExample {
    public static void main(String[] args) {
        int i = 1;
        
        do {
            System.out.println("do-while循环第" + i + "次");
            i++;
        } while (i <= 5);
    }
}

跳转语句 ​

java
public class JumpStatements {
    public static void main(String[] args) {
        // break语句 - 跳出循环
        System.out.println("break示例:");
        for (int i = 1; i <= 10; i++) {
            if (i == 5) {
                break; // 当i等于5时跳出循环
            }
            System.out.println(i);
        }
        
        // continue语句 - 跳过当前循环的剩余部分
        System.out.println("\ncontinue示例:");
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) {
                continue; // 跳过偶数
            }
            System.out.println("奇数: " + i);
        }
        
        // return语句 - 从方法返回
        System.out.println("\nreturn示例:");
        printNumbers();
    }
    
    public static void printNumbers() {
        for (int i = 1; i <= 10; i++) {
            if (i > 5) {
                return; // 当i大于5时结束方法
            }
            System.out.println(i);
        }
    }
}

面向对象基础 ​

类与对象的概念 ​

java
// 定义一个类
public class Person {
    // 成员变量（属性）
    String name;
    int age;
    String gender;
    
    // 构造方法
    public Person() {
        // 无参构造方法
    }
    
    public Person(String name, int age, String gender) {
        // 有参构造方法
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    
    // 成员方法（行为）
    public void introduce() {
        System.out.println("大家好，我叫" + name + "，今年" + age + "岁，性别" + gender);
    }
    
    public void eat(String food) {
        System.out.println(name + "正在吃" + food);
    }
    
    // getter和setter方法
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        }
    }
}

构造方法与析构方法 ​

java
public class Student {
    private String name;
    private int studentId;
    private static int totalStudents = 0; // 静态变量，记录学生总数
    
    // 无参构造方法
    public Student() {
        this("未知", 0);
        System.out.println("创建了一个学生对象");
    }
    
    // 有参构造方法
    public Student(String name, int studentId) {
        this.name = name;
        this.studentId = studentId;
        totalStudents++; // 每创建一个学生对象，总数加1
        System.out.println("创建了学生: " + name);
    }
    
    // 析构方法（通过finalize方法模拟）
    @Override
    protected void finalize() throws Throwable {
        try {
            System.out.println("学生 " + name + " 被销毁");
            totalStudents--; // 对象被销毁时，总数减1
        } finally {
            super.finalize();
        }
    }
    
    // 静态方法，获取学生总数
    public static int getTotalStudents() {
        return totalStudents;
    }
    
    // getter方法
    public String getName() {
        return name;
    }
    
    public int getStudentId() {
        return studentId;
    }
}

封装、继承与多态 ​

封装 ​

java
public class BankAccount {
    // 私有成员变量，外部无法直接访问
    private String accountNumber;
    private double balance;
    private String ownerName;
    
    // 构造方法
    public BankAccount(String accountNumber, String ownerName, double initialBalance) {
        this.accountNumber = accountNumber;
        this.ownerName = ownerName;
        this.balance = initialBalance;
    }
    
    // 公共方法，提供对私有变量的安全访问
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("存款成功，当前余额: " + balance);
        } else {
            System.out.println("存款金额必须大于0");
        }
    }
    
    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println("取款成功，当前余额: " + balance);
        } else {
            System.out.println("取款金额无效");
        }
    }
    
    public double getBalance() {
        return balance;
    }
    
    public String getAccountInfo() {
        return "账户: " + accountNumber + ", 户主: " + ownerName + ", 余额: " + balance;
    }
}

继承 ​

java
// 父类（基类）
public class Animal {
    protected String name;
    protected int age;
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void eat() {
        System.out.println(name + "正在吃东西");
    }
    
    public void sleep() {
        System.out.println(name + "正在睡觉");
    }
    
    public void makeSound() {
        System.out.println(name + "发出声音");
    }
}

// 子类（派生类）
public class Dog extends Animal {
    private String breed; // 品种
    
    public Dog(String name, int age, String breed) {
        super(name, age); // 调用父类构造方法
        this.breed = breed;
    }
    
    // 重写父类方法
    @Override
    public void makeSound() {
        System.out.println(name + "汪汪叫");
    }
    
    // 子类特有方法
    public void wagTail() {
        System.out.println(name + "摇尾巴");
    }
    
    public void fetch() {
        System.out.println(name + "去捡球");
    }
}

// 另一个子类
public class Cat extends Animal {
    private boolean isIndoor; // 是否为室内猫
    
    public Cat(String name, int age, boolean isIndoor) {
        super(name, age);
        this.isIndoor = isIndoor;
    }
    
    // 重写父类方法
    @Override
    public void makeSound() {
        System.out.println(name + "喵喵叫");
    }
    
    // 子类特有方法
    public void purr() {
        System.out.println(name + "发出呼噜声");
    }
}

多态 ​

java
public class PolymorphismExample {
    public static void main(String[] args) {
        // 父类引用指向子类对象
        Animal animal1 = new Dog("旺财", 3, "金毛");
        Animal animal2 = new Cat("咪咪", 2, true);
        
        // 多态体现：同一个方法调用，不同的行为
        animal1.makeSound(); // 输出：旺财汪汪叫
        animal2.makeSound(); // 输出：咪咪喵喵叫
        
        // 调用公共方法
        animal1.eat();
        animal2.eat();
        
        // 使用数组演示多态
        Animal[] animals = {
            new Dog("小白", 2, "哈士奇"),
            new Cat("小黑", 1, false),
            new Dog("小黄", 4, "柴犬")
        };
        
        // 遍历数组，演示多态
        for (Animal animal : animals) {
            animal.makeSound(); // 根据实际对象类型调用相应方法
            if (animal instanceof Dog) {
                // 向下转型，调用子类特有方法
                Dog dog = (Dog) animal;
                dog.fetch();
            } else if (animal instanceof Cat) {
                Cat cat = (Cat) animal;
                cat.purr();
            }
        }
    }
}

访问修饰符 ​

java
public class AccessModifiers {
    // public：公共的，任何地方都可以访问
    public String publicField = "公共字段";
    
    // protected：受保护的，同一包内或子类可以访问
    protected String protectedField = "受保护字段";
    
    // default（包私有）：同一包内可以访问
    String defaultField = "包私有字段";
    
    // private：私有的，只有本类可以访问
    private String privateField = "私有字段";
    
    // 不同访问修饰符的方法
    public void publicMethod() {
        System.out.println("公共方法");
    }
    
    protected void protectedMethod() {
        System.out.println("受保护方法");
    }
    
    void defaultMethod() {
        System.out.println("包私有方法");
    }
    
    private void privateMethod() {
        System.out.println("私有方法");
    }
    
    // 在同一类中可以访问所有成员
    public void testAccess() {
        System.out.println(publicField);
        System.out.println(protectedField);
        System.out.println(defaultField);
        System.out.println(privateField);
        
        publicMethod();
        protectedMethod();
        defaultMethod();
        privateMethod();
    }
}

// 同一包中的另一个类
class SamePackageClass {
    public void testAccess() {
        AccessModifiers obj = new AccessModifiers();
        
        // 可以访问public和protected成员
        System.out.println(obj.publicField);
        System.out.println(obj.protectedField);
        System.out.println(obj.defaultField);
        // System.out.println(obj.privateField); // 编译错误
        
        obj.publicMethod();
        obj.protectedMethod();
        obj.defaultMethod();
        // obj.privateMethod(); // 编译错误
    }
}

数组与集合框架基础 ​

一维数组与多维数组 ​

java
public class ArrayExample {
    public static void main(String[] args) {
        // 一维数组的声明和初始化
        // 方式1：先声明再初始化
        int[] numbers1;
        numbers1 = new int[5]; // 创建长度为5的整型数组
        
        // 方式2：声明时初始化
        int[] numbers2 = new int[5];
        
        // 方式3：直接赋值初始化
        int[] numbers3 = {1, 2, 3, 4, 5};
        
        // 方式4：使用new关键字直接赋值
        int[] numbers4 = new int[]{10, 20, 30, 40, 50};
        
        // 访问和修改数组元素
        numbers3[0] = 100; // 修改第一个元素
        System.out.println("第一个元素: " + numbers3[0]);
        System.out.println("数组长度: " + numbers3.length);
        
        // 遍历数组
        System.out.println("遍历数组:");
        for (int i = 0; i < numbers3.length; i++) {
            System.out.println("索引" + i + ": " + numbers3[i]);
        }
        
        // 增强for循环遍历
        System.out.println("增强for循环遍历:");
        for (int number : numbers3) {
            System.out.println(number);
        }
        
        // 多维数组
        // 二维数组声明和初始化
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        // 访问二维数组元素
        System.out.println("二维数组元素[1][2]: " + matrix[1][2]); // 输出6
        
        // 遍历二维数组
        System.out.println("遍历二维数组:");
        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();
        }
        
        // 不规则数组（每行长度不同）
        int[][] irregularArray = {
            {1, 2},
            {3, 4, 5, 6},
            {7, 8, 9}
        };
        
        System.out.println("不规则数组:");
        for (int i = 0; i < irregularArray.length; i++) {
            for (int j = 0; j < irregularArray[i].length; j++) {
                System.out.print(irregularArray[i][j] + " ");
            }
            System.out.println();
        }
        
        // 数组的常用操作
        // 复制数组
        int[] original = {1, 2, 3, 4, 5};
        int[] copy = new int[original.length];
        System.arraycopy(original, 0, copy, 0, original.length);
        
        // 使用Arrays工具类
        import java.util.Arrays;
        int[] sortedArray = {5, 2, 8, 1, 9};
        Arrays.sort(sortedArray); // 排序
        System.out.println("排序后: " + Arrays.toString(sortedArray));
        
        // 查找元素
        int index = Arrays.binarySearch(sortedArray, 8);
        System.out.println("元素8的索引: " + index);
    }
}

ArrayList 与 LinkedList 的使用 ​

java
import java.util.*;

public class ListExample {
    public static void main(String[] args) {
        // ArrayList示例
        System.out.println("=== ArrayList示例 ===");
        ArrayList<String> arrayList = new ArrayList<>();
        
        // 添加元素
        arrayList.add("苹果");
        arrayList.add("香蕉");
        arrayList.add("橙子");
        arrayList.add(1, "葡萄"); // 在指定位置插入
        
        System.out.println("ArrayList内容: " + arrayList);
        System.out.println("ArrayList大小: " + arrayList.size());
        
        // 访问元素
        System.out.println("第一个元素: " + arrayList.get(0));
        
        // 修改元素
        arrayList.set(0, "草莓");
        System.out.println("修改后的ArrayList: " + arrayList);
        
        // 删除元素
        arrayList.remove("香蕉");
        arrayList.remove(0); // 删除指定索引的元素
        System.out.println("删除元素后的ArrayList: " + arrayList);
        
        // 遍历ArrayList
        System.out.println("遍历ArrayList:");
        for (int i = 0; i < arrayList.size(); i++) {
            System.out.println("索引" + i + ": " + arrayList.get(i));
        }
        
        // 增强for循环遍历
        for (String fruit : arrayList) {
            System.out.println(fruit);
        }
        
        // LinkedList示例
        System.out.println("\n=== LinkedList示例 ===");
        LinkedList<Integer> linkedList = new LinkedList<>();
        
        // 添加元素
        linkedList.add(10);
        linkedList.add(20);
        linkedList.add(30);
        linkedList.addFirst(5); // 在开头添加
        linkedList.addLast(40); // 在末尾添加
        
        System.out.println("LinkedList内容: " + linkedList);
        
        // 访问元素
        System.out.println("第一个元素: " + linkedList.getFirst());
        System.out.println("最后一个元素: " + linkedList.getLast());
        
        // 修改元素
        linkedList.set(0, 1);
        System.out.println("修改后的LinkedList: " + linkedList);
        
        // 删除元素
        linkedList.removeFirst();
        linkedList.removeLast();
        System.out.println("删除首尾元素后的LinkedList: " + linkedList);
        
        // 栈操作（LIFO）
        LinkedList<String> stack = new LinkedList<>();
        stack.push("第一个");
        stack.push("第二个");
        stack.push("第三个");
        System.out.println("栈顶元素: " + stack.peek());
        System.out.println("弹出元素: " + stack.pop());
        System.out.println("弹出元素: " + stack.pop());
        
        // 队列操作（FIFO）
        LinkedList<String> queue = new LinkedList<>();
        queue.offer("第一个");
        queue.offer("第二个");
        queue.offer("第三个");
        System.out.println("队列头部元素: " + queue.peek());
        System.out.println("取出元素: " + queue.poll());
        System.out.println("取出元素: " + queue.poll());
    }
}

基本集合操作（增删改查） ​

java
import java.util.*;

public class CollectionOperations {
    public static void main(String[] args) {
        // 使用ArrayList演示基本操作
        List<String> fruits = new ArrayList<>();
        
        // 增加操作（Create）
        System.out.println("=== 增加操作 ===");
        fruits.add("苹果");
        fruits.add("香蕉");
        fruits.add("橙子");
        System.out.println("添加元素后: " + fruits);
        
        // 在指定位置添加
        fruits.add(1, "葡萄");
        System.out.println("在索引1插入葡萄后: " + fruits);
        
        // 批量添加
        List<String> moreFruits = Arrays.asList("草莓", "蓝莓", "樱桃");
        fruits.addAll(moreFruits);
        System.out.println("批量添加后: " + fruits);
        
        // 查询操作（Read）
        System.out.println("\n=== 查询操作 ===");
        // 根据索引查询
        System.out.println("索引2的元素: " + fruits.get(2));
        
        // 查询元素是否存在
        System.out.println("是否包含苹果: " + fruits.contains("苹果"));
        
        // 查询元素索引
        System.out.println("香蕉的索引: " + fruits.indexOf("香蕉"));
        
        // 查询集合大小
        System.out.println("集合大小: " + fruits.size());
        
        // 判断集合是否为空
        System.out.println("集合是否为空: " + fruits.isEmpty());
        
        // 修改操作（Update）
        System.out.println("\n=== 修改操作 ===");
        // 修改指定索引的元素
        fruits.set(0, "红苹果");
        System.out.println("修改索引0的元素后: " + fruits);
        
        // 批量修改（替换所有符合条件的元素）
        Collections.replaceAll(fruits, "橙子", "甜橙");
        System.out.println("替换橙子为甜橙后: " + fruits);
        
        // 删除操作（Delete）
        System.out.println("\n=== 删除操作 ===");
        // 删除指定元素
        fruits.remove("香蕉");
        System.out.println("删除香蕉后: " + fruits);
        
        // 删除指定索引的元素
        fruits.remove(1);
        System.out.println("删除索引1的元素后: " + fruits);
        
        // 删除满足条件的元素
        fruits.removeIf(fruit -> fruit.startsWith("蓝"));
        System.out.println("删除以'蓝'开头的元素后: " + fruits);
        
        // 清空所有元素
        // fruits.clear();
        // System.out.println("清空所有元素后: " + fruits);
        
        // 遍历操作
        System.out.println("\n=== 遍历操作 ===");
        // 1. 使用for循环
        System.out.println("使用for循环遍历:");
        for (int i = 0; i < fruits.size(); i++) {
            System.out.println("索引" + i + ": " + fruits.get(i));
        }
        
        // 2. 使用增强for循环
        System.out.println("使用增强for循环遍历:");
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
        
        // 3. 使用迭代器
        System.out.println("使用迭代器遍历:");
        Iterator<String> iterator = fruits.iterator();
        while (iterator.hasNext()) {
            String fruit = iterator.next();
            System.out.println(fruit);
            // 在迭代过程中可以安全删除元素
            if (fruit.equals("甜橙")) {
                iterator.remove();
            }
        }
        System.out.println("删除甜橙后: " + fruits);
        
        // 4. 使用forEach方法（Java 8+）
        System.out.println("使用forEach方法遍历:");
        fruits.forEach(System.out::println);
        
        // 5. 使用Stream API（Java 8+）
        System.out.println("使用Stream API过滤和遍历:");
        fruits.stream()
              .filter(fruit -> fruit.length() > 2)
              .forEach(System.out::println);
        
        // 排序操作
        System.out.println("\n=== 排序操作 ===");
        List<Integer> numbers = new ArrayList<>(Arrays.asList(5, 2, 8, 1, 9, 3));
        System.out.println("排序前: " + numbers);
        
        // 自然排序
        Collections.sort(numbers);
        System.out.println("自然排序后: " + numbers);
        
        // 自定义排序（降序）
        Collections.sort(numbers, Collections.reverseOrder());
        System.out.println("降序排序后: " + numbers);
        
        // 使用Comparator自定义排序
        List<String> words = new ArrayList<>(Arrays.asList("apple", "banana", "cherry", "date"));
        System.out.println("按长度排序前: " + words);
        words.sort(Comparator.comparing(String::length));
        System.out.println("按长度排序后: " + words);
    }
}

实践练习 ​

练习1：学生管理系统 ​

java
import java.util.*;

// 学生类
class Student {
    private String id;
    private String name;
    private int age;
    private String major;
    
    public Student(String id, String name, int age, String major) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.major = major;
    }
    
    // Getter和Setter方法
    public String getId() { return id; }
    public String getName() { return name; }
    public int getAge() { return age; }
    public String getMajor() { return major; }
    
    public void setName(String name) { this.name = name; }
    public void setAge(int age) { this.age = age; }
    public void setMajor(String major) { this.major = major; }
    
    @Override
    public String toString() {
        return "Student{id='" + id + "', name='" + name + "', age=" + age + ", major='" + major + "'}";
    }
}

// 学生管理类
class StudentManager {
    private List<Student> students;
    
    public StudentManager() {
        students = new ArrayList<>();
    }
    
    // 添加学生
    public void addStudent(Student student) {
        students.add(student);
        System.out.println("学生添加成功: " + student.getName());
    }
    
    // 根据ID查找学生
    public Student findStudentById(String id) {
        for (Student student : students) {
            if (student.getId().equals(id)) {
                return student;
            }
        }
        return null;
    }
    
    // 根据姓名查找学生
    public List<Student> findStudentsByName(String name) {
        List<Student> result = new ArrayList<>();
        for (Student student : students) {
            if (student.getName().contains(name)) {
                result.add(student);
            }
        }
        return result;
    }
    
    // 删除学生
    public boolean deleteStudentById(String id) {
        Student student = findStudentById(id);
        if (student != null) {
            students.remove(student);
            System.out.println("学生删除成功: " + student.getName());
            return true;
        } else {
            System.out.println("未找到ID为" + id + "的学生");
            return false;
        }
    }
    
    // 更新学生信息
    public boolean updateStudent(String id, String name, int age, String major) {
        Student student = findStudentById(id);
        if (student != null) {
            student.setName(name);
            student.setAge(age);
            student.setMajor(major);
            System.out.println("学生信息更新成功: " + student.getName());
            return true;
        } else {
            System.out.println("未找到ID为" + id + "的学生");
            return false;
        }
    }
    
    // 显示所有学生
    public void displayAllStudents() {
        if (students.isEmpty()) {
            System.out.println("暂无学生信息");
        } else {
            System.out.println("所有学生信息:");
            for (int i = 0; i < students.size(); i++) {
                System.out.println((i + 1) + ". " + students.get(i));
            }
        }
    }
    
    // 根据专业统计学生人数
    public Map<String, Integer> getStudentCountByMajor() {
        Map<String, Integer> majorCount = new HashMap<>();
        for (Student student : students) {
            String major = student.getMajor();
            majorCount.put(major, majorCount.getOrDefault(major, 0) + 1);
        }
        return majorCount;
    }
}

// 主程序
public class StudentManagementSystem {
    private static StudentManager manager = new StudentManager();
    private static Scanner scanner = new Scanner(System.in);
    
    public static void main(String[] args) {
        // 初始化一些测试数据
        initData();
        
        while (true) {
            showMenu();
            int choice = scanner.nextInt();
            scanner.nextLine(); // 消费换行符
            
            switch (choice) {
                case 1:
                    addStudent();
                    break;
                case 2:
                    findStudent();
                    break;
                case 3:
                    deleteStudent();
                    break;
                case 4:
                    updateStudent();
                    break;
                case 5:
                    displayAllStudents();
                    break;
                case 6:
                    showStatistics();
                    break;
                case 0:
                    System.out.println("谢谢使用！");
                    return;
                default:
                    System.out.println("无效选择，请重新输入");
            }
        }
    }
    
    private static void showMenu() {
        System.out.println("\n=== 学生管理系统 ===");
        System.out.println("1. 添加学生");
        System.out.println("2. 查找学生");
        System.out.println("3. 删除学生");
        System.out.println("4. 更新学生");
        System.out.println("5. 显示所有学生");
        System.out.println("6. 统计信息");
        System.out.println("0. 退出系统");
        System.out.print("请选择操作: ");
    }
    
    private static void initData() {
        manager.addStudent(new Student("001", "张三", 20, "计算机科学"));
        manager.addStudent(new Student("002", "李四", 21, "软件工程"));
        manager.addStudent(new Student("003", "王五", 19, "计算机科学"));
        manager.addStudent(new Student("004", "赵六", 22, "数据科学"));
    }
    
    private static void addStudent() {
        System.out.print("请输入学生ID: ");
        String id = scanner.nextLine();
        System.out.print("请输入学生姓名: ");
        String name = scanner.nextLine();
        System.out.print("请输入学生年龄: ");
        int age = scanner.nextInt();
        scanner.nextLine(); // 消费换行符
        System.out.print("请输入学生专业: ");
        String major = scanner.nextLine();
        
        Student student = new Student(id, name, age, major);
        manager.addStudent(student);
    }
    
    private static void findStudent() {
        System.out.print("请输入查找方式 (1-按ID查找, 2-按姓名查找): ");
        int choice = scanner.nextInt();
        scanner.nextLine(); // 消费换行符
        
        if (choice == 1) {
            System.out.print("请输入学生ID: ");
            String id = scanner.nextLine();
            Student student = manager.findStudentById(id);
            if (student != null) {
                System.out.println("找到学生: " + student);
            } else {
                System.out.println("未找到该学生");
            }
        } else if (choice == 2) {
            System.out.print("请输入学生姓名: ");
            String name = scanner.nextLine();
            List<Student> students = manager.findStudentsByName(name);
            if (!students.isEmpty()) {
                System.out.println("找到 " + students.size() + " 个学生:");
                for (Student student : students) {
                    System.out.println(student);
                }
            } else {
                System.out.println("未找到相关学生");
            }
        } else {
            System.out.println("无效选择");
        }
    }
    
    private static void deleteStudent() {
        System.out.print("请输入要删除的学生ID: ");
        String id = scanner.nextLine();
        manager.deleteStudentById(id);
    }
    
    private static void updateStudent() {
        System.out.print("请输入要更新的学生ID: ");
        String id = scanner.nextLine();
        System.out.print("请输入新的姓名: ");
        String name = scanner.nextLine();
        System.out.print("请输入新的年龄: ");
        int age = scanner.nextInt();
        scanner.nextLine(); // 消费换行符
        System.out.print("请输入新的专业: ");
        String major = scanner.nextLine();
        
        manager.updateStudent(id, name, age, major);
    }
    
    private static void displayAllStudents() {
        manager.displayAllStudents();
    }
    
    private static void showStatistics() {
        Map<String, Integer> majorCount = manager.getStudentCountByMajor();
        System.out.println("各专业学生人数统计:");
        for (Map.Entry<String, Integer> entry : majorCount.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue() + "人");
        }
    }
}

练习2：简单计算器 ​

java
import java.util.Scanner;

public class SimpleCalculator {
    private static Scanner scanner = new Scanner(System.in);
    
    public static void main(String[] args) {
        System.out.println("=== 简单计算器 ===");
        
        while (true) {
            try {
                System.out.print("请输入第一个数字: ");
                double num1 = scanner.nextDouble();
                
                System.out.print("请输入运算符 (+, -, *, /): ");
                String operator = scanner.next();
                
                System.out.print("请输入第二个数字: ");
                double num2 = scanner.nextDouble();
                
                double result = calculate(num1, num2, operator);
                System.out.println("计算结果: " + num1 + " " + operator + " " + num2 + " = " + result);
                
                System.out.print("是否继续计算? (y/n): ");
                String continueChoice = scanner.next();
                if (!continueChoice.equalsIgnoreCase("y")) {
                    break;
                }
            } catch (Exception e) {
                System.out.println("输入错误，请重新输入！");
                scanner.nextLine(); // 清除错误输入
            }
        }
        
        System.out.println("谢谢使用计算器！");
    }
    
    private static double calculate(double num1, double num2, String operator) {
        switch (operator) {
            case "+":
                return num1 + num2;
            case "-":
                return num1 - num2;
            case "*":
                return num1 * num2;
            case "/":
                if (num2 != 0) {
                    return num1 / num2;
                } else {
                    throw new ArithmeticException("除数不能为零");
                }
            default:
                throw new IllegalArgumentException("不支持的运算符: " + operator);
        }
    }
}

通过以上内容的学习和实践，您已经掌握了Java基础阶段的核心知识点。这些基础知识为后续学习Java进阶内容打下了坚实的基础。