Java面向对象编程：继承、多态与接口实战解析

1. 项目概述

这个Java编程练习系列聚焦面向对象编程的核心概念：继承、多态、抽象类和接口。作为SDUT（山东理工大学）的课程作业，它通过11-20题的系统训练，帮助学生掌握Java面向对象的高级特性。我在实际教学中发现，这些概念往往是学生从语法学习转向工程实践的关键门槛。

继承和多态让代码具备纵向扩展能力，抽象类和接口则定义了横向规范。这组题目设计精妙之处在于：前5题（1-10）铺垫基础语法后，11-20题突然提升抽象层级，要求用OOP思想解决实际问题。比如用继承实现不同几何图形的面积计算，通过接口规范支付系统的统一调用方式。

2. 核心概念解析

2.1 继承的本质与实现

继承不只是代码复用工具，更是分类思维的体现。Java中使用extends关键字建立父子类关系时，实际上在做三件事：

1. 属性继承：子类自动获得父类非private字段
2. 方法继承：可重写(override)父类非final方法
3. 类型继承：子类对象可向上转型为父类引用

java复制class Animal {
    void breathe() {
        System.out.println("呼吸氧气");
    }
}

class Fish extends Animal {
    @Override
    void breathe() {
        System.out.println("用鳃呼吸水中的氧气");
    }
}

关键经验：重写方法时坚持@Overrride注解，这能让编译器检查方法签名是否正确。我曾调试2小时才发现拼写错误的案例。

2.2 多态的两种表现形式

多态(polymorphism)在Java中主要通过两种机制实现：

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

java复制class Calculator {
    int add(int a, int b) { return a + b; }
    double add(double a, double b) { return a + b; }
}

2. 运行时多态：方法重写+向上转型

java复制Animal myFish = new Fish();  // 向上转型
myFish.breathe();  // 实际调用Fish类的方法

多态最精妙的应用是在集合中处理异构对象：

java复制List<Animal> zoo = new ArrayList<>();
zoo.add(new Fish());
zoo.add(new Bird());
for(Animal a : zoo) {
    a.breathe();  // 自动调用具体子类实现
}

2.3 抽象类的使用场景

抽象类(abstract class)适合以下情况：

• 需要包含具体方法实现
• 要求子类必须实现特定方法
• 需要定义protected级别的辅助方法

java复制abstract class Graphic {
    abstract double area();  // 强制子类实现
    
    protected void validate() {
        // 公共校验逻辑
    }
}

class Circle extends Graphic {
    private double radius;
    
    @Override
    double area() {
        return Math.PI * radius * radius;
    }
}

设计警示：抽象类可以有构造方法，但不能直接实例化。常见错误是尝试new Graphic()。

2.4 接口的演进历程

从Java 8开始，接口(interface)的能力大幅增强：

现代接口典型用法：

java复制interface Payment {
    void pay(double amount);  // 抽象方法
    
    default void refund() {   // 默认方法
        System.out.println("退款处理中...");
    }
    
    static String currency() { // 静态方法
        return "CNY";
    }
}

3. 题目精讲与实现

3.1 员工薪资系统（题11）

需求：实现Employee抽象类和其子类Manager/Programmer，不同岗位计算薪资方式不同。

java复制abstract class Employee {
    private String name;
    
    public Employee(String name) {
        this.name = name;
    }
    
    abstract double calculateSalary();
}

class Manager extends Employee {
    private double bonus;
    
    public Manager(String name, double bonus) {
        super(name);
        this.bonus = bonus;
    }
    
    @Override
    double calculateSalary() {
        return 15000 + bonus;
    }
}

避坑指南：

1. 抽象类虽然不能实例化，但构造方法必不可少——子类要通过super()调用
2. 字段访问控制：子类需要访问的字段应设为protected而非private

3.2 图形面积计算（题14）

利用接口实现多种图形的面积计算：

java复制interface AreaCalculable {
    double calculateArea();
}

class Circle implements AreaCalculable {
    private double radius;
    
    public Circle(double r) { radius = r; }
    
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

// 测试代码
AreaCalculable[] shapes = {
    new Circle(2.5),
    new Rectangle(3,4)
};
for(AreaCalculable shape : shapes) {
    System.out.println(shape.calculateArea());
}

类型选择诀窍：

• 需要多继承时用接口
• 需要包含公共代码时用抽象类
• 既需要多继承又需要公共代码？Java不允许多继承类，但可以实现多个接口+继承一个类

3.3 支付系统设计（题17）

演示接口多态的实际应用：

java复制interface PaymentMethod {
    void pay(double amount);
}

class Alipay implements PaymentMethod {
    @Override
    public void pay(double amount) {
        System.out.println("支付宝支付：" + amount);
    }
}

class PaymentProcessor {
    public void process(PaymentMethod method, double amount) {
        method.pay(amount);
    }
}

// 使用示例
PaymentProcessor processor = new PaymentProcessor();
processor.process(new Alipay(), 199.9);
processor.process(new WechatPay(), 88.8);

扩展技巧：结合枚举类型管理支付方式

java复制enum PaymentType {
    ALIPAY(new Alipay()),
    WECHAT(new WechatPay());
    
    private PaymentMethod instance;
    
    PaymentType(PaymentMethod pm) {
        this.instance = pm;
    }
    
    public PaymentMethod get() { return instance; }
}

4. 深度对比与工程实践

4.1 抽象类 vs 接口选择矩阵

实战建议：

• 定义行为契约优先选接口
• 需要封装公共状态和逻辑时用抽象类
• Java8之后，接口的default方法已经能替代大部分抽象类的功能

4.2 多态在框架中的应用

以Spring框架的依赖注入为例，其核心机制正是基于接口多态：

java复制interface UserRepository {
    User findById(Long id);
}

@Repository
class JpaUserRepository implements UserRepository {
    @Override
    public User findById(Long id) {
        // JPA实现
    }
}

@Service
class UserService {
    @Autowired  // 注入的是接口类型
    private UserRepository repository;
    
    public User getUser(Long id) {
        return repository.findById(id);
    }
}

这种设计的优势：

1. 业务层不依赖具体实现
2. 可以随时切换持久化方案（如换成MyBatis实现）
3. 方便单元测试时使用Mock对象

5. 常见问题排查

5.1 继承中的构造方法链

java复制class Parent {
    Parent() {
        System.out.println("Parent构造");
    }
}

class Child extends Parent {
    Child() {
        // 编译器自动插入super()
        System.out.println("Child构造");
    }
}

典型错误：

1. 父类没有无参构造时，子类必须显式调用super(参数)
2. super()必须作为子类构造方法的第一条语句

5.2 接口默认方法冲突

当实现多个接口存在同名默认方法时：

java复制interface A {
    default void show() { System.out.println("A"); }
}

interface B {
    default void show() { System.out.println("B"); }
}

class C implements A, B {  // 编译错误
    // 必须重写show()解决冲突
    @Override
    public void show() {
        A.super.show();  // 显式选择接口A的实现
    }
}

5.3 类型转换异常

向下转型时的ClassCastException预防：

java复制Animal animal = new Cat();
if(animal instanceof Dog) {  // 必须做类型检查
    Dog dog = (Dog)animal;  // 错误的转型
}

安全转型模式：

java复制if(animal instanceof Dog dog) {  // Java16+模式匹配
    dog.bark();
}

6. 性能考量与最佳实践

6.1 继承层次控制

过深的继承层次会影响：

• 方法调用性能（虚方法表查找）
• 代码可维护性（"脆弱的基类"问题）

黄金法则：

• 继承层次不超过3层
• 优先使用组合而非继承
• 考虑使用final禁止关键类被继承

6.2 接口方法设计原则

1. 单一职责：每个接口聚焦一个特定功能域
2. 适度粒度：避免"上帝接口"
3. 默认方法保守使用：仅用于向后兼容
4. 静态方法提供工具功能

6.3 面向对象设计检查表

在完成这些编程题后，建议用以下问题检验设计质量：

1. 是否所有继承关系都符合"is-a"原则？
2. 抽象类是否包含足够的公共实现？
3. 接口是否精确定义了行为契约？
4. 多态使用是否避免了instanceof检查？
5. 是否遵循了"对扩展开放，对修改关闭"原则？

我在实际项目中最有价值的经验是：面向对象不是银弹，继承滥用比不用更危险。好的OOP设计应该像乐高积木——各个模块通过标准接口灵活组合，而不是焊死的金属块。