目录

一、封装（Encapsulation）：数据安全的 “保护盾”

【1】为什么需要封装？

【2】封装的实现步骤

【3】代码

【4】封装的核心价值

二、继承（Inheritance）：代码复用的 “快捷键”

【1】为什么需要继承？

【2】继承的实现规则

【3】代码

【4】继承的核心价值

三、多态（Polymorphism）：灵活扩展的 “魔术手”

【1】为什么需要多态？

【2】多态的实现条件

【3】代码

【4】多态的核心价值

四、三大思想的关联：从 “安全” 到 “复用” 再到 “灵活”

---

一、封装（Encapsulation）：数据安全的 “保护盾”

        封装的核心是 “隐藏细节，暴露接口”，就像给对象穿上 “保护壳”—— 将内部的属性和复杂逻辑隐藏起来，只通过预先定义的公共方法与外部交互，避免外部直接操作导致数据混乱。

【1】为什么需要封装？

        举个简单例子：如果一个User类的age属性直接用public修饰，外部代码可以随意赋值 user.age = -20，这显然不符合 “年龄为正” 的业务逻辑。而封装能从根源上避免这种问题。

【2】封装的实现步骤

1.私有化属性：用private修饰类的成员变量，禁止外部直接访问

2.提供公共接口：定义get、set方法，在方法中加入逻辑校验

3.隐藏内部方法：仅将对外必要的方法用public修饰，内部辅助方法用private隐藏

【3】代码

public class User {
    // 1. 私有化属性，外部无法直接访问
    private String name;
    private int age;

    // 2. 提供公共getter/setter，加入逻辑校验
    public String getName() {
        return name;
    }

    public void setName(String name) {
        // 校验：姓名不能为空
        if (name == null || name.trim().isEmpty()) {
            throw new IllegalArgumentException("姓名不能为空");
        }
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        // 校验：年龄需在0-150之间
        if (age < 0 || age > 150) {
            throw new IllegalArgumentException("年龄必须在0-150之间");
        }
        this.age = age;
    }

    // 3. 内部辅助方法，外部不可见
    private void logUserInfo() {
        System.out.println("用户：" + name + "，年龄：" + age);
    }
}

【4】封装的核心价值

1.数据安全：通过校验逻辑确保属性值符合业务规则；

2.低耦合：外部只需关注 “怎么用”，无需关心 “内部怎么实现”，后续修改内部逻辑不影响外部调用；

3.代码可维护：属性的操作统一收口到 get/set方法，便于统一管理。

---

二、继承（Inheritance）：代码复用的 “快捷键”

        继承是指一个类（子类 / 派生类）可以继承另一个类（父类 / 基类）的属性和方法，同时可以新增自己的属性或重写父类的方法。它的核心是 “复用已有代码，减少重复开发”。

【1】为什么需要继承？

        假设我们需要定义 Student和 Teacher两个类，它们都有 name、age属性和 showInfo() 方法 —— 如果分别写两个类，会出现大量重复代码。而通过继承，我们可以先定义一个公共父类 Person，再让 Student和 Teacher继承 Person，直接复用父类的代码。

【2】继承的实现规则

• 用 extends 关键字表示继承，格式：子类 extends 父类；
• Java 只支持单继承（一个子类只能有一个直接父类），避免多继承的逻辑冲突；
• 父类的private成员（属性 / 方法）子类无法直接访问，但可以通过父类的public方法间接访问；
• 父类的 protected成员允许子类访问（即使不在同一个包），public成员允许所有类访问。

【3】代码

// 父类：公共的Person类
public class Person {
    protected String name; // 子类可访问
    protected int age;

    // 父类的构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 父类的方法
    public void showInfo() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

// 子类：Student继承自Person
public class Student extends Person {
    // 子类新增的属性
    private String studentId;

    // 子类的构造方法：必须先通过super()调用父类构造
    public Student(String name, int age, String studentId) {
        super(name, age); // 调用父类的构造方法，初始化name和age
        this.studentId = studentId;
    }

    // 子类新增的方法
    public void study() {
        System.out.println(studentId + "号学生" + name + "正在学习");
    }

    // （可选）重写父类的showInfo方法，扩展功能
    @Override
    public void showInfo() {
        super.showInfo(); // 调用父类的showInfo，复用已有逻辑
        System.out.println("学号：" + studentId);
    }
}

【4】继承的核心价值

• 代码复用：父类的通用属性和方法无需在子类中重复编写；
• 体系化设计：通过继承构建类的层级关系（如 Person→ Student/Teacher），让代码结构更清晰；
• 便于扩展：子类可以在父类基础上新增功能，不影响父类的原有逻辑。

---

三、多态（Polymorphism）：灵活扩展的 “魔术手”

        多态是指 “同一行为，不同表现”—— 子类对象可以赋值给父类引用，调用方法时会根据对象的实际类型执行对应的子类实现，而不是父类的实现。它是 Java 实现 “开闭原则”（对扩展开放，对修改关闭）的关键。

【1】为什么需要多态？

        假设我们需要开发一个 “课程管理系统”，有 MathCourse（数学）、EnglishCourse（英语）两种课程，都需要实现 “上课” 功能。如果不用多态，每次新增课程（如 ChineseCourse）都要修改调用逻辑；而用多态，新增课程时无需修改原有代码，直接扩展即可。

【2】多态的实现条件

1.存在继承关系：子类继承父类（或实现接口）；

2.子类重写父类方法：子类对父类的方法进行自定义实现；

3.父类引用指向子类对象：通过父类类型的变量调用子类的方法。

【3】代码

// 父类（接口也可，此处用抽象类更直观）
public abstract class Course {
    // 抽象方法：子类必须重写
    public abstract void startClass();
}

// 子类1：数学课程
public class MathCourse extends Course {
    @Override
    public void startClass() {
        System.out.println("数学课：开始讲解微积分");
    }
}

// 子类2：英语课程
public class EnglishCourse extends Course {
    @Override
    public void startClass() {
        System.out.println("英语课：开始练习口语对话");
    }
}

// 测试类：多态的核心体现
public class CourseTest {
    public static void main(String[] args) {
        // 父类引用指向子类对象（关键）
        Course math = new MathCourse();
        Course english = new EnglishCourse();

        // 同一调用方式，不同表现
        startCourse(math);    // 输出：数学课：开始讲解微积分
        startCourse(english); // 输出：英语课：开始练习口语对话

        // 新增课程（如语文课）：无需修改startCourse方法
        Course chinese = new ChineseCourse();
        startCourse(chinese); // 直接扩展，符合开闭原则
    }

    // 通用方法：只依赖父类，不关心具体子类
    public static void startCourse(Course course) {
        course.startClass(); // 调用的是子类的实现
    }
}

// 新增子类：语文课（无需修改原有代码）
class ChineseCourse extends Course {
    @Override
    public void startClass() {
        System.out.println("语文课：开始分析古文");
    }
}

【4】多态的核心价值

• 代码灵活：调用方只需面向父类编程，无需关心具体子类，降低代码耦合；

• 易于扩展：新增子类时，原有调用逻辑无需修改，符合 “开闭原则”；

• 简化逻辑：避免大量 if-else 判断（如不用多态需判断 “是数学 / 英语 / 语文课” 再执行对应逻辑）。

---

四、三大思想的关联：从 “安全” 到 “复用” 再到 “灵活”

封装、继承、多态并非孤立存在，而是相互支撑、层层递进的关系：

1.封装是基础：先通过封装保证数据安全和细节隐藏，才能让后续的继承和多态有可靠的 “基础组件”；

2.继承是桥梁：通过继承复用封装好的父类代码，同时为多态提供 “父类 - 子类” 的层级关系；

3.多态是目标：在封装和继承的基础上，通过多态实现代码的灵活扩展，最终达到 “高内聚、低耦合” 的设计目标。

---

        感谢你花时间读到这里～ 如果你觉得这篇内容对你有帮助，不妨点个赞让更多人看到；如果有任何想法、疑问，或者想分享你的相关经历，欢迎在评论区留言交流，你的每一条互动对我来说都很珍贵～ 我们下次再见啦！😊😊