面向对象与泛型

final class Fan {
    private final String make;
    private final double radius;
    private boolean on;
    private int speed;

    Fan(String make, double radius) {
        this.make = make;
        this.radius = radius;
    }

    void switchOn() { on = true; }
    void switchOff() { on = false; speed = 0; } // 规则留在对象内部
    void setSpeed(int speed) { this.speed = speed; }
    int speed() { return speed; }
}

final class RGB {
    private int r, g, b;

    RGB(int r, int g, int b) {
        if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255) {
            throw new IllegalArgumentException("component must be 0..255");
        }
        this.r = r; this.g = g; this.b = b;
    }

    void invert() { r = 255 - r; g = 255 - g; b = 255 - b; }
}

栈帧
int x ──────────────→ 5

堆
RGB 对象
 ↑
引用变量 rgb ────────→ RGB 对象

static void rename(Person p) { p.name = "Bob"; }   // 改的是双方共同指向的对象
static void replace(Person p) { p = new Person("New"); } // 只重绑方法内的引用副本

Person person = new Person("Alice");
rename(person);   // person.name == "Bob"
replace(person);  // person 仍指向原对象

Person a = new Person("Alice");
Person b = a;
b.name = "Bob";
// a.name 也变成 Bob

class Fan {
    Fan(String make) { }  // 写了带参构造器
}
new Fan();        // 编译错误
new Fan("IBM");   // 正确

class Child extends Parent {
    int value = log("子类字段");
    { log("子类实例块"); }

    Child() {
        super();                 // 必须是第一条显式构造调用
        log("子类构造体");
    }
}
// 输出：父类构造体 → 子类字段 → 子类实例块 → 子类构造体

Child()            { this(); }  // 委托给无参构造器
Child(int value)   { this(); this.value = value; }

final class Player {
    private static int createdCount;
    public static final int MAX_NAME_LENGTH = 40;

    static { createdCount = 0; }  // 类初始化时执行一次

    private final String name;

    Player(String name) { this.name = name; createdCount++; }

    static int createdCount() { return createdCount; }
}

final class BankAccount {
    private long balance;

    BankAccount(long openingBalance) {
        if (openingBalance < 0) {
            throw new IllegalArgumentException("balance cannot be negative");
        }
        this.balance = openingBalance;
    }

    void withdraw(long amount) {
        if (amount <= 0 || amount > balance) {
            throw new IllegalArgumentException("invalid withdrawal: " + amount);
        }
        balance -= amount;
    }

    long balance() { return balance; }
}

class Animal {
    protected final String name;
    Animal(String name) { this.name = name; }
    void sound() { System.out.println("……"); }
}

final class Dog extends Animal {
    Dog(String name) { super(name); }

    @Override
    void sound() { System.out.println("汪"); }
}

Animal animal = new Dog();  // 变量的静态类型是 Animal
animal.sound();             // 执行 Dog.sound()

static void run(GamingConsole game) {  // 声明是接口
    game.up(); game.down(); game.right();
}
run(new MarioGame());  // jump / go into pipe / move forward
run(new ChessGame());  // move piece up / down / right

@Override
void send() {
    super.send();                 // 先做通用逻辑
    System.out.println("已通过邮件发送");
}

if (p instanceof Student s) {
    s.setCollege("MyCollege");
}

interface Flyable {
    void fly();

    default String description() { return "flying object"; }

    static Flyable named(String name) { return () -> System.out.println(name + " flies"); }
}

abstract class Recipe {
    final void execute() { prepare(); cook(); cleanUp(); } // 流程固定，步骤可变
    abstract void prepare();
    abstract void cook();
    abstract void cleanUp();
}

interface SecureResource { }   // 用 instanceof 决定是否执行额外安全检查

class Report {
    private int currentRow;

    final class Cursor {                       // 成员内部类
        int current() { return currentRow; }   // 直接访问外部实例状态
    }

    static final class Formatter {             // 静态嵌套类
        static String header(String title) { return "[" + title + "]"; }
    }
}
Report report = new Report();
Report.Cursor cursor = report.new Cursor();   // 内部类需要外部实例
Report.Formatter.header("标题");              // 静态嵌套类直接创建

Runnable task = new Runnable() {
    @Override public void run() { System.out.println("一次性实现"); }
};

interface Engine { void start(); }

final class Car {
    private final Engine engine;
    Car(Engine engine) { this.engine = Objects.requireNonNull(engine); }
    void drive() { engine.start(); }
}

final class OrderProcessor {
    private final PaymentMethod payment;
    OrderProcessor(PaymentMethod payment) { this.payment = payment; }
}

public sealed interface Shape permits Circle, Rectangle, Square {}
public record Circle(double radius) implements Shape {}
public record Rectangle(double width, double height) implements Shape {}

static class MyCustomList<T> {
    private final List<T> list = new ArrayList<>();
    public void addElement(T element) { list.add(element); }
    public T get(int index) { return list.get(index); }
}
MyCustomList<String> names = new MyCustomList<>();
// names.addElement(42);  编译期就报错

static <T> T identity(T value) { return value; }

static class NumberList<T extends Number> {
    private final List<T> list = new ArrayList<>();
    void add(T value) { list.add(value); }
    double sum() {
        double total = 0.0;
        for (T value : list) total += value.doubleValue();  // 因上界而可用
        return total;
    }
}

static <T extends Document & Printable> void printAll(List<T> items) { ... }

static double sum(List<? extends Number> values) {   // 生产者：只安全地读
    double total = 0.0;
    for (Number n : values) total += n.doubleValue();
    return total;
}
static void addNumbers(List<? super Integer> values) { // 消费者：只安全地写
    values.add(1);
    values.add(2);
}

static <T> void copy(List<? super T> destination, List<? extends T> source) {
    for (T value : source) destination.add(value);
}

System.out.println(new ArrayList<String>().getClass()
        == new ArrayList<Integer>().getClass()); // true

new T();                    // 非法：不能实例化类型参数
new T[10];                  // 非法：不能创建泛型数组
static T data;              // 非法：静态环境不能引用类的类型参数
obj instanceof List<String> // 非法：运行时没有这个类型信息