【Java】深入理解封装、继承、多态：从概念到实战
大家好，我是云扬～ 今天继续分享 Java 面向对象的核心知识点 —— 封装、继承、多态。这三大特征是 Java 编程的基石，合理运用能让代码更简洁、灵活、可维护。下面结合具体代码示例，带大家深入理解每个特性的实现与应用场景。
一、引入：面向对象的核心支柱
Java 面向对象三大特征（封装、继承、多态）相辅相成：封装保证数据安全性，继承实现代码复用，多态提升扩展性。掌握这三者的设计思想，能从根本上提升代码质量。
二、封装：数据隐藏与接口暴露
封装是将数据和操作数据的方法封装为独立实体，隐藏内部实现细节，仅通过对外接口交互。
核心实现：私有属性 + 公共访问器
public class User {
// 私有属性：隐藏内部状态
private String username;
private String password;
private int age;
// 构造方法：初始化对象
public User(String username, String password, int age) {
this.username = username;
this.password = password;
this.age = age;
}
// 公共getter方法：安全访问属性
public String getUsername() {
return username;
}
// 公共setter方法：控制属性修改逻辑
public void setAge(int age) {
if (age > 0 && age { // 数据合法性校验
this.age = age;
} else {
throw new IllegalArgumentException("年龄必须在1-150之间");
}
}
// 重写Object类的toString()：自定义对象字符串表示
@Override
public String toString() {
return "User{username='" + username + "', age=" + age + "}";
}
// 重写equals()：基于内容比较对象
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
return age == user.age && Objects.equals(username, user.username);
}
}
封装的四大优势：
- 减少耦合：外部仅通过接口交互，内部修改不影响外部使用
- 自由修改内部结构：如密码加密逻辑可在 setPassword () 中修改
- 精确控制成员访问：如年龄设置的合法性校验
- 隐藏敏感信息：密码等私有属性无法直接访问
三、继承：代码复用的 “家族树”
继承允许子类继承父类的属性和方法，子类可扩展新功能或重写父类方法。
1. 单继承实现（extends 关键字）
// 父类：抽象共性特征
public class Animal {
protected String name;
protected int age;
// 父类构造方法
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
// 父类普通方法
public void eat() {
System.out.println(name + "正在进食");
}
}
// 子类：继承父类并扩展
public class Dog extends Animal {
// 子类特有属性
private String breed;
// 子类构造方法：必须先调用父类构造
public Dog(String name, int age, String breed) {
super(name, age); // 调用父类有参构造
this.breed = breed;
}
// 重写父类方法：@Override注解校验重写正确性
@Override
public void eat() {
System.out.println(name + "（" + breed + "）正在吃狗粮");
}
// 子类特有方法
public void bark() {
System.out.println(name + "汪汪叫");
}
}
2. 多继承效果实现（接口 implements）
Java 类不支持多继承，但可通过实现多个接口间接实现：
// 定义多个接口
interface Flyable {
void fly();
}
interface Runnable {
void run();
}
// 类实现多个接口，需重写所有抽象方法
public class Bird extends Animal implements Flyable, Runnable {
public Bird(String name, int age) {
super(name, age);
}
@Override
public void fly() {
System.out.println(name + "展翅高飞");
}
@Override
public void run() {
System.out.println(name + "地面奔跑");
}
}
3. 关键特性对比
| 特性 | 代码示例 |
|---|---|
| 方法重写（Override） | 子类 Dog 重写父类 Animal 的 eat () 方法，方法名、参数、返回值完全一致 |
| 方法重载（Overload） | 同一类中同名不同参： add (int a, int b) ，add(double a, double b) |
| this 与 super | this 访问本类成员：this.name super 访问父类成员：super.eat () |
4. 继承初始化顺序
class Parent {
static { System.out.println("1.父类静态代码块"); }
{ System.out.println("3.父类普通代码块"); }
public Parent() { System.out.println("4.父类构造方法"); }
}
class Child extends Parent {
static { System.out.println("2.子类静态代码块"); }
{ System.out.println("5.子类普通代码块"); }
public Child() { System.out.println("6.子类构造方法"); }
}
// 执行结果：1→2→3→4→5→6
public class InitOrderTest {
public static void main(String[] args) {
new Child();
}
}
核心规则：静态优先（父→子）→ 普通代码块（父→子）→ 构造方法（父→子）
四、多态：同一行为的不同表现
多态是指同一方法调用，因对象类型不同产生不同执行结果，核心是动态绑定。
多态的三个必要条件：
- 子类继承父类
- 子类重写父类方法
- 父类引用指向子类对象
代码实现：
// 父类
public abstract class Shape {
public abstract void draw(); // 抽象方法：定义规范
}
// 子类1
public class Circle extends Shape {
@Override
public void draw() {
System.out.println("绘制圆形");
}
}
// 子类2
public class Rectangle extends Shape {
@Override
public void draw() {
System.out.println("绘制矩形");
}
}
// 多态测试
public class PolymorphismTest {
public static void main(String[] args) {
Shape shape1 = new Circle(); // 向上转型：父类引用指向子类对象
Shape shape2 = new Rectangle();
shape1.draw(); // 输出：绘制圆形（执行子类实现）
shape2.draw(); // 输出：绘制矩形（执行子类实现）
// 向下转型：需先判断类型
if (shape1 instanceof Circle) {
Circle circle = (Circle) shape1;
// 调用子类特有方法
}
}
}
多态的优势：
- 扩展性强：新增三角形（Triangle）类无需修改原有代码
- 降低耦合：调用方仅依赖父类接口，不关心具体实现
- 代码简洁：统一调用方式，减少重复代码
五、修饰符与三大特征的关系
| 修饰符 | 作用场景 |
|---|---|
| final | 1. 修饰类：不能被继承（如 String 类） 2. 修饰方法：不能被重写 3. 修饰变量：不可修改 |
| abstract | 1. 修饰类：包含抽象方法，不能实例化 2. 修饰方法：无方法体，子类必须重写 |
| static | 1. 静态属性 / 方法：属于类，无需实例化即可访问 2. 静态代码块：类加载时执行一次 |
| 访问修饰符 | 子类重写方法时，访问权限不能比父类更严格（public > protected > default > private） |
六、小结
- 封装：隐藏细节，暴露接口（如 User 类的属性私有化）
- 继承：子承父业，扩展功能（如 Dog 继承 Animal）
- 多态：一接口多实现，动态绑定（如 Shape 的 draw 方法）
三大特征的核心价值在于：提高代码复用性、降低耦合度、增强扩展性。实际开发中，需结合业务场景灵活运用 —— 封装保证数据安全，继承减少重复代码，多态应对需求变化。
如果觉得本文有帮助，欢迎点赞收藏～ 后续会分享更多 Java 核心技术，咱们下期见！
