封装继承多态是什么，有什么联系

封装、继承、多态是面向对象编程（OOP）的三大核心特性： - 封装：隐藏对象内部细节，通过访问控制（如 private）提供对外接口，保护数据。 - 继承：子类复用父类的属性和方法，实现代码复用和层次关系。 - 多态：同一接口不同实现，对象根据实际类型动态执行行为，提升灵活性。

联系：它们相辅相成，封装保护数据为继承提供基础，继承定义层次为多态提供条件，多态依赖封装和继承实现动态行为。

1. 封装（Encapsulation）

是什么

将对象的属性和行为（方法）绑定在一起，通过访问修饰符（如 private、public）控制外部访问。
目的：隐藏实现细节，提供安全性和简洁接口。

示例

public class Person {
    private String name; // 私有属性
    private int age;

    // 公共接口
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

效果：外部只能通过 setName 修改 name，保护数据。

2. 继承（Inheritance）

是什么

子类通过 extends 继承父类的属性和方法，扩展或重用代码。
目的：实现代码复用，建立类层次关系。

示例

public class Animal {
    protected String species;

    public void eat() {
        System.out.println("Eating...");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println("Woof!");
    }
}

效果：Dog 继承 eat()，新增 bark()。

3. 多态（Polymorphism）

是什么

同一接口或方法，对象根据实际类型表现出不同行为。
类型：
编译时多态：方法重载（Overloading）。
运行时多态：方法重写（Overriding）+ 父类引用。
目的：提高灵活性和扩展性。

示例

public class Animal {
    public void sound() {
        System.out.println("Some sound");
    }
}

public class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("Meow");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal animal = new Cat(); // 父类引用子类对象
        animal.sound(); // 输出 "Meow"（运行时多态）
    }
}

它们之间的联系

封装为继承提供基础：
封装定义私有属性和公共方法，子类通过 protected 或 public 继承。
示例：Animal 的 species 被 Dog 继承。
继承为多态提供条件：
子类重写父类方法，形成多态的前提。
示例：Cat 重写 sound()，实现不同行为。
多态依赖封装和继承：
封装隐藏实现细节，多态通过接口调用。
继承建立类关系，多态动态绑定。
协同作用：
封装保护数据，继承复用代码，多态增强灵活性，共同构建 OOP 体系。

示例（综合）

public class Shape {
    private double area; // 封装

    public void setArea(double area) {
        this.area = area;
    }
    public double getArea() {
        return area;
    }
}

public class Circle extends Shape { // 继承
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
        setArea(Math.PI * radius * radius);
    }
}

public class Test {
    public static void main(String[] args) {
        Shape shape = new Circle(5); // 多态
        System.out.println(shape.getArea()); // 输出 78.54
    }
}

延伸与面试角度

封装优点：
安全性（隐藏细节）、模块化。
继承缺点：
耦合性高，可用组合替代。
多态实现：
Java：接口（interface）、抽象类。
联系应用：
Spring：多态（依赖注入）、封装（Bean）。
面试点：
问“多态类型”时，提重载和重写。
问“联系”时，提层次依赖。

总结

封装隐藏细节，继承复用代码，多态动态执行，三者层层递进，共同实现 OOP 的灵活性和可维护性。面试时，可写综合示例或提设计模式，展示理解深度。