面向对象编程的四大特性详解：封装、继承、多态与抽象

🎯 面向对象编程的四大特性（OOP 特性）

🧩 一、封装（Encapsulation）

✅ 概念

将数据（属性）和操作这些数据的方法（行为）绑定在一起，并对外隐藏内部实现细节，只暴露必要接口，形成一个独立的对象 (类的实例)。

🎯 现实类比

• 电饭煲：外部只需要按“煮饭”，不用关心内部如何加热、控温。
• Java 中：通过 private 修饰属性，public 提供访问方法（getter/setter）

📦 Java 示例

public class Person {
    private String name;  // 封装属性
    private int age;

    public String getName() {
        return name;      // 提供外部访问
    }

    public void setName(String name) {
        this.name = name;
    }

	public void setAge(int age) {
        this.age = age;
    }
}

可以看得出，Person 类对外没有提供 age 的 getter 方法，因为 Person 的年龄要保密。
所以，封装是把一个对象的属性私有化，同时提供一些可以被外界访问的方法。

❗ 面试陷阱

• **封装 = 只加 private 吗？**不是。封装 = 数据隐藏 + 提供控制访问的方式。
• **为什么要封装？**保证对象内部状态安全，避免被随意更改。

🧬 二、继承（Inheritance）

✅ 概念

子类继承父类的属性和方法，实现代码复用和体系结构扩展。

同时，子类还可以重写或者扩展从父类继承来的属性和方法，从而实现多态。

🎯 现实类比

• Bird 是 Animal 的一种，继承了动物的行为如“吃、睡”。
• Java 中使用 extends 实现继承。

📦 Java 示例

class Animal {
	protected String name;
    protected int age;
    void eat() {
        System.out.println("动物在吃东西");
    }
}

class Dog extends Animal {
	private String master;
    void bark() {
        System.out.println("狗在叫");
    }
}

Dog 类继承了 Animal 类的属性（name、age）和方法（eat），同时还有自己的属性（master）和方法（bark）。

❗ 面试陷阱

• Java 是单继承语言，一个类只能继承一个类。
• 接口（interface）可以多继承，类可以实现多个接口。

为什么Java里面要多组合少继承？

继承适合描述“is-a”的关系，但继承容易导致类之间的强耦合，一旦父类发生改变，子类也要随之改变，违背了开闭原则（尽量不修改现有代码，而是添加新的代码来实现）。

组合适合描述“has-a”或“can-do”的关系，通过在类中组合其他类，能够更灵活地扩展功能。组合避免了复杂的类继承体系，同时遵循了开闭原则和松耦合的设计原则。

举个例子，假设采用继承，每种形状和样式的组合都会导致类的急剧增加：

// 基类
class Shape {
    public void draw() {
        System.out.println("Drawing a shape");
    }
}

// 圆形
class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

// 带红色的圆形
class RedCircle extends Circle {
    @Override
    public void draw() {
        System.out.println("Drawing a red circle");
    }
}

// 带绿色的圆形
class GreenCircle extends Circle {
    @Override
    public void draw() {
        System.out.println("Drawing a green circle");
    }
}

// 类似的，对于矩形也要创建多个类
class Rectangle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
}

class RedRectangle extends Rectangle {
    @Override
    public void draw() {
        System.out.println("Drawing a red rectangle");
    }
}

组合模式更加灵活，可以将形状和颜色分开，松耦合。

// 形状接口
interface Shape {
    void draw();
}

// 颜色接口
interface Color {
    void applyColor();
}

形状干形状的事情。

// 圆形的实现
class Circle implements Shape {
    private Color color;  // 通过组合的方式持有颜色对象

    public Circle(Color color) {
        this.color = color;
    }

    @Override
    public void draw() {
        System.out.print("Drawing a circle with ");
        color.applyColor();  // 调用颜色的逻辑
    }
}

// 矩形的实现
class Rectangle implements Shape {
    private Color color;

    public Rectangle(Color color) {
        this.color = color;
    }

    @Override
    public void draw() {
        System.out.print("Drawing a rectangle with ");
        color.applyColor();
    }
}

颜色干颜色的事情

// 红色的实现
class RedColor implements Color {
    @Override
    public void applyColor() {
        System.out.println("red color");
    }
}

// 绿色的实现
class GreenColor implements Color {
    @Override
    public void applyColor() {
        System.out.println("green color");
    }
}

🎭 三、多态（Polymorphism）

✅ 概念

同一个行为在不同类的对象上可以产生不同的实现效果。

多态其实是一种能力——同一个行为具有不同的表现形式；换句话说就是，执行一段代码，Java 在运行时能根据对象类型的不同产生不同的结果。

🎯 多态的三个必要前置条件

📦 Java 示例

class Animal {
    void makeSound() {
        System.out.println("动物在叫");
    }
}

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

Animal a = new Dog();
a.makeSound();  // 输出：狗在汪汪叫

❗ 面试陷阱

• **多态的前提？**必须有继承或接口 + 方法重写 + 父类引用指向子类对象。
• 多态不适用于 static、private、构造器方法。

多态的实现原理是什么？

多态通过动态绑定实现，Java 使用虚方法表存储方法指针，方法调用时根据对象实际类型从虚方法表查找具体实现。

🧱 四、抽象（Abstraction）

✅ 概念

抽象是指从一类事物中提取共性特征，隐藏实现细节，仅保留对外功能定义。

🎯 类比理解

• “人会说话”是抽象概念，至于“说中文/说英语”是具体实现。
• Java 中通过 abstract class 或 interface 实现抽象。

📦 Java 示例

abstract class Animal {
    abstract void makeSound();  // 抽象方法
}

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

// 定义一个接口，相当于完全抽象类
interface Animal {
    void makeSound();  // 抽象方法（默认 public abstract）
}

// 实现类必须实现接口中的所有方法
class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("狗在汪汪叫");
    }
}

📊 总结图：面向对象四大特性

✅ 一句话总结记忆法：

OOP 就是封装行为、继承结构、抽象共性、多态运行 —— 让程序像现实世界一样灵活、可维护、易扩展。