继承、多态、抽象类与接口

// 父类
public class Animal {
    String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void eat() {
        System.out.println(name + "正在吃东西");
    }
    
    public void sleep() {
        System.out.println(name + "正在睡觉");
    }
}

// 子类继承父类
public class Dog extends Animal {
    // 子类特有的属性
    private String breed;
    
    public Dog(String name, String breed) {
        super(name); // 调用父类构造方法
        this.breed = breed;
    }
    
    // 子类特有的方法
    public void bark() {
        System.out.println(name + "汪汪叫");
    }
    
    // 重写父类方法
    @Override
    public void eat() {
        System.out.println(name + "(" + breed + ")在啃骨头");
    }
}

// 使用示例
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog("旺财", "金毛");
        dog.eat();    // 调用重写的方法
        dog.sleep();  // 继承自父类的方法
        dog.bark();   // 子类特有的方法
    }
}

旺财(金毛)在啃骨头
旺财正在睡觉
旺财汪汪叫

// √ 正确: 单继承
public class Dog extends Animal { }

// × 错误: Java不支持多重继承
// public class Dog extends Animal, Creature { }

class Animal { }
class Mammal extends Animal { }
class Dog extends Mammal { }  // 多层继承

// 父类
public class Parent {
    public int publicVar = 1;
    protected int protectedVar = 2;
    int defaultVar = 3;        // 包私有
    private int privateVar = 4;
    
    private void privateMethod() {
        System.out.println("私有方法");
    }
    
    protected void protectedMethod() {
        System.out.println("受保护方法");
    }
}

// 同包子类
public class Child extends Parent {
    public void accessMembers() {
        System.out.println(publicVar);      // √ 可访问
        System.out.println(protectedVar);   // √ 可访问
        System.out.println(defaultVar);     // √ 同包可访问
        // System.out.println(privateVar);  // × 编译错误
        
        protectedMethod();  // √ 可访问
        // privateMethod(); // × 编译错误
    }
}

// 不同包子类
public class AnotherChild extends Parent {
    public void accessMembers() {
        System.out.println(publicVar);      // √ 可访问
        System.out.println(protectedVar);   // √ 可访问
        // System.out.println(defaultVar);  // × 不同包无法访问
        // System.out.println(privateVar);  // × 编译错误
    }
}

public class Animal {
    private String name;
    
    public Animal(String name) {
        this.name = name;
    }
}

public class Dog extends Animal {
    private String breed;
    
    public Dog(String name, String breed) {
        super(name);  // 必须是构造方法第一行
        this.breed = breed;
    }
}

public class Parent {
    protected int value = 10;
}

public class Child extends Parent {
    private int value = 20;  // 同名变量(不推荐)
    
    public void printValues() {
        System.out.println("子类value: " + value);        // 20
        System.out.println("父类value: " + super.value);  // 10
    }
}

public class Parent {
    public void show() {
        System.out.println("父类方法");
    }
}

public class Child extends Parent {
    @Override
    public void show() {
        super.show();  // 先调用父类方法
        System.out.println("子类增强逻辑");
    }
}

class A {
    public A() {
        System.out.println("A的构造方法");
    }
}

class B extends A {
    public B() {
        super();  // 默认隐式调用
        System.out.println("B的构造方法");
    }
}

class C extends B {
    public C() {
        super();  // 默认隐式调用
        System.out.println("C的构造方法");
    }
}

public class Test {
    public static void main(String[] args) {
        new C();
    }
}

A的构造方法
B的构造方法
C的构造方法

public class Parent {
    // 私有成员不能直接继承
    private int privateField;
    
    // 构造方法不能继承
    public Parent(int value) { }
    
    // final方法不能重写
    public final void finalMethod() { }
    
    // static方法不参与多态
    public static void staticMethod() { }
}

// × 不推荐: 继承层次过深
class A { }
class B extends A { }
class C extends B { }
class D extends C { }
class E extends D { }
// ...继续继承

// 推荐: 控制在3层以内,优先使用组合

// × 不好的设计: 过度使用继承
class Animal { }
class FlyingAnimal extends Animal { }
class SwimmingAnimal extends Animal { }
// 问题: 鸭子既能飞又能游怎么办?

// √ 好的设计: 使用组合
class Animal {
    private MovementBehavior movement;
    
    public void move() {
        movement.move();
    }
}

interface MovementBehavior {
    void move();
}

class FlyingMovement implements MovementBehavior {
    public void move() {
        System.out.println("在空中飞翔");
    }
}

class SwimmingMovement implements MovementBehavior {
    public void move() {
        System.out.println("在水中游泳");
    }
}

// 使用
Animal duck = new Animal();
duck.movement = new FlyingMovement();  // 可以飞
duck.movement = new SwimmingMovement(); // 也可以游

class Animal {
    // 父类方法
    public void makeSound() {
        System.out.println("动物发出声音");
    }
    
    // 返回类型为父类
    public Animal create() {
        return new Animal();
    }
    
    // 受保护方法
    protected void eat() {
        System.out.println("动物在吃东西");
    }
    
    // final方法不能重写
    public final void sleep() {
        System.out.println("动物在睡觉");
    }
    
    // static方法不参与重写
    public static void count() {
        System.out.println("统计动物数量");
    }
}

class Dog extends Animal {
    // √ 正确重写
    @Override
    public void makeSound() {
        System.out.println("狗汪汪叫");
    }
    
    // √ 协变返回类型(JDK 5+)
    @Override
    public Dog create() {  // 返回类型可以是父类返回类型的子类
        return new Dog();
    }
    
    // √ 访问权限可以更宽松
    @Override
    public void eat() {  // protected → public
        System.out.println("狗在啃骨头");
    }
    
    // × 编译错误: 不能重写final方法
    // @Override
    // public void sleep() { }
    
    // 这不是重写,而是定义了新的静态方法(不推荐同名)
    public static void count() {
        System.out.println("统计狗的数量");
    }
}

class Parent {
    // final方法
    public final void finalMethod() { }
    
    // static方法
    public static void staticMethod() { }
    
    // private方法(子类不可见)
    private void privateMethod() { }
}

class Child extends Parent {
    // × 编译错误: final方法不能重写
    // public void finalMethod() { }
    
    // × 这不是重写,是新的静态方法
    public static void staticMethod() { }
    
    // √ 这是新方法,不是重写
    private void privateMethod() { }
}

public class Calculator {
    // 重载方法1: 两个整数
    public int add(int a, int b) {
        return a + b;
    }
    
    // 重载方法2: 三个整数
    public int add(int a, int b, int c) {
        return a + b + c;
    }
    
    // 重载方法3: 两个浮点数
    public double add(double a, double b) {
        return a + b;
    }
    
    // 重载方法4: 整数和浮点数
    public double add(int a, double b) {
        return a + b;
    }
    
    // × 编译错误: 仅返回类型不同不能重载
    // public double add(int a, int b) {
    //     return a + b;
    // }
    
    // √ 重载可以改变访问修饰符
    private long add(long a, long b) {
        return a + b;
    }
}

public class OverloadTest {
    public void test(int a) {
        System.out.println("int参数: " + a);
    }
    
    public void test(long a) {
        System.out.println("long参数: " + a);
    }
    
    public void test(Integer a) {
        System.out.println("Integer参数: " + a);
    }
    
    public void test(int... a) {
        System.out.println("可变参数: " + Arrays.toString(a));
    }
    
    public static void main(String[] args) {
        OverloadTest obj = new OverloadTest();
        
        obj.test(10);           // 调用 test(int)
        obj.test(10L);          // 调用 test(long)
        obj.test(Integer.valueOf(10)); // 调用 test(Integer)
        obj.test(10, 20);       // 调用 test(int...)
    }
}

class Parent {
    // 方法1
    public void show(int a) {
        System.out.println("Parent.show(int): " + a);
    }
    
    // 方法2: 重载
    public void show(double a) {
        System.out.println("Parent.show(double): " + a);
    }
}

class Child extends Parent {
    // 重写方法1
    @Override
    public void show(int a) {
        System.out.println("Child.show(int): " + a);
    }
    
    // 重载: 新增方法
    public void show(String s) {
        System.out.println("Child.show(String): " + s);
    }
    
    // 重写方法2
    @Override
    public void show(double a) {
        System.out.println("Child.show(double): " + a);
    }
}

public class Test {
    public static void main(String[] args) {
        Parent p = new Child();
        p.show(10);      // 动态绑定,调用 Child.show(int)
        p.show(10.5);    // 动态绑定,调用 Child.show(double)
        // p.show("hello"); // 编译错误: Parent没有show(String)
        
        Child c = new Child();
        c.show(10);      // 调用 Child.show(int)
        c.show(10.5);    // 调用 Child.show(double)
        c.show("hello"); // 调用 Child.show(String)
    }
}

class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("狗汪汪叫");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("猫喵喵叫");
    }
}

public class PolymorphismDemo {
    // 多态方法: 接收父类类型参数
    public static void letAnimalSpeak(Animal animal) {
        animal.makeSound();  // 运行时动态绑定
    }
    
    public static void main(String[] args) {
        Animal animal1 = new Dog();  // 向上转型
        Animal animal2 = new Cat();  // 向上转型
        
        animal1.makeSound();  // 输出: 狗汪汪叫
        animal2.makeSound();  // 输出: 猫喵喵叫
        
        // 统一接口处理不同类型对象
        letAnimalSpeak(new Dog());  // 输出: 狗汪汪叫
        letAnimalSpeak(new Cat());  // 输出: 猫喵喵叫
    }
}

Animal animal = new Dog();  // 向上转型
animal.makeSound();  // 调用Dog重写的方法
// animal.bark();    // 编译错误: 父类引用无法调用子类特有方法

Animal animal = new Dog();  // 向上转型

// 不安全的向下转型
// Dog dog = (Dog) animal;  // 编译通过,运行时可能出错

// 安全的向下转型
if (animal instanceof Dog) {
    Dog dog = (Dog) animal;  // 向下转型
    dog.bark();  // 调用子类特有方法
}

class Animal { }
class Dog extends Animal { }
class Cat extends Animal { }

public class InstanceOfDemo {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();
        Animal animal3 = new Animal();
        
        // instanceof判断
        System.out.println(animal1 instanceof Animal);  // true
        System.out.println(animal1 instanceof Dog);     // true
        System.out.println(animal1 instanceof Cat);     // false
        System.out.println(animal3 instanceof Dog);     // false
        
        // Java 16+: 模式匹配(预览特性)
        if (animal1 instanceof Dog dog) {
            dog.bark();  // 直接使用dog变量
        }
    }
}

public void processAnimal(Animal animal) {
    // 方式1: 传统instanceof检查
    if (animal instanceof Dog) {
        Dog dog = (Dog) animal;
        dog.bark();
    } else if (animal instanceof Cat) {
        Cat cat = (Cat) animal;
        cat.meow();
    }
    
    // 方式2: Java 16+ 模式匹配
    if (animal instanceof Dog dog) {
        dog.bark();
    } else if (animal instanceof Cat cat) {
        cat.meow();
    }
    
    // 方式3: 多态方法(推荐)
    animal.makeSound();  // 无需类型转换
}

// 统一处理不同类型的Shape对象
public class Canvas {
    // 多态参数
    public void draw(Shape shape) {
        shape.draw();  // 根据实际对象调用对应draw方法
    }
    
    public void drawMultiple(Shape... shapes) {
        for (Shape shape : shapes) {
            shape.draw();
        }
    }
}

abstract class Shape {
    abstract void draw();
}

class Circle extends Shape {
    void draw() {
        System.out.println("绘制圆形");
    }
}

class Rectangle extends Shape {
    void draw() {
        System.out.println("绘制矩形");
    }
}

// 使用
Canvas canvas = new Canvas();
canvas.draw(new Circle());      // 绘制圆形
canvas.draw(new Rectangle());   // 绘制矩形
canvas.drawMultiple(new Circle(), new Rectangle());  // 批量绘制

// 统一集合管理不同子类对象
List<Animal> animals = new ArrayList<>();
animals.add(new Dog());
animals.add(new Cat());
animals.add(new Bird());

// 统一处理
for (Animal animal : animals) {
    animal.makeSound();  // 多态调用
}

interface Product {
    void use();
}

class ProductA implements Product {
    public void use() {
        System.out.println("使用产品A");
    }
}

class ProductB implements Product {
    public void use() {
        System.out.println("使用产品B");
    }
}

class ProductFactory {
    // 静态工厂方法返回接口类型
    public static Product createProduct(String type) {
        switch (type) {
            case "A":
                return new ProductA();
            case "B":
                return new ProductB();
            default:
                throw new IllegalArgumentException("未知产品类型");
        }
    }
}

// 使用
Product product = ProductFactory.createProduct("A");
product.use();  // 多态调用

// 策略接口
interface PaymentStrategy {
    void pay(int amount);
}

// 具体策略
class CreditCardPayment implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("信用卡支付: " + amount + "元");
    }
}

class AlipayPayment implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("支付宝支付: " + amount + "元");
    }
}

// 上下文类
class ShoppingCart {
    private PaymentStrategy strategy;
    
    // 动态设置策略
    public void setPaymentStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void checkout(int amount) {
        strategy.pay(amount);  // 多态调用
    }
}

// 使用
ShoppingCart cart = new ShoppingCart();
cart.setPaymentStrategy(new CreditCardPayment());
cart.checkout(100);  // 信用卡支付

cart.setPaymentStrategy(new AlipayPayment());
cart.checkout(200);  // 支付宝支付

// 无需为每种动物编写独立方法
public void letAnimalSpeak(Animal animal) {
    animal.makeSound();  // 一处代码处理所有子类
}

// 新增子类无需修改现有代码
class Bird extends Animal {
    @Override
    public void makeSound() {
        System.out.println("鸟儿叽叽喳喳");
    }
}
// letAnimalSpeak方法无需修改即可处理Bird

// 模块间通过接口通信,降低依赖
public class BusinessService {
    private DataSource dataSource;  // 接口类型
    
    // 可以注入任何DataSource实现
    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }
}

Animal animal = new Dog();
// animal.bark();  // 编译错误

// 需要向下转型
if (animal instanceof Dog) {
    ((Dog) animal).bark();
}

// 抽象类定义
public abstract class Animal {
    // 普通成员变量
    protected String name;
    private int age;
    
    // 构造方法
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 抽象方法(无实现)
    public abstract void makeSound();
    
    // 抽象方法(无实现)
    public abstract void move();
    
    // 具体方法
    public void sleep() {
        System.out.println(name + "在睡觉");
    }
    
    // final方法(不能被子类重写)
    public final void die() {
        System.out.println(name + "死亡");
    }
    
    // static方法
    public static void describe() {
        System.out.println("这是一个动物类");
    }
}

// 子类实现抽象方法
public class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);  // 调用抽象类构造方法
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + "汪汪叫");
    }
    
    @Override
    public void move() {
        System.out.println(name + "在奔跑");
    }
}

// × 编译错误: 抽象类不能实例化
// Animal animal = new Animal("测试", 1);

// √ 通过具体子类实例化
Animal dog = new Dog("旺财", 3);

// 抽象类提供模板实现
public abstract class AbstractDao<T> {
    // 具体方法: 公共逻辑
    public void save(T entity) {
        if (validate(entity)) {
            doSave(entity);
        }
    }
    
    // 具体方法: 验证逻辑可复用
    protected boolean validate(T entity) {
        return entity != null;
    }
    
    // 抽象方法: 子类实现具体保存逻辑
    protected abstract void doSave(T entity);
    
    // 抽象方法: 子类实现具体查询逻辑
    public abstract T findById(Long id);
}

// 子类实现
public class UserDao extends AbstractDao<User> {
    @Override
    protected void doSave(User user) {
        System.out.println("保存用户: " + user.getName());
    }
    
    @Override
    public User findById(Long id) {
        System.out.println("查询用户ID: " + id);
        return new User();
    }
}

// 抽象类定义算法骨架
public abstract class DataProcessor {
    // 模板方法: 定义算法骨架
    public final void process() {
        loadData();
        validateData();
        transformData();
        saveData();
    }
    
    // 抽象方法: 子类实现
    protected abstract void loadData();
    protected abstract void transformData();
    protected abstract void saveData();
    
    // 具体方法: 可复用的逻辑
    protected void validateData() {
        System.out.println("验证数据格式");
    }
}

// 具体子类
class CSVProcessor extends DataProcessor {
    protected void loadData() {
        System.out.println("从CSV文件加载数据");
    }
    
    protected void transformData() {
        System.out.println("转换CSV数据格式");
    }
    
    protected void saveData() {
        System.out.println("保存CSV数据");
    }
}

// 接口定义
public interface Flyable {
    // 常量: 默认 public static final
    int MAX_HEIGHT = 10000;
    
    // 抽象方法: 默认 public abstract
    void fly();
    
    // 默认方法(JDK 8+): 有具体实现
    default void land() {
        System.out.println("降落中...");
    }
    
    // 静态方法(JDK 8+): 工具方法
    static void checkWeather() {
        System.out.println("检查天气状况");
    }
    
    // 私有方法(JDK 9+): 代码复用
    private void log(String message) {
        System.out.println("[LOG] " + message);
    }
}

// 实现接口
public class Bird implements Flyable {
    @Override
    public void fly() {
        System.out.println("鸟儿在飞翔");
    }
    
    // 可以重写默认方法
    @Override
    public void land() {
        Flyable.super.land();  // 调用接口默认实现
        System.out.println("鸟儿着陆");
    }
}

// 使用
Flyable bird = new Bird();
bird.fly();      // 调用实现类方法
bird.land();     // 调用默认方法
Flyable.checkWeather();  // 调用静态方法

interface Flyable {
    void fly();  // 只有抽象方法
}

interface Flyable {
    void fly();
    
    // 默认方法: 向后兼容
    default void startEngine() {
        System.out.println("启动引擎");
    }
    
    // 静态方法: 工具方法
    static void checkFuel() {
        System.out.println("检查燃料");
    }
}

interface Flyable {
    void fly();
    
    default void flyHigh() {
        checkCondition();  // 复用私有方法
        System.out.println("高空飞行");
    }
    
    default void flyLow() {
        checkCondition();  // 复用私有方法
        System.out.println("低空飞行");
    }
    
    // 私有方法: 复用代码
    private void checkCondition() {
        System.out.println("检查飞行条件");
    }
    
    // 私有静态方法
    private static void log(String message) {
        System.out.println("[LOG] " + message);
    }
}

interface InterfaceA {
    default void show() {
        System.out.println("InterfaceA.show");
    }
}

interface InterfaceB {
    default void show() {
        System.out.println("InterfaceB.show");
    }
}

// 实现多个接口
class MyClass implements InterfaceA, InterfaceB {
    // 必须重写冲突的默认方法
    @Override
    public void show() {
        // 方式1: 调用指定接口的默认方法
        InterfaceA.super.show();
        
        // 方式2: 提供新实现
        System.out.println("MyClass.show");
    }
}

// 多接口继承
interface InterfaceC extends InterfaceA, InterfaceB {
    // 接口也可以重写默认方法
    @Override
    default void show() {
        InterfaceA.super.show();
        System.out.println("InterfaceC.show");
    }
}

// 自定义函数式接口
@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b);
}

// 使用Lambda表达式
Calculator add = (a, b) -> a + b;
Calculator multiply = (a, b) -> a * b;

System.out.println(add.calculate(5, 3));       // 8
System.out.println(multiply.calculate(5, 3));  // 15

// Java内置函数式接口
// Predicate<T>: 判断型接口
Predicate<Integer> isEven = n -> n % 2 == 0;
System.out.println(isEven.test(4));  // true

// Consumer<T>: 消费型接口
Consumer<String> printer = s -> System.out.println(s);
printer.accept("Hello");  // Hello

// Supplier<T>: 供给型接口
Supplier<Double> randomSupplier = () -> Math.random();
System.out.println(randomSupplier.get());

// Function<T, R>: 函数型接口
Function<String, Integer> stringLength = s -> s.length();
System.out.println(stringLength.apply("Hello"));  // 5

// 抽象类: is-a关系,共享代码
public abstract class Vehicle {
    protected String brand;  // 成员变量
    protected int speed;
    
    public Vehicle(String brand) {  // 构造方法
        this.brand = brand;
    }
    
    // 抽象方法
    public abstract void start();
    
    // 具体方法: 共享代码
    public void stop() {
        System.out.println(brand + "停止运行");
    }
    
    // 私有方法
    private void log(String message) {
        System.out.println(message);
    }
}

// 接口: can-do关系,行为规范
public interface Flyable {
    int MAX_HEIGHT = 10000;  // 常量
    
    void fly();  // 抽象方法
    
    // 默认方法
    default void land() {
        System.out.println("降落");
    }
}

// 组合使用
public class Airplane extends Vehicle implements Flyable {
    public Airplane(String brand) {
        super(brand);
    }
    
    @Override
    public void start() {
        System.out.println(brand + "飞机启动");
    }
    
    @Override
    public void fly() {
        System.out.println(brand + "飞机起飞");
    }
}

// √ 适合使用抽象类
// 1. 需要共享代码和状态
public abstract class Employee {
    protected String name;
    protected double salary;
    
    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }
    
    // 共享方法
    public void work() {
        System.out.println(name + "在工作中");
    }
    
    // 抽象方法
    public abstract double calculateBonus();
}

// 2. 需要控制子类初始化
public abstract class DatabaseConnection {
    protected String url;
    
    public DatabaseConnection(String url) {
        this.url = url;
        connect();  // 子类必须先连接
    }
    
    protected abstract void connect();
}

// 3. 需要protected成员
public abstract class Account {
    protected double balance;
    
    protected void updateBalance(double amount) {
        this.balance += amount;
    }
}

// √ 适合使用接口
// 1. 定义行为规范,无状态共享
public interface Comparable<T> {
    int compareTo(T o);
}

// 2. 实现多重继承
public class Duck implements Flyable, Swimmable, Walkable {
    // 具备多种能力
}

// 3. 为不相关类定义共同行为
public interface Serializable { }
// 任何类都可实现,无论继承层次

// 4. 函数式接口
@FunctionalInterface
public interface ActionListener {
    void actionPerformed(ActionEvent e);
}

// 接口定义规范
public interface DataSource {
    Connection getConnection();
}

// 抽象类提供部分实现
public abstract class AbstractDataSource implements DataSource {
    protected String url;
    protected String username;
    
    public AbstractDataSource(String url, String username) {
        this.url = url;
        this.username = username;
    }
    
    // 共享代码
    protected void validateConfig() {
        if (url == null || url.isEmpty()) {
            throw new IllegalArgumentException("URL不能为空");
        }
    }
}

// 具体实现
public class MySQLDataSource extends AbstractDataSource {
    public MySQLDataSource(String url, String username) {
        super(url, username);
    }
    
    @Override
    public Connection getConnection() {
        validateConfig();  // 复用抽象类方法
        // 返回MySQL连接
        return null;
    }
}

// 密封类：只允许 Circle、Square、Triangle 三个子类
public sealed class Shape permits Circle, Square, Triangle {}

// 直接子类必须声明为 final / sealed / non-sealed
public final class Circle extends Shape {}          // 不再允许下级继承
public sealed class Square extends Shape permits ColoredSquare {}
public non-sealed class Triangle extends Shape {}   // 恢复开放继承

// record 隐式 final，天然满足 sealed 约束
public sealed interface Expr permits ConstantExpr, PlusExpr, TimesExpr {
    int eval();
}

public record ConstantExpr(int i) implements Expr {
    public int eval() { return i; }
}

public record PlusExpr(Expr a, Expr b) implements Expr {
    public int eval() { return a.eval() + b.eval(); }
}

public record TimesExpr(Expr a, Expr b) implements Expr {
    public int eval() { return a.eval() * b.eval(); }
}

// 编译器验证：所有密封子类都有分支，无需 default
static double area(Shape s) {
    return switch (s) {
        case Circle c -> Math.PI * c.radius() * c.radius();
        case Square sq -> sq.side() * sq.side();
        case Triangle t -> t.base() * t.height() / 2;
    };
}

class Animal { }
class Dog extends Animal { }
class Cat extends Animal { }

public class InstanceOfDemo {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();
        Animal animal3 = null;
        
        // 基本用法
        System.out.println(animal1 instanceof Animal);  // true: Dog是Animal的子类
        System.out.println(animal1 instanceof Dog);     // true: 实际类型是Dog
        System.out.println(animal1 instanceof Cat);     // false: 不是Cat实例
        
        // null的特殊处理
        System.out.println(animal3 instanceof Dog);     // false: null instanceof 任何类型都是false
        
        // 编译时类型检查
        String str = "hello";
        // System.out.println(str instanceof Animal);  // 编译错误: 类型不兼容
        
        // 数组类型检查
        int[] arr = new int[5];
        System.out.println(arr instanceof int[]);    // true
        System.out.println(arr instanceof Object);   // true: 数组是Object的子类
    }
}

// 传统写法
public void processOld(Animal animal) {
    if (animal instanceof Dog) {
        Dog dog = (Dog) animal;
        dog.bark();
    }
}

// Java 16+ 模式匹配
public void processNew(Animal animal) {
    if (animal instanceof Dog dog) {
        dog.bark();  // 直接使用dog变量
    }
}

// 带条件的模式匹配
public void processWithCondition(Animal animal) {
    if (animal instanceof Dog dog && dog.getAge() > 3) {
        dog.bark();
    }
}

class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println("汪汪叫");
    }
    
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

public class UpcastingDemo {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Animal animal = dog;  // 向上转型(自动)
        
        animal.eat();   // 调用Dog重写的方法: 狗吃骨头
        // animal.bark();  // 编译错误: 无法调用子类特有方法
        
        // 编译时类型 vs 运行时类型
        System.out.println(animal.getClass().getName());  // Dog
    }
}

public class DowncastingDemo {
    public static void main(String[] args) {
        // 场景1: 正确的向下转型
        Animal animal1 = new Dog();  // 向上转型
        if (animal1 instanceof Dog) {
            Dog dog = (Dog) animal1;  // 向下转型
            dog.bark();  // 可以调用子类特有方法
        }
        
        // 场景2: 错误的向下转型
        Animal animal2 = new Cat();
        // Dog dog = (Dog) animal2;  // 编译通过,运行时抛出ClassCastException
        if (animal2 instanceof Dog) {
            Dog dog = (Dog) animal2;
        } else {
            System.out.println("类型不匹配,无法转换");
        }
        
        // 场景3: Java 16+ 模式匹配
        if (animal1 instanceof Dog dog) {
            dog.bark();  // 类型转换和检查一步完成
        }
    }
}

public class TypeConversionBestPractice {
    // √ 推荐: 使用多态
    public void processAnimal1(Animal animal) {
        animal.makeSound();  // 无需类型转换
    }
    
    // √ 可接受: 必要时的类型检查
    public void processAnimal2(Animal animal) {
        if (animal instanceof Dog dog) {
            dog.bark();
        } else if (animal instanceof Cat cat) {
            cat.meow();
        }
    }
    
    // × 不推荐: 过度使用类型检查
    public void processAnimal3(Animal animal) {
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.bark();
            dog.eat();
            dog.sleep();
            // ... 大量Dog特有方法
        }
        // 应该考虑重新设计,使用多态或访问者模式
    }
    
    // √ 推荐: 访问者模式处理复杂逻辑
    interface AnimalVisitor {
        void visit(Dog dog);
        void visit(Cat cat);
    }
    
    public void processAnimal4(Animal animal, AnimalVisitor visitor) {
        if (animal instanceof Dog dog) {
            visitor.visit(dog);
        } else if (animal instanceof Cat cat) {
            visitor.visit(cat);
        }
    }
}

// × 危险代码
Animal animal = getAnimal();  // 可能返回null
if (animal instanceof Dog) {
    Dog dog = (Dog) animal;  // 安全
}
// 但如果后续使用animal时要小心
animal.eat();  // animal可能为null!

// √ 安全代码
Animal animal = getAnimal();
if (animal != null) {
    animal.eat();  // 安全
    if (animal instanceof Dog dog) {
        dog.bark();
    }
}

// × 设计问题: 过度使用instanceof
public void process(Object obj) {
    if (obj instanceof String) {
        String str = (String) obj;
        System.out.println(str.length());
    } else if (obj instanceof Integer) {
        Integer num = (Integer) obj;
        System.out.println(num * 2);
    } else if (obj instanceof Double) {
        Double num = (Double) obj;
        System.out.println(num * 3);
    }
    // 违反开闭原则,新增类型需要修改代码
}

// √ 更好的设计: 使用重载
public void process(String str) {
    System.out.println(str.length());
}

public void process(Integer num) {
    System.out.println(num * 2);
}

public void process(Double num) {
    System.out.println(num * 3);
}

// 数组协变(有风险)
String[] strings = new String[10];
Object[] objects = strings;  // 向上转型,编译通过

// objects[0] = new Integer(1);  // 编译通过,但运行时抛出ArrayStoreException

// √ 安全的数组操作
Object[] objects = new Object[10];
objects[0] = "hello";
objects[1] = 123;  // 安全

// 泛型数组(推荐)
List<String>[] stringLists = new ArrayList[10];  // 编译警告
List<String>[] stringLists = (List<String>[]) new ArrayList[10];  // 安全但需要强转

// 抽象类定义模板
public abstract class DataExporter {
    // 模板方法: 定义算法骨架,final防止子类重写
    public final void export(String data) {
        validateData(data);
        String processed = processData(data);
        String formatted = formatData(processed);
        saveData(formatted);
        logExport(data);
    }
    
    // 抽象方法: 子类必须实现
    protected abstract String processData(String data);
    protected abstract String formatData(String data);
    protected abstract void saveData(String data);
    
    // 具体方法: 子类可选重写
    protected void validateData(String data) {
        if (data == null || data.isEmpty()) {
            throw new IllegalArgumentException("数据不能为空");
        }
    }
    
    // 钩子方法: 子类可选重写
    protected void logExport(String data) {
        System.out.println("数据导出完成");
    }
}

// 具体子类: CSV导出
public class CSVExporter extends DataExporter {
    @Override
    protected String processData(String data) {
        return data.replace(",", ";");
    }
    
    @Override
    protected String formatData(String data) {
        return "CSV格式: " + data;
    }
    
    @Override
    protected void saveData(String data) {
        System.out.println("保存到CSV文件: " + data);
    }
}

// 具体子类: JSON导出
public class JSONExporter extends DataExporter {
    @Override
    protected String processData(String data) {
        return "{\"data\":\"" + data + "\"}";
    }
    
    @Override
    protected String formatData(String data) {
        return "JSON格式: " + data;
    }
    
    @Override
    protected void saveData(String data) {
        System.out.println("保存到JSON文件: " + data);
    }
    
    // 重写钩子方法
    @Override
    protected void logExport(String data) {
        System.out.println("JSON数据导出完成: " + data);
    }
}

// 使用
DataExporter csvExporter = new CSVExporter();
csvExporter.export("name,age,city");

DataExporter jsonExporter = new JSONExporter();
jsonExporter.export("name:张三,age:25,city:北京");

// 策略接口
public interface SortStrategy {
    <T extends Comparable<T>> void sort(List<T> list);
}

// 具体策略: 冒泡排序
public class BubbleSortStrategy implements SortStrategy {
    @Override
    public <T extends Comparable<T>> void sort(List<T> list) {
        System.out.println("使用冒泡排序");
        // 冒泡排序实现
        for (int i = 0; i < list.size() - 1; i++) {
            for (int j = 0; j < list.size() - 1 - i; j++) {
                if (list.get(j).compareTo(list.get(j + 1)) > 0) {
                    T temp = list.get(j);
                    list.set(j, list.get(j + 1));
                    list.set(j + 1, temp);
                }
            }
        }
    }
}

// 具体策略: 快速排序
public class QuickSortStrategy implements SortStrategy {
    @Override
    public <T extends Comparable<T>> void sort(List<T> list) {
        System.out.println("使用快速排序");
        // 快速排序实现(简化版)
        Collections.sort(list);
    }
}

// 上下文类
public class SortedList<T extends Comparable<T>> {
    private List<T> list;
    private SortStrategy strategy;
    
    public SortedList(List<T> list) {
        this.list = list;
    }
    
    // 设置策略
    public void setSortStrategy(SortStrategy strategy) {
        this.strategy = strategy;
    }
    
    // 执行排序
    public void sort() {
        if (strategy != null) {
            strategy.sort(list);
        }
    }
    
    public List<T> getList() {
        return list;
    }
}

// 使用
List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 9, 3);
SortedList<Integer> sortedList = new SortedList<>(new ArrayList<>(numbers));

// 策略1: 冒泡排序
sortedList.setSortStrategy(new BubbleSortStrategy());
sortedList.sort();
System.out.println(sortedList.getList());

// 策略2: 快速排序
sortedList.setSortStrategy(new QuickSortStrategy());
sortedList.sort();
System.out.println(sortedList.getList());

// 抽象组件
public abstract class FileSystemComponent {
    protected String name;
    
    public FileSystemComponent(String name) {
        this.name = name;
    }
    
    public abstract void display(int depth);
    public abstract int getSize();
}

// 叶子节点: 文件
public class File extends FileSystemComponent {
    private int size;
    
    public File(String name, int size) {
        super(name);
        this.size = size;
    }
    
    @Override
    public void display(int depth) {
        System.out.println("-".repeat(depth) + name);
    }
    
    @Override
    public int getSize() {
        return size;
    }
}

// 组合节点: 文件夹
public class Folder extends FileSystemComponent {
    private List<FileSystemComponent> children = new ArrayList<>();
    
    public Folder(String name) {
        super(name);
    }
    
    // 添加子组件
    public void add(FileSystemComponent component) {
        children.add(component);
    }
    
    // 移除子组件
    public void remove(FileSystemComponent component) {
        children.remove(component);
    }
    
    @Override
    public void display(int depth) {
        System.out.println("-".repeat(depth) + name + "/");
        for (FileSystemComponent child : children) {
            child.display(depth + 2);
        }
    }
    
    @Override
    public int getSize() {
        int totalSize = 0;
        for (FileSystemComponent child : children) {
            totalSize += child.getSize();
        }
        return totalSize;
    }
}

// 使用
Folder root = new Folder("根目录");

Folder documents = new Folder("文档");
documents.add(new File("简历.docx", 1024));
documents.add(new File("报告.pdf", 2048));

Folder pictures = new Folder("图片");
pictures.add(new File("照片.jpg", 3072));
pictures.add(new File("图标.png", 512));

root.add(documents);
root.add(pictures);
root.add(new File("readme.txt", 256));

root.display(0);
System.out.println("总大小: " + root.getSize() + " bytes");

// × 错误示范: 不恰当的继承关系
class Stack extends Vector { }  // 栈不应该继承向量
class Properties extends Hashtable { }  // 属性不应该继承哈希表

// 问题: 暴露了父类不应该暴露的方法
Stack<String> stack = new Stack<>();
stack.add(0, "element");  // 栈不应该支持在任意位置插入

// √ 正确做法: 使用组合
class Stack<E> {
    private LinkedList<E> list = new LinkedList<>();
    
    public void push(E item) {
        list.addFirst(item);
    }
    
    public E pop() {
        return list.removeFirst();
    }
}

// × 错误示范: 子类改变了父类的行为约定
class Rectangle {
    protected int width;
    protected int height;
    
    public void setWidth(int width) {
        this.width = width;
    }
    
    public void setHeight(int height) {
        this.height = height;
    }
    
    public int getArea() {
        return width * height;
    }
}

class Square extends Rectangle {
    @Override
    public void setWidth(int width) {
        this.width = width;
        this.height = width;  // 改变了父类的行为约定
    }
    
    @Override
    public void setHeight(int height) {
        this.height = height;
        this.width = height;  // 改变了父类的行为约定
    }
}

// 问题: 无法用Square替换Rectangle
public void test(Rectangle rect) {
    rect.setWidth(5);
    rect.setHeight(4);
    // Rectangle: area = 20
    // Square: area = 16  行为不一致!
    assert rect.getArea() == 20;  // Square会导致断言失败
}

// √ 正确做法: 不应该建立继承关系
class Shape {
    abstract int getArea();
}

class Rectangle extends Shape { }
class Square extends Shape { }  // 各自独立实现

// × 危险代码: 构造方法中调用可重写的方法
class Parent {
    protected int value;
    
    public Parent() {
        this.value = 10;
        init();  // 在构造方法中调用可重写的方法
    }
    
    protected void init() {
        System.out.println("Parent init, value = " + value);
    }
}

class Child extends Parent {
    private String name;
    
    public Child(String name) {
        super();  // 先调用父类构造方法
        this.name = name;
    }
    
    @Override
    protected void init() {
        // 此时name还未初始化,值为null!
        System.out.println("Child init, name = " + name);
    }
}

// 问题演示
Child child = new Child("张三");
// 输出: Child init, name = null  (name还未初始化)

// √ 正确做法: 避免在构造方法中调用可重写的方法
class Parent {
    protected int value;
    
    public Parent() {
        this.value = 10;
        // 不调用可重写的方法
    }
    
    public void init() {  // 改为public,让外部显式调用
        System.out.println("Parent init, value = " + value);
    }
}

class Child extends Parent {
    private String name;
    
    public Child(String name) {
        super();
        this.name = name;
    }
    
    @Override
    public void init() {
        System.out.println("Child init, name = " + name);  // name已初始化
    }
}

// 使用
Child child = new Child("张三");
child.init();  // 显式调用init,此时name已初始化

class Parent {
    public String name = "Parent";
    
    public void show() {
        System.out.println("Parent.show");
    }
}

class Child extends Parent {
    public String name = "Child";  // 隐藏父类变量(不推荐)
    
    @Override
    public void show() {
        System.out.println("Child.show");
    }
}

// 多态只对方法有效,对成员变量无效
Parent parent = new Child();
parent.show();           // 输出: Child.show (方法多态)
System.out.println(parent.name);  // 输出: Parent (变量不参与多态)

Child child = new Child();
System.out.println(child.name);  // 输出: Child

// 建议: 避免在子类中定义与父类同名的成员变量
// 将成员变量设为private,通过getter方法访问

class Parent {
    public static void staticMethod() {
        System.out.println("Parent.staticMethod");
    }
}

class Child extends Parent {
    public static void staticMethod() {  // 隐藏父类静态方法(不是重写)
        System.out.println("Child.staticMethod");
    }
}

// 静态方法不参与多态
Parent parent = new Child();
parent.staticMethod();  // 输出: Parent.staticMethod

// 编译时根据引用类型决定调用哪个方法
Parent.staticMethod();   // Parent.staticMethod
Child.staticMethod();    // Child.staticMethod

// 建议: 通过类名直接调用静态方法,避免产生误解

class Parent {
    private void privateMethod() {
        System.out.println("Parent.privateMethod");
    }
    
    public void callPrivate() {
        privateMethod();  // 调用私有方法
    }
}

class Child extends Parent {
    // 这不是重写,是新的私有方法
    private void privateMethod() {
        System.out.println("Child.privateMethod");
    }
}

Parent parent = new Child();
parent.callPrivate();  // 输出: Parent.privateMethod
// 私有方法对子类不可见,无法重写

// 建议: 如果希望子类可以自定义行为,使用protected或public

// × 错误认识
interface MyInterface {
    int value = 10;  // 这不是实例变量,是常量 public static final
}

// √ 正确理解
interface MyInterface {
    // 等价于: public static final int value = 10;
    int value = 10;
}

// 如果需要实例变量,使用抽象类
abstract class MyAbstractClass {
    protected int value = 10;  // 实例变量
}

// × 错误示范
interface Counter {
    int count = 0;  // 常量,不是实例变量
    
    default void increment() {
        // count++;  // 编译错误: 不能修改final变量
    }
}

// √ 正确做法: 默认方法只能访问常量和其他默认方法
interface Counter {
    int MAX_COUNT = 100;  // 常量
    
    default void checkCount(int count) {
        if (count > MAX_COUNT) {
            System.out.println("超过最大值");
        }
    }
}

interface A {
    default void show() {
        System.out.println("A.show");
    }
}

interface B {
    default void show() {
        System.out.println("B.show");
    }
}

// × 编译错误: 必须显式解决冲突
// class MyClass implements A, B { }

// √ 正确处理
class MyClass implements A, B {
    @Override
    public void show() {
        A.super.show();  // 选择A的实现
        B.super.show();  // 选择B的实现
        // 或提供新的实现
        System.out.println("MyClass.show");
    }
}

// 商品抽象类
public abstract class Product {
    protected String id;
    protected String name;
    protected double price;
    protected int stock;
    
    public Product(String id, String name, double price, int stock) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.stock = stock;
    }
    
    // 抽象方法: 不同商品计算折扣方式不同
    public abstract double calculateDiscount();
    
    // 具体方法: 显示商品信息
    public void displayInfo() {
        System.out.printf("商品ID: %s, 名称: %s, 价格: %.2f, 库存: %d%n",
                id, name, price, stock);
    }
    
    // getter和setter
    public double getPrice() {
        return price;
    }
    
    public int getStock() {
        return stock;
    }
    
    public void setStock(int stock) {
        this.stock = stock;
    }
}

// 实体商品
public class PhysicalProduct extends Product {
    private double weight;
    private String dimensions;
    
    public PhysicalProduct(String id, String name, double price, int stock,
                          double weight, String dimensions) {
        super(id, name, price, stock);
        this.weight = weight;
        this.dimensions = dimensions;
    }
    
    @Override
    public double calculateDiscount() {
        // 实体商品: 库存超过100打8折
        return stock > 100 ? price * 0.2 : 0;
    }
    
    // 计算运费
    public double calculateShipping() {
        return weight * 5;  // 每公斤5元
    }
}

// 数字商品
public class DigitalProduct extends Product {
    private String downloadUrl;
    private long fileSize;
    
    public DigitalProduct(String id, String name, double price, int stock,
                         String downloadUrl, long fileSize) {
        super(id, name, price, stock);
        this.downloadUrl = downloadUrl;
        this.fileSize = fileSize;
    }
    
    @Override
    public double calculateDiscount() {
        // 数字商品: 首次购买优惠10元
        return 10;
    }
    
    // 生成下载链接
    public String generateDownloadLink(String userId) {
        return downloadUrl + "?token=" + userId + "_" + System.currentTimeMillis();
    }
}

// 使用多态
public class ProductService {
    public void processProducts(List<Product> products) {
        for (Product product : products) {
            product.displayInfo();
            double discount = product.calculateDiscount();
            System.out.printf("折扣金额: %.2f%n", discount);
            System.out.println("---");
        }
    }
}

// 支付策略接口
public interface PaymentStrategy {
    boolean pay(double amount);
    String getPaymentMethod();
}

// 信用卡支付
public class CreditCardPayment implements PaymentStrategy {
    private String cardNumber;
    private String cvv;
    private String expiryDate;
    
    public CreditCardPayment(String cardNumber, String cvv, String expiryDate) {
        this.cardNumber = cardNumber;
        this.cvv = cvv;
        this.expiryDate = expiryDate;
    }
    
    @Override
    public boolean pay(double amount) {
        System.out.printf("使用信用卡支付 %.2f 元%n", amount);
        System.out.println("卡号: " + maskCardNumber(cardNumber));
        return true;
    }
    
    @Override
    public String getPaymentMethod() {
        return "信用卡";
    }
    
    private String maskCardNumber(String cardNumber) {
        return "**** **** **** " + cardNumber.substring(cardNumber.length() - 4);
    }
}

// 支付宝支付
public class AlipayPayment implements PaymentStrategy {
    private String account;
    
    public AlipayPayment(String account) {
        this.account = account;
    }
    
    @Override
    public boolean pay(double amount) {
        System.out.printf("使用支付宝支付 %.2f 元%n", amount);
        System.out.println("账号: " + account);
        return true;
    }
    
    @Override
    public String getPaymentMethod() {
        return "支付宝";
    }
}

// 微信支付
public class WeChatPayment implements PaymentStrategy {
    private String openid;
    
    public WeChatPayment(String openid) {
        this.openid = openid;
    }
    
    @Override
    public boolean pay(double amount) {
        System.out.printf("使用微信支付 %.2f 元%n", amount);
        System.out.println("OpenID: " + openid);
        return true;
    }
    
    @Override
    public String getPaymentMethod() {
        return "微信";
    }
}

// 订单类
public class Order {
    private String orderId;
    private List<Product> products = new ArrayList<>();
    private PaymentStrategy paymentStrategy;
    
    public Order(String orderId) {
        this.orderId = orderId;
    }
    
    public void addProduct(Product product) {
        products.add(product);
    }
    
    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }
    
    public double calculateTotal() {
        double total = 0;
        for (Product product : products) {
            total += product.getPrice() - product.calculateDiscount();
        }
        return total;
    }
    
    public boolean checkout() {
        double total = calculateTotal();
        System.out.println("订单号: " + orderId);
        System.out.printf("订单总额: %.2f 元%n", total);
        
        if (paymentStrategy != null) {
            System.out.println("支付方式: " + paymentStrategy.getPaymentMethod());
            return paymentStrategy.pay(total);
        } else {
            System.out.println("请选择支付方式");
            return false;
        }
    }
}

// 使用
Order order = new Order("ORD-2023-001");
order.addProduct(new PhysicalProduct("P001", "Java编程思想", 108.00, 150, 1.2, "16开"));
order.addProduct(new DigitalProduct("D001", "视频教程", 199.00, 999, "http://download.example.com", 1024));

// 策略1: 信用卡支付
order.setPaymentStrategy(new CreditCardPayment("6225888888888888", "123", "12/25"));
order.checkout();

// 策略2: 支付宝支付
order.setPaymentStrategy(new AlipayPayment("user@example.com"));
order.checkout();

// 促销组件抽象类
public abstract class PromotionComponent {
    protected String name;
    
    public PromotionComponent(String name) {
        this.name = name;
    }
    
    public abstract double calculateDiscount(Order order);
    public abstract void display(int depth);
}

// 单个促销
public class SinglePromotion extends PromotionComponent {
    private double discountAmount;
    private Predicate<Order> condition;
    
    public SinglePromotion(String name, double discountAmount, Predicate<Order> condition) {
        super(name);
        this.discountAmount = discountAmount;
        this.condition = condition;
    }
    
    @Override
    public double calculateDiscount(Order order) {
        return condition.test(order) ? discountAmount : 0;
    }
    
    @Override
    public void display(int depth) {
        System.out.println("-".repeat(depth) + name + " (减" + discountAmount + "元)");
    }
}

// 组合促销
public class CompositePromotion extends PromotionComponent {
    private List<PromotionComponent> promotions = new ArrayList<>();
    
    public CompositePromotion(String name) {
        super(name);
    }
    
    public void addPromotion(PromotionComponent promotion) {
        promotions.add(promotion);
    }
    
    @Override
    public double calculateDiscount(Order order) {
        double totalDiscount = 0;
        for (PromotionComponent promotion : promotions) {
            totalDiscount += promotion.calculateDiscount(order);
        }
        return totalDiscount;
    }
    
    @Override
    public void display(int depth) {
        System.out.println("-".repeat(depth) + name + ":");
        for (PromotionComponent promotion : promotions) {
            promotion.display(depth + 2);
        }
    }
}

// 使用
// 创建单个促销
PromotionComponent newMemberPromo = new SinglePromotion(
    "新用户立减", 20, order -> order.calculateTotal() > 100
);

PromotionComponent weekendPromo = new SinglePromotion(
    "周末特惠", 30, order -> true
);

// 创建组合促销
CompositePromotion holidayPackage = new CompositePromotion("节日大礼包");
holidayPackage.addPromotion(new SinglePromotion("满200减50", 50, order -> order.calculateTotal() >= 200));
holidayPackage.addPromotion(new SinglePromotion("新人券", 30, order -> true));

CompositePromotion allPromotions = new CompositePromotion("所有促销活动");
allPromotions.addPromotion(newMemberPromo);
allPromotions.addPromotion(weekendPromo);
allPromotions.addPromotion(holidayPackage);

// 显示促销结构
allPromotions.display(0);

// 计算折扣
Order order = new Order("ORD-001");
order.addProduct(new PhysicalProduct("P001", "商品A", 150, 10, 1.0, "标准"));
double totalDiscount = allPromotions.calculateDiscount(order);
System.out.println("总折扣: " + totalDiscount + "元");

// 菱形继承问题示例(假设Java支持多重继承)
class D {
    void method() { }
}
class B extends D {
    void method() { System.out.println("B"); }
}
class C extends D {
    void method() { System.out.println("C"); }
}
// 假设允许:
// class A extends B, C { }
// A调用method()时,调用B的还是C的? 二义性!

class Parent {
    int value = 10;
    
    Parent(int value) {
        this.value = value;
    }
    
    void show() {
        System.out.println("Parent: " + value);
    }
}

class Child extends Parent {
    int value = 20;
    
    Child() {
        super(100);  // 1. 调用父类构造方法
    }
    
    void show() {
        super.show();  // 2. 调用父类方法
        System.out.println("Child: " + value);
        System.out.println("Parent value: " + super.value);  // 3. 访问父类变量
    }
}

1. 编译时检查引用类型是否有该方法
2. 运行时获取对象的实际类型
3. 在实际类型的方法表中查找方法
4. 找到后执行方法

class Parent {
    public static void staticMethod() {
        System.out.println("Parent");
    }
}

class Child extends Parent {
    public static void staticMethod() {
        System.out.println("Child");
    }
}

Parent parent = new Child();
parent.staticMethod();  // 输出: Parent (不是Child!)
// 静态方法根据引用类型决定,与对象实际类型无关

class Parent {
    String name = "Parent";
}

class Child extends Parent {
    String name = "Child";
}

Parent parent = new Child();
System.out.println(parent.name);  // 输出: Parent (不是Child!)

interface MyInterface {
    void abstractMethod();  // 抽象方法
    
    default void defaultMethod() {  // 默认方法
        System.out.println("默认实现");
        privateMethod();  // 复用私有方法
    }
    
    static void staticMethod() {  // 静态方法
        System.out.println("静态方法");
    }
    
    private void privateMethod() {  // 私有方法
        System.out.println("私有方法");
    }
}

// 传统写法
if (obj instanceof String) {
    String str = (String) obj;
    System.out.println(str.length());
}

// Java 16+ 模式匹配
if (obj instanceof String str) {
    System.out.println(str.length());
}

// JDBC模板
abstract class JdbcTemplate {
    public final void execute(String sql) {
        Connection conn = getConnection();
        PreparedStatement stmt = createStatement(conn, sql);
        ResultSet rs = executeQuery(stmt);
        processResult(rs);
        closeResources(conn, stmt, rs);
    }
    
    protected abstract void processResult(ResultSet rs);
    // 其他方法有默认实现
}

public class Parent {
    public int publicVar = 1;
    protected int protectedVar = 2;
    int defaultVar = 3;        // 包私有
    private int privateVar = 4;
    
    private void privateMethod() {
        System.out.println("私有方法");
    }
    
    protected void protectedMethod() {
        System.out.println("受保护方法");
    }
}

// 同包子类
public class Child extends Parent {
    public void accessMembers() {
        System.out.println(publicVar);      // √ 可访问
        System.out.println(protectedVar);   // √ 可访问
        System.out.println(defaultVar);     // √ 同包可访问
        // System.out.println(privateVar);  // × 编译错误：私有成员不可访问
        
        protectedMethod();  // √ 可访问
        // privateMethod(); // × 编译错误
    }
}

// 不同包子类
public class AnotherChild extends Parent {
    public void accessMembers() {
        System.out.println(publicVar);      // √ 可访问
        System.out.println(protectedVar);   // √ 可访问（子类继承）
        // System.out.println(defaultVar);  // × 不同包无法访问
        // System.out.println(privateVar);  // × 编译错误
    }
}

public class BankAccount {
    private String accountNumber;  // 私有字段
    private double balance;        // 私有字段
    
    public BankAccount(String accountNumber, double balance) {
        this.accountNumber = accountNumber;
        this.balance = balance;
    }
    
    // 公共 getter 方法
    public String getAccountNumber() {
        return accountNumber;
    }
    
    public double getBalance() {
        return balance;
    }
    
    // 控制性的修改方法（非简单setter，包含业务校验）
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
    
    public boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;
    }
}

public class OuterClass {
    private class PrivateInnerClass { }      // 仅外部类内部可见
    protected class ProtectedInnerClass { }  // 同包或子类可见
    class DefaultInnerClass { }              // 同包可见
    public class PublicInnerClass { }        // 所有地方可见
}

public class FinalVariableDemo {
    // 编译时常量：声明时就确定值，编译器会内联优化
    public static final int MAX_SIZE = 100;
    public static final String APP_NAME = "OrderService";
    
    // 运行时常量：运行时确定值
    public static void main(String[] args) {
        // 基本类型 final 变量
        final int MAX_VALUE = 100;
        // MAX_VALUE = 200;  // 编译错误：无法修改 final 变量
        
        final double PI;
        PI = 3.14159;  // 第一次赋值（blank final）
        // PI = 3.14;  // 编译错误：无法再次赋值
        
        // 引用类型 final：引用不可变，对象内容可变
        final StringBuilder sb = new StringBuilder("Hello");
        sb.append(" World");  // √ 合法：修改对象内容
        System.out.println(sb);  // 输出: Hello World
        // sb = new StringBuilder("Hi");  // × 编译错误：无法修改引用
        
        final int[] arr = {1, 2, 3};
        arr[0] = 100;  // √ 合法：修改数组元素
        // arr = new int[5];  // × 编译错误：无法修改引用
    }
}

public class FinalFieldDemo {
    // 方式1：声明时赋值
    final int A = 1;
    
    // 方式2：初始化块赋值
    final int B;
    {
        B = 2;
    }
    
    // 方式3：构造方法赋值
    final int C;
    
    public FinalFieldDemo() {
        this.C = 3;
    }
    
    // 静态 final 变量
    static final double PI = 3.14159;
    static final int MAX_SIZE;
    static {
        MAX_SIZE = 100;  // 静态初始化块赋值
    }
}

class Parent {
    // final 方法：子类不能重写
    public final void display() {
        System.out.println("父类的 final 方法");
    }
    
    // private 方法隐含 final（子类不可见，无法重写）
    private void secret() {
        System.out.println("私有方法");
    }
}

class Child extends Parent {
    // × 编译错误：无法重写 final 方法
    // @Override
    // public void display() { }
    
    // 这不是重写，而是新方法
    private void secret() {
        System.out.println("子类的私有方法");
    }
}

// final 类不能被继承
final class FinalClass {
    public void method() {
        System.out.println("final 类的方法");
    }
}

// × 编译错误：无法继承 final 类
// class SubClass extends FinalClass { }

public class Constants {
    // 全局常量
    public static final double PI = 3.14159;
    public static final int MAX_VALUE = 100;
    public static final String APP_NAME = "MyApp";
    
    // 私有常量（仅供类内部使用）
    private static final int DEFAULT_SIZE = 10;
}

public class FinalInLambda {
    public void demo() {
        String prefix = "Hello ";  // effectively final（未显式声明final，但未修改）
        
        // Lambda 表达式访问局部变量
        Runnable r = () -> {
            System.out.println(prefix + "World");  // √ 合法
            // prefix = "Hi ";  // 如果修改 prefix，上面会报错
        };
        
        new Thread(r).start();
    }
    
    public void demoWithFinal() {
        final String suffix = "!";
        
        Runnable r = () -> {
            System.out.println("Hello" + suffix);
        };
        
        new Thread(r).start();
    }
}

import java.util.Objects;

public class Person {
    private String name;
    private int age;
    private String id;
    
    public Person(String name, int age, String id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }
    
    @Override
    public boolean equals(Object obj) {
        // 1. 检查是否是同一个对象（性能优化）
        if (this == obj) return true;
        
        // 2. 检查是否为 null 或类型不同
        if (obj == null || getClass() != obj.getClass()) return false;
        
        // 3. 类型转换并比较字段
        Person person = (Person) obj;
        return age == person.age && 
               Objects.equals(name, person.name) && 
               Objects.equals(id, person.id);
    }
    
    // 重写 equals 必须重写 hashCode
    @Override
    public int hashCode() {
        return Objects.hash(name, age, id);
    }
}

// hashCode 的正确实现
@Override
public int hashCode() {
    // 方式1：Objects.hash()（推荐，简洁）
    return Objects.hash(name, age, id);
    
    // 方式2：手动计算（性能更好）
    int result = name.hashCode();
    result = 31 * result + age;
    result = 31 * result + (id != null ? id.hashCode() : 0);
    return result;
}

public class ToStringDemo {
    private String name;
    private int age;
    
    public ToStringDemo(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    @Override
    public String toString() {
        return "ToStringDemo{name='" + name + "', age=" + age + "}";
    }
    
    public static void main(String[] args) {
        ToStringDemo obj = new ToStringDemo("张三", 25);
        
        // 打印对象会自动调用 toString()
        System.out.println(obj);  // ToStringDemo{name='张三', age=25}
        System.out.println(obj.toString());  // 同上
    }
}

import java.util.Arrays;

// 浅拷贝示例
class ShallowCopy implements Cloneable {
    private int[] data;
    
    public ShallowCopy(int[] data) {
        this.data = data;
    }
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();  // 默认浅拷贝
    }
    
    public int[] getData() { return data; }
}

// 深拷贝示例
class DeepCopy implements Cloneable {
    private int[] data;
    
    public DeepCopy(int[] data) {
        this.data = data.clone();
    }
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        DeepCopy cloned = (DeepCopy) super.clone();
        cloned.data = this.data.clone();  // 深拷贝引用类型
        return cloned;
    }
    
    public int[] getData() { return data; }
}

public class CloneDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        int[] original = {1, 2, 3};
        
        // 浅拷贝：修改副本会影响原对象
        ShallowCopy shallow1 = new ShallowCopy(original);
        ShallowCopy shallow2 = (ShallowCopy) shallow1.clone();
        shallow2.getData()[0] = 99;
        System.out.println("浅拷贝 - 原对象: " + Arrays.toString(shallow1.getData()));  // [99, 2, 3]
        
        // 深拷贝：修改副本不影响原对象
        DeepCopy deep1 = new DeepCopy(original);
        DeepCopy deep2 = (DeepCopy) deep1.clone();
        deep2.getData()[0] = 99;
        System.out.println("深拷贝 - 原对象: " + Arrays.toString(deep1.getData()));  // [1, 2, 3]
    }
}

// 推荐方式：try-with-resources
public class ResourceDemo {
    public static void main(String[] args) {
        try (MyResource resource = new MyResource()) {
            resource.use();
        }  // 自动调用 close() 方法
    }
}

class MyResource implements AutoCloseable {
    public void use() {
        System.out.println("使用资源");
    }
    
    @Override
    public void close() {
        System.out.println("关闭资源");
    }
}

public class StaticBlockDemo {
    private static final Map<String, String> CONFIG;
    
    static {
        CONFIG = new HashMap<>();
        CONFIG.put("host", "localhost");
        CONFIG.put("port", "8080");
        System.out.println("静态代码块执行");
    }
    
    public static void main(String[] args) {
        System.out.println("main 方法执行");
        System.out.println(CONFIG);
    }
}

public class InstanceBlockDemo {
    private String name;
    
    // 实例代码块
    {
        System.out.println("实例代码块执行");
        name = "默认名称";
    }
    
    public InstanceBlockDemo() {
        System.out.println("构造方法执行");
    }
    
    public static void main(String[] args) {
        new InstanceBlockDemo();
        System.out.println("---");
        new InstanceBlockDemo();
    }
    // 输出:
    // 实例代码块执行
    // 构造方法执行
    // ---
    // 实例代码块执行
    // 构造方法执行
}

class Parent {
    static {
        System.out.println("1. 父类静态代码块");
    }
    
    {
        System.out.println("4. 父类实例代码块");
    }
    
    public Parent() {
        System.out.println("5. 父类构造方法");
    }
}

class Child extends Parent {
    private static int staticVar = initStaticVar();
    
    static {
        System.out.println("3. 子类静态代码块");
    }
    
    private int instanceVar = initInstanceVar();
    
    {
        System.out.println("7. 子类实例代码块");
    }
    
    public Child() {
        System.out.println("8. 子类构造方法");
    }
    
    private static int initStaticVar() {
        System.out.println("2. 子类静态变量初始化");
        return 10;
    }
    
    private int initInstanceVar() {
        System.out.println("6. 子类实例变量初始化");
        return 20;
    }
}

public class InitializationOrderDemo {
    public static void main(String[] args) {
        new Child();
    }
}
// 输出:
// 1. 父类静态代码块
// 2. 子类静态变量初始化
// 3. 子类静态代码块
// 4. 父类实例代码块
// 5. 父类构造方法
// 6. 子类实例变量初始化
// 7. 子类实例代码块
// 8. 子类构造方法