面试题：Java接口与抽象类对大型项目代码可维护性与扩展性的深度影响

1. 接口与抽象类的基本概念

接口：是一种特殊的抽象类型，它只包含方法签名而没有方法体，类实现接口必须实现接口中定义的所有方法。接口主要用于实现多继承，体现行为的抽象。
抽象类：可以包含抽象方法和具体方法。抽象方法只有声明没有实现，具体方法有完整的方法体。抽象类不能被实例化，主要用于提供一个通用的类层次结构的基础。

2. 确保可维护性和扩展性的策略

2.1 使用接口定义行为契约

在大型项目中，不同模块之间通过接口进行交互。例如，假设项目中有一个支付模块，我们可以定义一个 PaymentService 接口：

public interface PaymentService {
    boolean processPayment(double amount);
}

这样，不同的支付实现类（如 AlipayPaymentService、WechatPaymentService）可以实现这个接口，而其他模块调用 PaymentService 接口方法时，不需要关心具体的实现。

2.2 使用抽象类提取公共代码

当多个类有一些共同的属性和方法时，可以将这些内容提取到抽象类中。例如，在一个电商项目中，Product 类有一些共同的属性和方法，可以定义一个抽象类 AbstractProduct：

public abstract class AbstractProduct {
    protected String name;
    protected double price;

    public AbstractProduct(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public double getPrice() {
        return price;
    }

    public abstract String getDetails();
}

具体的产品类（如 Book、Electronics）继承 AbstractProduct 并实现抽象方法 getDetails。

2.3 不破坏原有代码结构添加新功能

假设要在支付模块中添加新的支付方式（如 ApplePay），由于已经定义了 PaymentService 接口，只需要创建一个新的类 ApplePayPaymentService 实现 PaymentService 接口即可：

public class ApplePayPaymentService implements PaymentService {
    @Override
    public boolean processPayment(double amount) {
        // 实现Apple Pay支付逻辑
        return true;
    }
}

在使用支付功能的地方，通过依赖注入等方式使用新的实现类，而不需要修改原有代码。

2.4 处理接口或抽象类变更的波及效应

如果需要在 PaymentService 接口中添加一个新方法 refundPayment，所有实现类都需要实现这个方法。为了减少对已有代码的影响，可以先在接口中添加默认实现（Java 8 及以上支持）：

public interface PaymentService {
    boolean processPayment(double amount);

    default boolean refundPayment(double amount) {
        // 默认实现，例如返回false
        return false;
    }
}

这样，已有的实现类不需要立即修改。对于需要特殊退款逻辑的实现类，再重写 refundPayment 方法。

3. 具体代码重构示例

假设原始代码中有一个 Order 类直接依赖具体的支付实现类 AlipayPaymentService：

public class Order {
    private AlipayPaymentService paymentService;

    public Order() {
        this.paymentService = new AlipayPaymentService();
    }

    public void placeOrder(double amount) {
        boolean success = paymentService.processPayment(amount);
        if (success) {
            System.out.println("Order placed successfully.");
        } else {
            System.out.println("Payment failed.");
        }
    }
}

重构时，引入 PaymentService 接口：

public class Order {
    private PaymentService paymentService;

    public Order(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void placeOrder(double amount) {
        boolean success = paymentService.processPayment(amount);
        if (success) {
            System.out.println("Order placed successfully.");
        } else {
            System.out.println("Payment failed.");
        }
    }
}

使用时：

public class Main {
    public static void main(String[] args) {
        PaymentService alipayService = new AlipayPaymentService();
        Order order = new Order(alipayService);
        order.placeOrder(100.0);
    }
}

这样，当需要更换支付方式时，只需要在创建 Order 对象时传入不同的 PaymentService 实现类，而不需要修改 Order 类的内部代码。

星途面试题库