面向对象（OOP）

┌─────────────────────────────────────┐
│            外部调用者               │
│                 ↓                   │
│     ┌───────────────────────┐      │
│     │   public 方法（接口）  │      │
│     └───────────────────────┘      │
│                 ↑                   │
│     ┌───────────────────────┐      │
│     │  private 属性（隐藏）  │      │
│     └───────────────────────┘      │
└─────────────────────────────────────┘

public class Person {
    // 1. 私有化属性
    private String name;
    private int age;
    
    // 2. 无参构造器
    public Person() {}
    
    // 3. 有参构造器
    public Person(String name, int age) {
        this.name = name;
        this.setAge(age);  // 调用 setter 进行校验
    }
    
    // 4. getter 方法
    public String getName() {
        return name;
    }
    
    // 5. setter 方法（包含校验逻辑）
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        // 在 setter 中进行数据校验
        if (age < 0 || age > 150) {
            throw new IllegalArgumentException("年龄必须在 0-150 之间");
        }
        this.age = age;
    }
}

        ┌───────────┐
        │   Animal  │  （父类/基类/超类）
        │  + name   │
        │  + eat()  │
        └─────┬─────┘
              │ extends
        ┌─────┴─────┐
   ┌────┴────┐ ┌────┴────┐
   │   Dog   │ │   Cat   │  （子类/派生类）
   │ + bark()│ │ + meow()│
   └─────────┘ └─────────┘

// 父类
public class Animal {
    protected String name;
    
    public void eat() {
        System.out.println(name + " 正在吃东西");
    }
}
 
// 子类继承父类
public class Dog extends Animal {
    
    public Dog(String name) {
        this.name = name;  // 继承自父类的属性
    }
    
    public void bark() {
        System.out.println(name + " 正在汪汪叫");
    }
    
    // 重写父类方法
    @Override
    public void eat() {
        System.out.println(name + " 正在啃骨头");
    }
}

public class Child extends Parent {
    private String name = "子类名称";
    
    public void show() {
        System.out.println(this.name);    // 子类的 name
        System.out.println(super.name);   // 父类的 name
        super.method();                    // 调用父类的方法
    }
    
    public Child() {
        super();  // 调用父类构造器（必须在第一行）
    }
}

public class Animal {
    public Animal create() {
        return new Animal();
    }
}
 
public class Dog extends Animal {
    // 协变返回类型：返回父类方法返回类型的子类
    @Override
    public Dog create() {
        return new Dog();
    }
}

        ┌───────────┐
        │  Animal   │
        │  + shout()│
        └─────┬─────┘
              │
    ┌─────────┼─────────┐
    │         │         │
┌───┴───┐ ┌───┴───┐ ┌───┴───┐
│  Dog  │ │  Cat  │ │  Pig  │
│shout()│ │shout()│ │shout()│
│ 汪汪  │ │ 喵喵  │ │ 哼哼  │
└───────┘ └───────┘ └───────┘

Animal a = new Dog();  a.shout();  // 汪汪
Animal a = new Cat();  a.shout();  // 喵喵
Animal a = new Pig();  a.shout();  // 哼哼

// 父类
public abstract class Animal {
    public abstract void shout();
}
 
// 子类
public class Dog extends Animal {
    @Override
    public void shout() {
        System.out.println("汪汪汪！");
    }
}
 
public class Cat extends Animal {
    @Override
    public void shout() {
        System.out.println("喵喵喵！");
    }
}
 
// 多态使用
public class Test {
    public static void main(String[] args) {
        // 向上转型：父类引用指向子类对象
        Animal dog = new Dog();
        Animal cat = new Cat();
        
        // 同一个方法调用，不同的执行结果
        dog.shout();  // 汪汪汪！
        cat.shout();  // 喵喵喵！
        
        // 作为参数传递
        animalShout(new Dog());  // 汪汪汪！
        animalShout(new Cat());  // 喵喵喵！
    }
    
    // 多态的应用：参数类型使用父类
    public static void animalShout(Animal animal) {
        animal.shout();
    }
}

Animal animal = new Dog();  // 向上转型（自动）
 
// 向下转型（需要强转，可能抛出 ClassCastException）
if (animal instanceof Dog) {
    Dog dog = (Dog) animal;  // 安全转型
    dog.shout();
}

Animal animal = new Dog();
 
System.out.println(animal instanceof Dog);     // true
System.out.println(animal instanceof Animal);  // true
System.out.println(animal instanceof Cat);     // false
 
// Java 14+ 模式匹配
if (animal instanceof Dog dog) {
    dog.shout();  // 自动转型
}

public class Parent {
    public String name = "父类";
    public void show() {
        System.out.println("父类方法");
    }
}
 
public class Child extends Parent {
    public String name = "子类";  // 隐藏父类属性
    
    @Override
    public void show() {
        System.out.println("子类方法");
    }
}
 
public class Test {
    public static void main(String[] args) {
        Parent p = new Child();
        System.out.println(p.name);  // "父类" - 变量看编译类型
        p.show();                    // "子类方法" - 方法看运行类型
    }
}

Parent p = new Child();
p.staticMethod();  // 调用 Parent 的静态方法（看编译类型）

┌─────────────────────────────────────────────────────┐
│                   面向对象三大特性                    │
├─────────────────────────────────────────────────────┤
│                                                     │
│   ┌──────────┐          ┌──────────┐               │
│   │   封装   │ ───────→ │   继承   │               │
│   │ (安全性) │   基础    │  (复用性) │               │
│   └──────────┘          └────┬─────┘               │
│                              │                      │
│                              ↓                      │
│                       ┌──────────┐                 │
│                       │   多态   │                 │
│                       │ (扩展性) │                 │
│                       └──────────┘                 │
│                                                     │
│  封装 → 继承 → 多态：层层递进，相辅相成              │
└─────────────────────────────────────────────────────┘

public class A {
    public String name = "A";
    public void print() { System.out.println("A"); }
}
 
public class B extends A {
    public String name = "B";
    @Override
    public void print() { System.out.println("B"); }
}
 
public class Test {
    public static void main(String[] args) {
        A a = new B();
        System.out.println(a.name);
        a.print();
    }
}

A    // 成员变量不具备多态性，看编译类型
B    // 方法具有多态性，看运行类型

// 方法1：使用 final 修饰类
public final class CannotBeExtended {
    // ...
}
 
// 方法2：私有化构造器 + 静态工厂（可以防止继承，但不能实例化）
public class CannotBeExtended {
    private CannotBeExtended() {}
    
    public static CannotBeExtended create() {
        return new CannotBeExtended();
    }
}

// 抽象类
public abstract class Animal {
    protected String name;
    
    // 具体方法（有实现）
    public void sleep() {
        System.out.println(name + " 正在睡觉");
    }
    
    // 抽象方法（无实现，子类必须重写）
    public abstract void makeSound();
    
    // 构造方法（供子类调用）
    public Animal(String name) {
        this.name = name;
    }
}
 
// 子类必须实现所有抽象方法
public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + " 汪汪叫");
    }
}

// 抽象方法：只有声明，没有实现
public abstract void draw();
 
// 规则：
// 1. 抽象方法必须在抽象类中
// 2. 抽象方法不能是 private（子类无法重写）
// 3. 抽象方法不能是 static（属于实例）
// 4. 抽象方法不能是 final（需要被重写）

// 接口定义
public interface Flyable {
    // 常量（默认 public static final）
    int MAX_HEIGHT = 10000;
    
    // 抽象方法（默认 public abstract）
    void fly();
}
 
// 实现接口
public class Bird implements Flyable {
    @Override
    public void fly() {
        System.out.println("鸟儿飞翔，最高 " + MAX_HEIGHT + " 米");
    }
}
 
// 多实现
public class Superman implements Flyable, Runnable {
    @Override
    public void fly() {
        System.out.println("超人飞行");
    }
    
    @Override
    public void run() {
        System.out.println("超人奔跑");
    }
}

public interface MyInterface {
    // 抽象方法
    void abstractMethod();
    
    // 默认方法（JDK 8+）：有实现，子类可选择重写
    default void defaultMethod() {
        System.out.println("接口默认方法");
    }
    
    // 静态方法（JDK 8+）：属于接口，只能通过接口名调用
    static void staticMethod() {
        System.out.println("接口静态方法");
    }
}
 
// 使用
public class MyClass implements MyInterface {
    @Override
    public void abstractMethod() {
        System.out.println("实现抽象方法");
    }
    
    // defaultMethod() 可以不重写，直接使用
}
 
// 调用
MyClass obj = new MyClass();
obj.abstractMethod();   // 实现抽象方法
obj.defaultMethod();    // 接口默认方法（可重写）
MyInterface.staticMethod();  // 接口静态方法

public interface MyInterface {
    default void method1() {
        commonLogic();  // 调用私有方法
        System.out.println("方法1");
    }
    
    default void method2() {
        commonLogic();  // 复用私有方法
        System.out.println("方法2");
    }
    
    // 私有方法（JDK 9+）：供默认方法复用
    private void commonLogic() {
        System.out.println("公共逻辑");
    }
    
    // 私有静态方法
    private static void staticCommonLogic() {
        System.out.println("静态公共逻辑");
    }
}

// 抽象类：模板方法模式
public abstract class AbstractProcessor {
    // 模板方法：定义算法骨架
    public final void process() {
        validate();      // 公共逻辑
        doProcess();     // 子类实现
        log();           // 公共逻辑
    }
    
    private void validate() {
        System.out.println("参数校验");
    }
    
    // 抽象方法：子类实现
    protected abstract void doProcess();
    
    private void log() {
        System.out.println("记录日志");
    }
}

// 接口：能力/行为定义
public interface Flyable { void fly(); }
public interface Swimmable { void swim(); }
public interface Runnable { void run(); }
 
// 一个类可以有多种能力
public class Duck implements Flyable, Swimmable, Runnable {
    @Override
    public void fly() { System.out.println("鸭子飞"); }
    
    @Override
    public void swim() { System.out.println("鸭子游泳"); }
    
    @Override
    public void run() { System.out.println("鸭子跑"); }
}

public interface A {
    void methodA();
}
 
public interface B {
    void methodB();
}
 
// 接口多继承
public interface C extends A, B {
    void methodC();
}
 
// 实现 C 需要实现所有方法
public class Impl implements C {
    @Override
    public void methodA() { }
    
    @Override
    public void methodB() { }
    
    @Override
    public void methodC() { }
}

public interface A {
    default void show() {
        System.out.println("A");
    }
}
 
public interface B {
    default void show() {
        System.out.println("B");
    }
}
 
// 解决方案1：必须重写
public class C implements A, B {
    @Override
    public void show() {
        A.super.show();  // 调用 A 的默认方法
        // 或 B.super.show();
        // 或自己实现
    }
}
 
// 解决方案2：继承优先于接口
public class D extends BaseClass implements A {
    // 如果 BaseClass 有 show()，则优先使用
    // 如果没有，则使用 A 的默认方法
}

// 合法：抽象类没有抽象方法
public abstract class MyClass {
    public void normalMethod() {
        System.out.println("普通方法");
    }
}

public abstract class Test {
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

// 一个类可以同时拥有多种能力
public class Superman implements Flyable, Swimmable, Runnable {
    // 同时实现多个接口
}