三者之间的关系：

封装是基础，提供了数据的安全性
继承提供了代码的复用性
多态提供了代码的灵活性和扩展性

一、封装（Encapsulation）：

// 封装示例
public class Student {
    // 私有属性（实现封装）
    private String name;
    private int age;
    
    // 提供公共的访问方法（getter和setter）
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        // 可以在这里添加数据验证
        if (name != null && !name.isEmpty()) {
            this.name = name;
        }
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        // 添加年龄验证
        if (age > 0 && age < 150) {
            this.age = age;
        }
    }
}

封装的特点：

隐藏内部实现细节
对属性的访问进行控制
提高代码的安全性
只能通过规定的方法访问数据

二、继承（Inheritance）：

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

// 子类继承父类
public class Dog extends Animal {
    // 子类可以使用父类的属性和方法
    
    // 子类可以有自己的属性和方法
    private String breed;
    
    public void bark() {
        System.out.println(name + "在汪汪叫");
    }
    
    // 子类可以重写父类的方法
    @Override
    public void eat() {
        System.out.println(name + "在吃骨头");
    }
}

继承的特点：

子类可以使用父类的属性和方法
子类可以有自己的属性和方法
子类可以重写父类的方法
Java只支持单继承，但可以实现多个接口

三、多态（Polymorphism）：

1. 多态的三个必要条件：

// 1. 继承或者实现（继承父类或实现接口）
// 2. 重写（重写父类/接口的方法）
// 3. 父类引用指向子类对象（向上转型）

2.多态的具体实现：

简单示例

// 炒菜的接口
interface Cooking {
    void cook();  // 炒菜的方法
}

// 青椒炒肉
class PepperMeat implements Cooking {
    public void cook() {
        System.out.println("炒青椒炒肉");
    }
}

// 番茄炒蛋
class TomatoEgg implements Cooking {
    public void cook() {
        System.out.println("炒番茄炒蛋");
    }
}

// 厨师类
class Chef {
    // 多态体现在这里：接收任何实现了Cooking接口的类
    public void doCook(Cooking dish) {
        dish.cook();  // 具体炒什么菜由传入的对象决定


    }
}

//！！！！ 多态的使用场景：

public class Test {
    public static void main(String[] args) {
        Chef chef = new Chef();
        
        // 来个青椒炒肉
        chef.doCook(new PepperMeat());  // 输出：炒青椒炒肉
        
        // 来个番茄炒蛋
        chef.doCook(new TomatoEgg());   // 输出：炒番茄炒蛋

/**
想象你是餐厅服务员：
顾客说："我要点菜"（调用doCook方法）
顾客说具体要什么菜（传入的dish对象）：

"我要青椒炒肉"（传入PepperMeat对象）
"我要番茄炒蛋"（传入TomatoEgg对象）

你把菜单给厨师（调用cook方法）

*/

    }
}

多态的作用是：

代码更灵活
不需要修改厨师的代码，就能让厨师炒新的菜
调用同一个方法，能得到不同的结果

// 1. 基于继承的实现
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("喵喵喵");
    }
}

// 2. 基于接口的实现
interface Shape {
    double getArea();
}

class Circle implements Shape {
    private double radius;
    
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle implements Shape {
    private double width;
    private double height;
    
    @Override
    public double getArea() {
        return width * height;
    }
}

3.多态的使用场景：

//多态的使用场景：

// 1. 方法参数的多态
public class AnimalService {
    public void makeAnimalSound(Animal animal) {  // 父类引用作为参数
        animal.makeSound();  // 调用的是子类重写的方法
    }
}

// 使用
AnimalService service = new AnimalService();
service.makeAnimalSound(new Dog());  // 输出：汪汪汪
service.makeAnimalSound(new Cat());  // 输出：喵喵喵

// 2. 数组或集合中的多态
Animal[] animals = new Animal[2];
animals[0] = new Dog();  // 向上转型
animals[1] = new Cat();  // 向上转型

for(Animal animal : animals) {
    animal.makeSound();  // 分别输出：汪汪汪、喵喵喵
}

4.多态的好处：

降低耦合度：代码之间的依赖关系变少
提高扩展性：新增子类不需要修改原有代码
同一个方法可以有不同的实现
父类引用可以指向子类对象
接口引用可以指向实现类对象
增加代码的复用性,提高代码的灵活性和扩展性

5.多态的注意事项：

Animal animal = new Dog();
animal.makeSound();  // 正常调用，会调用Dog的方法

// 无法调用子类特有的方法
// animal.fetch();  // 错误！Animal类型的引用无法调用Dog特有的方法

// 如果需要调用子类特有方法，需要向下转型
if(animal instanceof Dog) {
    Dog dog = (Dog)animal;  // 向下转型
    dog.fetch();  // 现在可以调用Dog特有的方法了
}

6.实际应用场景：

// 1. 策略模式
interface PaymentStrategy {
    void pay(double amount);
}

class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("信用卡支付: " + amount);
    }
}

class WeChatPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("微信支付: " + amount);
    }
}

// 2. Spring框架中的多态
interface UserDao {
    void save();
}

@Repository  // 多个实现类，Spring通过多态特性注入
class MysqlUserDao implements UserDao {
    @Override
    public void save() {
        System.out.println("保存到MySQL");
    }
}