面试题：Java类的重载与重写在复杂继承体系中的问题与解决方案

可能遇到的问题

命名冲突：在重载和重写过程中，若方法命名不规范，可能出现方法名相同但参数列表、返回值类型或功能不一致的情况，导致开发人员难以理解方法的真正用途。例如：

class Parent {
    public void doWork(int num) {
        System.out.println("Parent doWork with int: " + num);
    }
}

class Child extends Parent {
    // 命名冲突，虽参数不同但功能可能混淆
    public void doWork(String str) {
        System.out.println("Child doWork with String: " + str);
    }
}

调用混乱：在多层继承结构中，由于重写和重载，很难确定实际调用的是哪个方法。尤其在多态场景下，对象的实际类型决定了方法调用，这可能导致难以追踪的错误。例如：

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();
        animal1.makeSound(); // 调用Dog的makeSound
        animal2.makeSound(); // 调用Cat的makeSound
        // 如果对Animal、Dog、Cat类关系不熟悉，很难直观判断调用结果
    }
}

脆弱的基类依赖：子类依赖于基类的方法签名。若基类方法签名改变（例如添加或移除参数），所有重写该方法的子类都需要修改，这增加了维护成本。例如：

class Base {
    public void process(int value) {
        System.out.println("Base process: " + value);
    }
}

class Sub extends Base {
    @Override
    public void process(int value) {
        System.out.println("Sub process: " + value);
    }
}

// 若Base类改为
class Base {
    public void process(int value, String msg) {
        System.out.println("Base process: " + value + " " + msg);
    }
}
// Sub类必须修改以适配新的签名

优化方案

使用里氏替换原则：确保子类可以完全替代父类，遵循相同的接口契约。例如，在上述动物的例子中，Dog和Cat类都正确重写了Animal类的makeSound方法，符合里氏替换原则。
策略模式：当有多种行为变体时，可将行为封装成不同的策略类，避免在一个类中大量重载方法。例如：

interface PaymentStrategy {
    void pay(double amount);
}

class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paying " + amount + " using Credit Card");
    }
}

class PayPalPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paying " + amount + " using PayPal");
    }
}

class ShoppingCart {
    private PaymentStrategy paymentStrategy;

    public ShoppingCart(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void checkout(double amount) {
        paymentStrategy.pay(amount);
    }
}

public class Main {
    public static void main(String[] args) {
        ShoppingCart cart1 = new ShoppingCart(new CreditCardPayment());
        ShoppingCart cart2 = new ShoppingCart(new PayPalPayment());
        cart1.checkout(100.0);
        cart2.checkout(200.0);
    }
}

模板方法模式：在基类中定义一个算法的骨架，将部分步骤延迟到子类实现，减少重复代码和方法重载。例如：

abstract class AbstractGame {
    public final void play() {
        initialize();
        startGame();
        endGame();
    }

    protected abstract void initialize();
    protected abstract void startGame();
    protected abstract void endGame();
}

class Cricket extends AbstractGame {
    @Override
    protected void initialize() {
        System.out.println("Cricket game initialized!");
    }

    @Override
    protected void startGame() {
        System.out.println("Cricket game started.");
    }

    @Override
    protected void endGame() {
        System.out.println("Cricket game ended.");
    }
}

class Football extends AbstractGame {
    @Override
    protected void initialize() {
        System.out.println("Football game initialized!");
    }

    @Override
    protected void startGame() {
        System.out.println("Football game started.");
    }

    @Override
    protected void endGame() {
        System.out.println("Football game ended.");
    }
}

public class Main {
    public static void main(String[] args) {
        AbstractGame game1 = new Cricket();
        AbstractGame game2 = new Football();
        game1.play();
        game2.play();
    }
}

星途面试题库

面试题：Java类的重载与重写在复杂继承体系中的问题与解决方案

知识考点

面试题答案

可能遇到的问题

优化方案