（八）Java面向对象编程三大特性：封装、继承与多态性详解

一、面向对象编程概述

面向对象编程(Object-Oriented Programming, OOP)是一种基于"对象"概念的编程范式，它使用对象来设计应用程序和计算机程序。对象是数据字段(通常称为属性)和方法的集合，可以模拟现实世界中的实体。

面向对象编程有三大基本特性：

1. 封装(Encapsulation)：将数据和操作数据的方法绑定在一起，隐藏内部实现细节

2. 继承(Inheritance)：建立类之间的层次关系，实现代码复用

3. 多态(Polymorphism)：同一操作作用于不同对象，可以有不同的解释和执行结果

Java作为一门纯粹的面向对象编程语言，完全支持这三大特性。下面我们将分别深入探讨这三大特性在Java中的实现和应用。

二、封装(Encapsulation)

2.1 封装的概念与意义

封装是面向对象编程最基础的特性，它指的是将对象的状态(属性)和行为(方法)捆绑在一起，并对外部隐藏对象内部的具体实现细节。封装的主要目的是：

1. 隐藏实现细节：外部无需知道对象内部如何工作，只需知道如何使用

2. 提高安全性：防止外部代码直接访问和修改对象内部数据

3. 增强可维护性：内部实现可以自由改变而不影响外部代码

4. 简化使用：提供清晰的接口，降低使用复杂度

2.2 Java中的封装实现

在Java中，封装主要通过访问修饰符(private, protected, public)和getter/setter方法来实现。

访问修饰符

Java提供了四种访问级别：

1. private：仅在当前类中可见

2. default(默认，不写修饰符)：同一包内可见

3. protected：同一包内及子类可见

4. public：所有类可见

良好的封装实践通常将属性设为private，通过public的方法来访问和修改这些属性。

Getter和Setter方法

Getter(获取器)和Setter(设置器)方法是访问和修改私有属性的标准方式。它们提供了对属性的受控访问，可以在方法中添加额外的逻辑，如参数验证、计算等。

java

public class Person {private String name;private int age;// Getter方法public String getName() {return name;}// Setter方法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) {if (age < 0 || age > 150) {throw new IllegalArgumentException("年龄不合法");}this.age = age;}
}

2.3 封装的优点

1. 灵活性：可以自由改变内部实现而不影响外部代码

2. 可维护性：修改和调试更加容易，因为变化被限制在类内部

3. 安全性：防止非法或不合理的值被赋予属性

4. 易于使用：使用者只需知道方法的作用，无需了解实现细节

2.4 封装的实际应用示例

考虑一个银行账户类，如果不使用封装：

java

public class BankAccount {public double balance;  // 余额直接公开
}

这样任何代码都可以直接修改balance，可能导致非法操作：

java

BankAccount account = new BankAccount();
account.balance = -1000;  // 非法操作，但无法阻止

使用封装改进后：

java

public class BankAccount {private double balance;public double getBalance() {return balance;}public void deposit(double amount) {if (amount <= 0) {throw new IllegalArgumentException("存款金额必须大于0");}balance += amount;}public void withdraw(double amount) {if (amount <= 0) {throw new IllegalArgumentException("取款金额必须大于0");}if (amount > balance) {throw new IllegalArgumentException("余额不足");}balance -= amount;}
}

这样既保证了数据的安全性，又提供了合理的操作接口。

三、继承(Inheritance)

3.1 继承的概念与意义

继承是面向对象编程中实现代码重用和建立类之间关系的重要机制。通过继承，可以基于现有类创建新类，新类继承了现有类的属性和方法，并可以添加新的属性和方法或修改继承来的方法。

继承的主要优点：

1. 代码复用：子类可以直接使用父类的非私有成员

2. 层次分类：可以建立清晰的类层次结构

3. 扩展性：可以在不修改父类的情况下扩展功能

3.2 Java中的继承实现

在Java中，继承通过extends关键字实现。Java只支持单继承，即一个类只能直接继承一个父类。

基本语法

java

class ParentClass {// 父类成员
}class ChildClass extends ParentClass {// 子类特有成员
}

继承示例

java

// 父类
public class Animal {private String name;public Animal(String name) {this.name = name;}public void eat() {System.out.println(name + "正在吃东西");}public void sleep() {System.out.println(name + "正在睡觉");}
}// 子类
public class Dog extends Animal {public Dog(String name) {super(name);  // 调用父类构造方法}// 子类特有方法public void bark() {System.out.println(getName() + "汪汪叫");}// 方法重写@Overridepublic void eat() {System.out.println(getName() + "正在啃骨头");}
}

3.3 方法重写(Override)

子类可以重新定义从父类继承的方法，这称为方法重写。重写的方法必须：

1. 方法名相同

2. 参数列表相同

3. 返回类型相同或是其子类

4. 访问修饰符不能比父类更严格

5. 不能抛出比父类方法更多的异常

使用@Override注解可以明确表示这是重写的方法，编译器会检查是否符合重写规则。

3.4 super关键字

super关键字用于引用父类的成员：

1. super()：调用父类构造方法，必须在子类构造方法的第一行

2. super.method()：调用父类被重写的方法

3. super.field：访问父类的字段(不常用)

3.5 继承中的构造方法

在继承关系中，创建子类对象时：

1. 子类构造方法必须调用父类构造方法(显式或隐式)

2. 如果没有显式调用，编译器会自动插入super()

3. 如果父类没有无参构造方法，子类必须显式调用父类的有参构造方法

java

public class Parent {private int value;public Parent(int value) {this.value = value;}
}public class Child extends Parent {public Child() {super(0);  // 必须显式调用，因为父类没有无参构造方法}public Child(int value) {super(value);  // 调用父类有参构造方法}
}

3.6 继承的限制

1. 单继承限制：Java类只能直接继承一个父类

2. final类：被声明为final的类不能被继承

3. private成员：子类不能直接访问父类的private成员

4. 构造方法：构造方法不能被继承

3.7 继承与组合的选择

继承表示"is-a"关系，组合表示"has-a"关系。在以下情况下应优先考虑组合而非继承：

1. 只是想复用代码，没有真正的"is-a"关系

2. 需要从多个类继承行为(Java不支持多继承)

3. 父类的改变可能会破坏子类功能

java

// 使用继承
class Engine {void start() { /*...*/ }
}class Car extends Engine {  // 不合理的继承，汽车不是发动机
}// 使用组合
class Car {private Engine engine;void start() {engine.start();}
}

四、多态性(Polymorphism)

4.1 多态的概念与意义

多态是指同一操作作用于不同的对象，可以有不同的解释和执行结果。在Java中，多态主要体现在两个方面：

1. 编译时多态(静态多态)：方法重载(Overload)

2. 运行时多态(动态多态)：方法重写(Override)结合向上转型

多态的主要优点：

1. 可替换性：子类对象可以替换父类对象

2. 可扩展性：可以轻松添加新类到系统中

3. 接口性：通过父类/接口定义通用接口

4. 灵活性：编写更通用、更灵活的代码

4.2 方法重载(Overload)

方法重载是指在同一个类中定义多个同名方法，但这些方法的参数列表不同(参数类型、个数或顺序不同)。返回类型可以相同也可以不同。

java

public class Calculator {public int add(int a, int b) {return a + b;}public double add(double a, double b) {return a + b;}public int add(int a, int b, int c) {return a + b + c;}
}

4.3 向上转型与向下转型

向上转型(Upcasting)

将子类对象赋值给父类引用，这是自动进行的，总是安全的。

java

Animal animal = new Dog("Buddy");  // 向上转型

向下转型(Downcasting)

将父类引用转换为子类引用，需要显式进行，且可能抛出ClassCastException。

java

Animal animal = new Dog("Buddy");
Dog dog = (Dog) animal;  // 向下转型

使用instanceof操作符可以避免ClassCastException：

java

if (animal instanceof Dog) {Dog dog = (Dog) animal;
}

4.4 运行时多态的实现

运行时多态通过方法重写和向上转型实现。JVM在运行时根据对象的实际类型决定调用哪个方法。

java

class Animal {void makeSound() {System.out.println("动物发出声音");}
}class Dog extends Animal {@Overridevoid makeSound() {System.out.println("汪汪汪");}
}class Cat extends Animal {@Overridevoid makeSound() {System.out.println("喵喵喵");}
}public class TestPolymorphism {public static void main(String[] args) {Animal animal1 = new Dog();Animal animal2 = new Cat();animal1.makeSound();  // 输出"汪汪汪"animal2.makeSound();  // 输出"喵喵喵"}
}

4.5 多态的应用场景

1. 通用程序设计：编写处理父类对象的代码，实际可以处理所有子类对象

2. 框架设计：框架定义接口，具体实现由使用者提供

3. 回调机制：通过接口实现回调

4. 策略模式：运行时选择算法

4.6 多态的实现机制

Java通过方法表(method table)实现多态。每个类都有一个方法表，包含该类所有可被调用的方法的实际入口地址。当通过父类引用调用方法时：

1. 获取对象的实际类型

2. 查找该类型的方法表

3. 找到对应方法的入口地址

4. 调用方法

4.7 多态的限制

1. 字段没有多态：字段访问由引用类型决定，而不是实际对象类型

2. 静态方法没有多态：静态方法调用由编译时类型决定

3. 私有方法不能被重写：私有方法隐式是final的

4. 构造方法不能被重写：构造方法不是多态的

java

class Parent {public String field = "Parent Field";public void printField() {System.out.println(field);}
}class Child extends Parent {public String field = "Child Field";@Overridepublic void printField() {System.out.println(field);}
}public class Test {public static void main(String[] args) {Parent obj = new Child();System.out.println(obj.field);      // 输出"Parent Field"(字段无多态)obj.printField();                  // 输出"Child Field"(方法有多态)}
}

五、三大特性的综合应用

5.1 设计模式中的三大特性

面向对象三大特性是设计模式的基础。例如：

1. 策略模式：利用多态在运行时选择算法

2. 装饰器模式：通过继承和组合动态添加职责

3. 工厂模式：利用多态创建对象，隐藏具体实现

5.2 实际项目案例

考虑一个图形绘制系统的设计：

java

// 封装：隐藏图形内部实现细节
public abstract class Shape {private String color;public Shape(String color) {this.color = color;}// 封装color的访问public String getColor() {return color;}public void setColor(String color) {this.color = color;}// 抽象方法，子类必须实现public abstract double area();public abstract double perimeter();@Overridepublic String toString() {return "Shape[color=" + color + "]";}
}// 继承：建立图形层次结构
public class Circle extends Shape {private double radius;public Circle(String color, double radius) {super(color);this.radius = radius;}@Overridepublic double area() {return Math.PI * radius * radius;}@Overridepublic double perimeter() {return 2 * Math.PI * radius;}@Overridepublic String toString() {return "Circle[" + super.toString() + ",radius=" + radius + "]";}
}public class Rectangle extends Shape {private double length;private double width;public Rectangle(String color, double length, double width) {super(color);this.length = length;this.width = width;}@Overridepublic double area() {return length * width;}@Overridepublic double perimeter() {return 2 * (length + width);}@Overridepublic String toString() {return "Rectangle[" + super.toString() + ",length=" + length + ",width=" + width + "]";}
}// 多态：统一处理不同图形
public class ShapeTest {public static void printShapeInfo(Shape shape) {System.out.println(shape);System.out.println("面积: " + shape.area());System.out.println("周长: " + shape.perimeter());System.out.println();}public static void main(String[] args) {Shape[] shapes = new Shape[] {new Circle("红色", 5.0),new Rectangle("蓝色", 4.0, 6.0)};for (Shape shape : shapes) {printShapeInfo(shape);}}
}

5.3 面向对象设计原则

1. 单一职责原则(SRP)：一个类只负责一个功能领域

2. 开放-封闭原则(OCP)：对扩展开放，对修改封闭

3. 里氏替换原则(LSP)：子类必须能够替换父类

4. 依赖倒置原则(DIP)：依赖抽象而非具体实现

5. 接口隔离原则(ISP)：使用多个专门接口比使用单一总接口好

6. 合成复用原则(CARP)：优先使用组合而非继承

六、高级话题与常见问题

6.1 抽象类与接口

抽象类

1. 用abstract修饰，可以包含抽象方法和具体方法

2. 不能实例化，必须被子类继承

3. 子类必须实现所有抽象方法，除非子类也是抽象类

java

public abstract class Animal {private String name;public Animal(String name) {this.name = name;}public String getName() {return name;}// 抽象方法，无实现public abstract void makeSound();// 具体方法public void sleep() {System.out.println(name + "正在睡觉");}
}

接口

1. Java 8之前：完全抽象，只能有抽象方法和常量

2. Java 8开始：可以有默认方法和静态方法

3. Java 9开始：可以有私有方法

4. 类通过implements实现接口，可以实现多个接口

java

public interface Drawable {// 常量String DEFAULT_COLOR = "black";// 抽象方法void draw();// 默认方法default void setColor(String color) {System.out.println("设置颜色为" + color);}// 静态方法static void printInfo() {System.out.println("这是一个可绘制接口");}
}

抽象类与接口的选择

1. 当需要定义是什么(is-a)关系时使用抽象类

2. 当需要定义能做什么(can-do)关系时使用接口

3. 优先考虑接口，因为Java不支持多继承但支持多接口实现

6.2 final关键字

1. final类：不能被继承

2. final方法：不能被子类重写

3. final变量：只能赋值一次，成为常量

java

public final class Constants {public static final double PI = 3.14159;private Constants() {}  // 防止实例化
}class Parent {public final void finalMethod() {System.out.println("不能重写此方法");}
}

6.3 对象构造与初始化顺序

创建对象时的初始化顺序：

1. 父类静态代码块和静态变量初始化

2. 子类静态代码块和静态变量初始化

3. 父类实例变量初始化和代码块

4. 父类构造方法

5. 子类实例变量初始化和代码块

6. 子类构造方法

java

class Parent {static {System.out.println("父类静态代码块");}{System.out.println("父类实例代码块");}public Parent() {System.out.println("父类构造方法");}
}class Child extends Parent {static {System.out.println("子类静态代码块");}{System.out.println("子类实例代码块");}public Child() {System.out.println("子类构造方法");}
}public class TestInitialization {public static void main(String[] args) {new Child();}
}

输出顺序：

父类静态代码块
子类静态代码块
父类实例代码块
父类构造方法
子类实例代码块
子类构造方法

6.4 常见面试问题

1. 封装的好处是什么？如何实现封装？

   • 好处：安全性、灵活性、易于维护

   • 实现：private字段 + public方法

2. 继承的优缺点是什么？

   • 优点：代码复用、层次分类

   • 缺点：破坏封装、增加耦合、不灵活

3. 多态的实现机制是什么？

   • 方法重写 + 向上转型 + 动态绑定

4. 抽象类和接口的区别？

   • 抽象类：是什么，单继承，可以有实现

   • 接口：能做什么，多实现，Java 8+可以有默认实现

5. 为什么Java不支持多继承？

   • 避免"菱形继承"问题，简化设计

七、总结

Java面向对象编程的三大特性——封装、继承和多态，是Java语言的核心基础。理解并熟练运用这三大特性，是成为合格Java开发者的必备条件。

1. 封装是基础，它通过隐藏实现细节和提供受控访问来提高代码的安全性和可维护性。

2. 继承建立了类之间的层次关系，实现了代码复用，但也需要注意避免过度使用继承导致的耦合问题。

3. 多态则提供了灵活性，使得程序可以编写更通用的代码，适应未来的扩展需求。

在实际开发中，我们应该：

1. 优先使用组合而非继承

2. 面向接口编程而非实现

3. 遵循SOLID原则

4. 合理使用设计模式

掌握这些面向对象的核心概念，不仅能够编写出更优雅、更易维护的Java代码，也能够更好地理解和应用各种设计模式和框架。面向对象编程是一种思维方式，需要通过不断的实践和反思来真正掌握其精髓。