三者之间的关系：

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

一、封装（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 + "在汪汪叫");}// 子类可以重写父类的方法@Overridepublic 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;@Overridepublic double getArea() {return Math.PI * radius * radius;}
}class Rectangle implements Shape {private double width;private double height;@Overridepublic 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 {@Overridepublic void pay(double amount) {System.out.println("信用卡支付: " + amount);}
}class WeChatPayment implements PaymentStrategy {@Overridepublic void pay(double amount) {System.out.println("微信支付: " + amount);}
}// 2. Spring框架中的多态
interface UserDao {void save();
}@Repository  // 多个实现类，Spring通过多态特性注入
class MysqlUserDao implements UserDao {@Overridepublic void save() {System.out.println("保存到MySQL");}
}