public class HelloWorld {
    // 程序的入口，main 方法
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}
    复制
  

    # 1. 编译源文件
javac HelloWorld.java

# 2. 运行字节码
java HelloWorld
    复制
  

    public class Types {
    public static void main(String[] args) {
        int age = 20;
        double price = 19.99;
        char grade = 'A';
        boolean isStudent = true;
        long population = 7900000000L;
        float pi = 3.14f;

        System.out.println("年龄: " + age);
        System.out.println("价格: " + price);
        System.out.println("等级: " + grade);
        System.out.println("是学生: " + isStudent);
    }
}
    复制
  

    public class Cast {
    public static void main(String[] args) {
        // 自动转换：int → double
        int i = 100;
        double d = i;
        System.out.println("自动转换: " + d);

        // 强制转换：double → int
        double pi = 3.99;
        int n = (int) pi;  // 直接截断小数部分
        System.out.println("强制转换: " + n);
    }
}
    复制
  

    public class StringDemo {
    public static void main(String[] args) {
        String name = "张三";
        String greeting = "你好";
        // 字符串拼接用 +
        System.out.println(greeting + ", " + name + "!");

        // 常用方法
        System.out.println("长度: " + name.length());
        System.out.println("大写: " + "hello".toUpperCase());
        System.out.println("连接: " + "a".concat("b"));
    }
}
    复制
  

    public class Arithmetic {
    public static void main(String[] args) {
        int a = 17, b = 5;
        System.out.println("加: " + (a + b));    // 22
        System.out.println("减: " + (a - b));    // 12
        System.out.println("乘: " + (a * b));    // 85
        System.out.println("除: " + (a / b));    // 3（整数除法，截断）
        System.out.println("取余: " + (a % b));  // 2
    }
}
    复制
  

    public class IncDec {
    public static void main(String[] args) {
        int i = 5;
        System.out.println(i++);  // 5（先使用，后加1）
        System.out.println(i);    // 6
        System.out.println(++i);  // 7（先加1，后使用）
    }
}
    复制
  

    public class Logic {
    public static void main(String[] args) {
        int score = 75;
        // 逻辑与
        boolean pass = score >= 60 && score <= 100;
        System.out.println("及格: " + pass);

        // 逻辑或
        boolean holiday = false;
        boolean weekend = true;
        boolean canRest = holiday || weekend;
        System.out.println("可以休息: " + canRest);

        // 短路特性
        int x = 0;
        if (x != 0 && 10 / x > 1) {
            System.out.println("不会执行到这里");
        }
        System.out.println("短路避免了除零错误");
    }
}
    复制
  

    public class Assign {
    public static void main(String[] args) {
        int n = 10;
        n += 5;  // 等价于 n = n + 5
        System.out.println("+= 后: " + n);  // 15

        // 三元运算符: 条件 ? 真值 : 假值
        int age = 17;
        String status = age >= 18 ? "成年" : "未成年";
        System.out.println(status);
    }
}
    复制
  

    public class IfElse {
    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("不及格");
        }
    }
}
    复制
  

    public class Nested {
    public static void main(String[] args) {
        int age = 20;
        boolean hasLicense = true;

        if (age >= 18) {
            if (hasLicense) {
                System.out.println("可以开车");
            } else {
                System.out.println("成年了，但没驾照");
            }
        } else {
            System.out.println("未成年，不能开车");
        }
    }
}
    复制
  

    public class Switch {
    public static void main(String[] args) {
        int day = 3;
        switch (day) {
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            default:
                System.out.println("其他");
        }
    }
}
    复制
  

    public class SwitchNew {
    public static void main(String[] args) {
        int day = 3;
        String name = switch (day) {
            case 1 -> "星期一";
            case 2 -> "星期二";
            case 3 -> "星期三";
            default -> "其他";
        };
        System.out.println(name);
    }
}
    复制
  

    public class ForLoop {
    public static void main(String[] args) {
        // 打印 1 到 5
        for (int i = 1; i <= 5; i++) {
            System.out.println("第 " + i + " 次");
        }
    }
}
    复制
  

    public class WhileLoop {
    public static void main(String[] args) {
        int n = 1024;
        int count = 0;
        // 不断除以 2，直到 n 变为 0
        while (n > 0) {
            n = n / 2;
            count++;
        }
        System.out.println("循环了 " + count + " 次");
    }
}
    复制
  

    public class DoWhile {
    public static void main(String[] args) {
        int i = 10;
        do {
            System.out.println("i = " + i);
            i++;
        } while (i < 5);  // 条件为 false，但已经执行了一次
    }
}
    复制
  

    public class BreakContinue {
    public static void main(String[] args) {
        // break: 跳出整个循环
        System.out.println("=== break 示例 ===");
        for (int i = 1; i <= 10; i++) {
            if (i == 5) break;  // 到 5 就停
            System.out.println(i);
        }

        // continue: 跳过本次，继续下一次
        System.out.println("=== continue 示例 ===");
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) continue;  // 跳过偶数
            System.out.println(i);
        }
    }
}
    复制
  

    public class Multiplication {
    public static void main(String[] args) {
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.printf("%d×%d=%-4d", j, i, i * j);
            }
            System.out.println();
        }
    }
}
    复制
  

    public class MethodBasic {
    // 定义方法：修饰符 返回类型 方法名(参数列表)
    public static int add(int a, int b) {
        return a + b;
    }

    // 无返回值用 void
    public static void greet(String name) {
        System.out.println("你好, " + name + "!");
    }

    public static void main(String[] args) {
        int result = add(3, 5);    // 调用有返回值的方法
        System.out.println("3 + 5 = " + result);

        greet("张三");              // 调用无返回值的方法
    }
}
    复制
  

    public class 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;
    }

    public static void main(String[] args) {
        System.out.println(add(1, 2));        // 调用第一个
        System.out.println(add(1, 2, 3));     // 调用第二个
        System.out.println(add(1.5, 2.5));    // 调用第三个
    }
}
    复制
  

    public class PassByValue {
    public static void change(int x) {
        x = 100;  // 只改了副本
    }

    public static void main(String[] args) {
        int n = 10;
        change(n);
        System.out.println("n = " + n);  // 还是 10
    }
}
    复制
  

    public class Scope {
    public static void main(String[] args) {
        int x = 10;  // main 方法作用域
        if (x > 5) {
            int y = 20;  // if 块作用域
            System.out.println(x + y);  // 30
        }
        // System.out.println(y);  // 编译错误！y 在这里不可见
    }
}
    复制
  

    public class Recursion {
    // n! = n * (n-1)!
    public static int factorial(int n) {
        if (n <= 1) return 1;       // 终止条件
        return n * factorial(n - 1); // 递归调用
    }

    public static void main(String[] args) {
        System.out.println("5! = " + factorial(5));  // 120
    }
}
    复制
  

    public class ArrayBasic {
    public static void main(String[] args) {
        // 声明并初始化
        int[] scores = {90, 85, 78, 92, 88};

        // 访问元素（下标从 0 开始）
        System.out.println("第一个: " + scores[0]);
        System.out.println("第三个: " + scores[2]);

        // 数组长度
        System.out.println("长度: " + scores.length);

        // 修改元素
        scores[1] = 95;
        System.out.println("修改后: " + scores[1]);
    }
}
    复制
  

    public class ArrayCreate {
    public static void main(String[] args) {
        // 方式1: 先声明再分配空间
        int[] a = new int[5];  // 默认值全为 0
        a[0] = 10;

        // 方式2: 直接初始化
        int[] b = {1, 2, 3};

        // 方式3: new + 初始化
        String[] names = new String[]{"Alice", "Bob", "Carol"};

        System.out.println(a[0] + " " + a[1]);  // 10 0
        System.out.println(names.length);
    }
}
    复制
  

    public class ArrayLoop {
    public static void main(String[] args) {
        int[] nums = {10, 20, 30, 40, 50};

        // 方式1: 普通 for 循环
        System.out.print("for: ");
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + " ");
        }
        System.out.println();

        // 方式2: 增强 for（for-each）
        System.out.print("for-each: ");
        for (int num : nums) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}
    复制
  

    public class ArrayMax {
    public static void main(String[] args) {
        int[] nums = {3, 7, 2, 9, 5, 1, 8};
        int max = nums[0];  // 假设第一个最大

        for (int i = 1; i < nums.length; i++) {
            if (nums[i] > max) {
                max = nums[i];
            }
        }
        System.out.println("最大值: " + max);
    }
}
    复制
  

    public class TwoD {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        // 遍历二维数组
        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();
        }
    }
}
    复制
  

    // 学生类
public class Student {
    // 属性（字段 / 成员变量）
    String name;
    int age;
    double score;

    // 方法（行为）
    public void study() {
        System.out.println(name + " 正在学习");
    }

    public void introduce() {
        System.out.println("我叫 " + name + "，今年 " + age + " 岁");
    }
}
    复制
  

    public class Main {
    public static void main(String[] args) {
        // 创建对象
        Student s1 = new Student();
        s1.name = "张三";
        s1.age = 20;
        s1.score = 92.5;

        // 调用方法
        s1.introduce();
        s1.study();

        // 创建另一个对象
        Student s2 = new Student();
        s2.name = "李四";
        s2.age = 21;
        s2.introduce();
    }
}
    复制
  

    public class Book {
    String title;
    double price;

    public void setInfo(String title, double price) {
        this.title = title;    // this.title 是成员变量
        this.price = price;    // 右边 title 是参数
    }

    public void show() {
        System.out.println("《" + title + "》 价格: " + price);
    }

    public static void main(String[] args) {
        Book b = new Book();
        b.setInfo("Java入门", 59.9);
        b.show();
    }
}
    复制
  

    public class MathUtil {
    // 静态变量：所有对象共享
    static int count = 0;

    // 静态方法：直接用类名调用
    public static int square(int n) {
        return n * n;
    }

    public MathUtil() {
        count++;  // 每创建一个对象，count 加 1
    }

    public static void main(String[] args) {
        System.out.println("3 的平方: " + MathUtil.square(3));

        new MathUtil();
        new MathUtil();
        System.out.println("创建了 " + MathUtil.count + " 个对象");
    }
}
    复制
  

    public class Account {
    private String owner;
    private double balance;

    // getter
    public double getBalance() {
        return balance;
    }

    // setter：加入校验逻辑
    public void setBalance(double balance) {
        if (balance < 0) {
            System.out.println("余额不能为负！");
            return;
        }
        this.balance = balance;
    }

    public String getOwner() {
        return owner;
    }

    public void setOwner(String owner) {
        this.owner = owner;
    }
}
    复制
  

    public class AccountTest {
    public static void main(String[] args) {
        Account acc = new Account();
        acc.setOwner("张三");
        acc.setBalance(1000);
        System.out.println(acc.getOwner() + " 余额: " + acc.getBalance());

        acc.setBalance(-500);  // 会被拦截
        System.out.println(acc.getOwner() + " 余额: " + acc.getBalance());
    }
}
    复制
  

    public class Person {
    private String name;
    private int age;

    // 无参构造
    public Person() {
        this.name = "未知";
        this.age = 0;
    }

    // 有参构造（重载）
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void show() {
        System.out.println(name + ", " + age + " 岁");
    }

    public static void main(String[] args) {
        Person p1 = new Person();           // 调用无参构造
        Person p2 = new Person("李四", 25);  // 调用有参构造
        p1.show();
        p2.show();
    }
}
    复制
  

    public class Car {
    String brand;
    String color;
    int year;

    public Car(String brand) {
        this(brand, "白色", 2024);  // 调用三参构造
    }

    public Car(String brand, String color, int year) {
        this.brand = brand;
        this.color = color;
        this.year = year;
    }

    public void info() {
        System.out.println(year + "款 " + color + " " + brand);
    }

    public static void main(String[] args) {
        Car c = new Car("丰田");
        c.info();
    }
}
    复制
  

    public class Product {
    private int id;
    private String name;
    private double price;

    // 无参构造（必须）
    public Product() {}

    // 全参构造（推荐）
    public Product(int id, String name, double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public double getPrice() { return price; }
    public void setPrice(double price) { this.price = price; }
}
    复制
  

    // 父类（基类）
class Animal {
    String name;

    public void eat() {
        System.out.println(name + " 在吃东西");
    }

    public void sleep() {
        System.out.println(name + " 在睡觉");
    }
}

// 子类继承 Animal
class Dog extends Animal {
    public void bark() {
        System.out.println(name + " 汪汪汪！");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.name = "旺财";
        d.eat();    // 继承自父类
        d.bark();   // 自己的方法
    }
}
    复制
  

    class Shape {
    public double area() {
        return 0;
    }
}

class Circle extends Shape {
    double radius;
    public Circle(double r) { this.radius = r; }

    @Override  // 重写注解，帮助编译器检查
    public double area() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    double width, height;
    public Rectangle(double w, double h) {
        this.width = w;
        this.height = h;
    }

    @Override
    public double area() {
        return width * height;
    }
}

public class Main {
    public static void main(String[] args) {
        Circle c = new Circle(5);
        Rectangle r = new Rectangle(4, 6);
        System.out.printf("圆面积: %.2f%n", c.area());
        System.out.printf("矩形面积: %.2f%n", r.area());
    }
}
    复制
  

    class Vehicle {
    String brand;
    public Vehicle(String brand) {
        this.brand = brand;
        System.out.println("Vehicle 构造");
    }
    public void run() {
        System.out.println(brand + " 在行驶");
    }
}

class Car extends Vehicle {
    int wheels;
    public Car(String brand, int wheels) {
        super(brand);      // 调用父类构造，必须放第一行
        this.wheels = wheels;
        System.out.println("Car 构造");
    }

    @Override
    public void run() {
        super.run();       // 调用父类方法
        System.out.println(brand + " 有 " + wheels + " 个轮子");
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car("奔驰", 4);
        car.run();
    }
}
    复制
  

    class Animal {
    public void speak() {
        System.out.println("动物发出声音");
    }
}
class Dog extends Animal {
    public void speak() { System.out.println("汪汪汪"); }
}
class Cat extends Animal {
    public void speak() { System.out.println("喵喵喵"); }
}

public class Main {
    // 父类引用作为参数——多态的威力
    public static void makeSpeak(Animal a) {
        a.speak();  // 运行时决定调用哪个子类的方法
    }

    public static void main(String[] args) {
        // 父类引用指向子类对象
        Animal a1 = new Dog();  // 向上转型
        Animal a2 = new Cat();

        makeSpeak(a1);  // 汪汪汪
        makeSpeak(a2);  // 喵喵喵
    }
}
    复制
  

    Animal a = new Dog();  // 向上转型
// a.bark();  // 编译错误！Animal 没有 bark 方法

if (a instanceof Dog) {
    Dog d = (Dog) a;  // 向下转型
    d.bark();         // 现在可以调用 Dog 特有方法
}
    复制
  

    if (a instanceof Dog d) {
    d.bark();  // d 已自动声明并转型
}
    复制
  

    abstract class Shape {
    // 抽象方法：只有声明，没有实现
    public abstract double area();

    // 普通方法：抽象类中也可以有
    public void display() {
        System.out.printf("面积 = %.2f%n", area());
    }
}

class Triangle extends Shape {
    double base, height;
    public Triangle(double b, double h) {
        this.base = b; this.height = h;
    }
    @Override
    public double area() {
        return 0.5 * base * height;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape s = new Triangle(3, 4);
        s.display();
    }
}
    复制
  

    // 定义接口
interface Flyable {
    void fly();  // 默认 public abstract
}

interface Swimmable {
    void swim();
}

// 实现多个接口
class Duck implements Flyable, Swimmable {
    public void fly() {
        System.out.println("鸭子飞起来了");
    }
    public void swim() {
        System.out.println("鸭子游起来了");
    }
}

public class Main {
    public static void main(String[] args) {
        Duck d = new Duck();
        d.fly();
        d.swim();

        // 接口引用也可以多态
        Flyable f = new Duck();
        f.fly();
    }
}
    复制
  

    public class TryCatch {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        try {
            System.out.println(arr[5]);  // 越界！
            System.out.println("这行不会执行");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("捕获到异常: " + e.getMessage());
        } finally {
            System.out.println("finally 总是执行");
        }
        System.out.println("程序继续运行");
    }
}
    复制
  

    try {
    String s = null;
    System.out.println(s.length());  // 空指针
} catch (NullPointerException e) {
    System.out.println("空指针异常");
} catch (Exception e) {       // 父类异常放最后
    System.out.println("其他异常");
}
    复制
  

    public class ThrowsDemo {
    // throws 声明方法可能抛出的异常
    public static int divide(int a, int b) throws ArithmeticException {
        if (b == 0) {
            // throw 主动抛出异常
            throw new ArithmeticException("除数不能为零");
        }
        return a / b;
    }

    public static void main(String[] args) {
        try {
            System.out.println(divide(10, 0));
        } catch (ArithmeticException e) {
            System.out.println("出错: " + e.getMessage());
        }
    }
}
    复制
  

    // 继承 Exception 创建受检异常
class AgeInvalidException extends Exception {
    public AgeInvalidException(String msg) {
        super(msg);
    }
}

public class CustomException {
    public static void checkAge(int age) throws AgeInvalidException {
        if (age < 0 || age > 150) {
            throw new AgeInvalidException("年龄不合法: " + age);
        }
        System.out.println("年龄合法: " + age);
    }

    public static void main(String[] args) {
        try {
            checkAge(200);
        } catch (AgeInvalidException e) {
            System.out.println("捕获: " + e.getMessage());
        }
    }
}
    复制
  

    import java.util.ArrayList;
import java.util.List;

public class ArrayListDemo {
    public static void main(String[] args) {
        // 创建 ArrayList（泛型指定元素类型）
        List<String> fruits = new ArrayList<>();

        // 添加元素
        fruits.add("苹果");
        fruits.add("香蕉");
        fruits.add("橘子");

        // 获取元素
        System.out.println("第二个: " + fruits.get(1));

        // 修改元素
        fruits.set(0, "红富士");

        // 遍历
        for (String f : fruits) {
            System.out.println(f);
        }

        // 删除
        fruits.remove("橘子");
        System.out.println("删除后大小: " + fruits.size());
        System.out.println("包含香蕉? " + fruits.contains("香蕉"));
    }
}
    复制
  

    import java.util.HashMap;
import java.util.Map;

public class HashMapDemo {
    public static void main(String[] args) {
        // 创建 HashMap
        Map<String, Integer> scores = new HashMap<>();

        // 添加键值对
        scores.put("张三", 90);
        scores.put("李四", 85);
        scores.put("王五", 95);

        // 根据键取值
        System.out.println("李四成绩: " + scores.get("李四"));

        // 修改：put 相同的键会覆盖
        scores.put("张三", 88);
        System.out.println("张三新成绩: " + scores.get("张三"));

        // 遍历
        for (Map.Entry<String, Integer> entry : scores.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }

        // 判断是否包含某个键
        System.out.println("有王五? " + scores.containsKey("王五"));
        System.out.println("大小: " + scores.size());
    }
}
    复制
  

    import java.util.HashSet;
import java.util.Set;

public class HashSetDemo {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Java");
        set.add("Python");
        set.add("Java");  // 重复，不会被添加
        set.add("C++");

        System.out.println("大小: " + set.size());  // 3
        for (String s : set) {
            System.out.println(s);
        }

        // 删除
        set.remove("C++");
        System.out.println("删除后包含 C++? " + set.contains("C++"));
    }
}
    复制
  

    import java.util.HashMap;
import java.util.Map;

public class WordCount {
    public static void main(String[] args) {
        String[] words = {"java", "python", "java", "c++", "python", "java"};

        Map<String, Integer> count = new HashMap<>();
        for (String w : words) {
            // getOrDefault: 键不存在时返回默认值
            count.put(w, count.getOrDefault(w, 0) + 1);
        }

        for (Map.Entry<String, Integer> e : count.entrySet()) {
            System.out.println(e.getKey() + " 出现 " + e.getValue() + " 次");
        }
    }
}
    复制
  

    import java.util.ArrayList;
import java.util.List;

public class NoGeneric {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("hello");
        list.add(123);       // 可以混入不同类型！

        String s = (String) list.get(1);  // 运行时 ClassCastException
        System.out.println(s);
    }
}
    复制
  

    import java.util.ArrayList;
import java.util.List;

public class Generic {
    public static void main(String[] args) {
        // 指定集合只能存 String
        List<String> list = new ArrayList<>();
        list.add("hello");
        // list.add(123);  // 编译错误！编译期就拦截

        String s = list.get(0);  // 不需要强制转换
        System.out.println(s);
    }
}
    复制
  

    // 泛型类：T 是类型参数
public class Box<T> {
    private T item;

    public void put(T item) {
        this.item = item;
    }

    public T get() {
        return item;
    }

    public static void main(String[] args) {
        Box<String> strBox = new Box<>();
        strBox.put("礼物");
        System.out.println(strBox.get());

        Box<Integer> intBox = new Box<>();
        intBox.put(42);
        System.out.println(intBox.get());
    }
}
    复制
  

    public class GenericMethod {
    // 泛型方法：<T> 声明类型参数
    public static <T> void printArray(T[] arr) {
        for (T item : arr) {
            System.out.print(item + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Integer[] nums = {1, 2, 3};
        String[] strs = {"A", "B", "C"};

        printArray(nums);  // 自动推断 T = Integer
        printArray(strs);  // 自动推断 T = String
    }
}
    复制
  

    import java.util.ArrayList;
import java.util.List;

// 学生类（封装）
class Student {
    private int id;
    private String name;
    private double score;

    public Student(int id, String name, double score) {
        this.id = id;
        this.name = name;
        this.score = score;
    }

    public int getId() { return id; }
    public String getName() { return name; }
    public double getScore() { return score; }

    public String toString() {
        return String.format("学号:%d  姓名:%s  成绩:%.1f", id, name, score);
    }
}

// 学生管理系统
class StudentManager {
    private List<Student> students = new ArrayList<>();

    // 添加学生
    public void add(Student s) {
        students.add(s);
        System.out.println("添加成功: " + s.getName());
    }

    // 按学号删除
    public void removeById(int id) {
        students.removeIf(s -> s.getId() == id);
        System.out.println("已删除学号 " + id);
    }

    // 查询所有
    public void listAll() {
        if (students.isEmpty()) {
            System.out.println("暂无学生");
            return;
        }
        for (Student s : students) {
            System.out.println(s);
        }
    }

    // 统计平均分
    public double average() {
        if (students.isEmpty()) return 0;
        double sum = 0;
        for (Student s : students) sum += s.getScore();
        return sum / students.size();
    }
}

public class StudentSystem {
    public static void main(String[] args) {
        StudentManager mgr = new StudentManager();

        mgr.add(new Student(1, "张三", 90));
        mgr.add(new Student(2, "李四", 85));
        mgr.add(new Student(3, "王五", 78));

        System.out.println("\n--- 全部学生 ---");
        mgr.listAll();

        System.out.println("\n--- 删除李四 ---");
        mgr.removeById(2);

        System.out.println("\n--- 删除后 ---");
        mgr.listAll();

        System.out.printf("%n平均分: %.1f%n", mgr.average());
    }
}
    复制