今天我们来聊聊 Java 面向对象的三大特性，封装、继承、多态。
一、封装（Encapsulation）
定义：封装是面向对象的基础特性，核心是 将对象的属性（数据）和行为（方法）捆绑在一起，并隐藏内部实现细节，只对外暴露可控的接口。
类比：手机的内部电路（属性）和通话功能（方法）被封装在外壳里，你不需要知道内部原理，只需通过按键 / 屏幕（接口）操作即可。
作用：
- 提高代码安全性：防止外部随意修改对象的核心属性；
- 增强可维护性：内部实现修改时，只要接口不变，外部代码无需调整；
- 降低耦合：外部仅依赖接口，不依赖内部细节。
示例代码：- // 封装的典型实现：属性私有化 + 提供get/set方法public class Person { // 1. 属性私有化（private），隐藏内部数据 private String name; private int age; // 2. 提供公共的getter（读取）/setter（修改）方法，控制访问规则 public String getName() { return name; } public void setName(String name) { // 可以在setter中添加校验逻辑，保证数据合法性 if (name == null || name.trim().isEmpty()) { throw new IllegalArgumentException("姓名不能为空"); } this.name = name; } public int getAge() { return age; } public void setAge(int age) { // 限制年龄范围，避免非法值 if (age < 0 || age > 150) { throw new IllegalArgumentException("年龄必须在0-150之间"); } this.age = age; } // 封装行为：对外暴露的业务方法 public void introduce() { System.out.println("我叫" + name + "，今年" + age + "岁"); }}// 测试public class EncapsulationTest { public static void main(String[] args) { Person person = new Person(); // 通过setter设置属性（会触发校验） person.setName("张三"); person.setAge(25); person.introduce(); // 输出：我叫张三，今年25岁 }}
定义：继承是面向对象的扩展特性，核心是 子类（Subclass）继承父类（Superclass）的属性和方法，实现代码复用，同时子类可以扩展或重写父类的功能。
类比："小狗" 和 "小猫" 都是 "动物"，可以继承 "动物" 的属性（名字）和方法（吃东西、睡觉），再各自扩展特有功能（小狗是 "汪汪叫"，小猫是 "喵喵叫"）。
作用：
- 代码复用：避免重复编写相同的属性和方法；
- 体系化管理：构建类的层级关系；
- 为多态奠定基础。
示例代码：- // 父类：抽象的"动物"public class Animal { // 父类属性 protected String name; // protected：子类可直接访问 // 父类构造方法 public Animal(String name) { this.name = name; } // 父类方法 public void eat() { System.out.println(name + "在吃食物"); } // 父类方法 public void sleep() { System.out.println(name + "在睡觉"); }}// 子类：Dog（继承Animal）public class Dog extends Animal { // 子类特有属性 private String breed; // 品种 // 子类构造方法：必须通过super调用父类构造 public Dog(String name, String breed) { super(name); // 调用父类的构造方法 this.breed = breed; } // 重写（Override）父类方法：扩展/修改父类行为 @Override public void eat() { System.out.println(name + "（" + breed + "）在啃骨头"); } // 子类特有方法：扩展父类功能 public void bark() { System.out.println(name + "在汪汪叫"); }}// 测试public class InheritanceTest { public static void main(String[] args) { Dog dog = new Dog("旺财", "金毛"); // 继承父类的方法 dog.sleep(); // 输出：旺财在睡觉 // 重写后的方法 dog.eat(); // 输出：旺财（金毛）在啃骨头 // 子类特有方法 dog.bark(); // 输出：旺财在汪汪叫 }}
定义：多态是面向对象的核心特性，核心是 同一个行为（方法调用），不同对象表现出不同的形态。
类比：同样是 "吃" 这个行为，狗啃骨头、猫吃鱼、人吃饭，行为的具体实现不同，但对外的调用方式一致。
前提：
- 存在 继承 / 实现 关系（子类继承父类，或类实现接口）；
- 子类重写父类的方法；
- 父类引用指向子类对象（Animal animal = new Dog()）。
作用：
- 提高代码灵活性：无需关注具体子类类型，统一调用父类方法即可；
- 增强可扩展性：新增子类时，无需修改原有调用逻辑；
- 降低代码耦合：调用方仅依赖父类 / 接口，不依赖具体子类。
示例代码：- // 基于上面的Animal和Dog，新增Cat子类public class Cat extends Animal { public Cat(String name) { super(name); } // 重写eat方法 @Override public void eat() { System.out.println(name + "在吃小鱼干"); } // 子类特有方法 public void meow() { System.out.println(name + "在喵喵叫"); }}// 测试public class PolymorphismTest { // 统一的调用方法：接收Animal类型（父类），无需关心具体是Dog还是Cat public static void feedAnimal(Animal animal) { animal.eat(); // 运行时会根据实际对象类型调用对应方法（动态绑定） } public static void main(String[] args) { // 1. 父类引用指向子类对象 Animal animal1 = new Dog("旺财", "金毛"); Animal animal2 = new Cat("咪宝"); // 2. 同一个方法调用，表现不同行为（多态核心） feedAnimal(animal1); // 输出：旺财（金毛）在啃骨头 feedAnimal(animal2); // 输出：咪宝在吃小鱼干 // 3. 多态的局限：父类引用不能直接调用子类特有方法，需强制类型转换 // animal1.bark(); // 编译错误 if (animal1 instanceof Dog) { // 判断对象实际类型 Dog dog = (Dog) animal1; // 强制转换 dog.bark(); // 输出：旺财在汪汪叫 } }}
- 封装不止是属性私有化：类的 私有方法、内部类 也是封装的体现，目的都是隐藏内部逻辑。
- Java 是单继承：一个子类只能继承一个父类，但可以通过 "实现接口" 间接实现多继承效果。
- 多态，对于成员方法，是 "编译看左边，运行看右边"，即编译时检查父类是否有该方法，运行时执行子类重写的方法。而对于成员变量，则是 "编译和运行都看左边"，访问的是父类中的变量。
心定则安，守拙成巧。-- 烟沙九洲
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！ |
提升卡
置顶卡
沉默卡
喧嚣卡
变色卡
千斤顶
照妖镜
