在面向对象的编程中，子类继承父类是一种常见的实现代码复用的方式。然而，仅仅通过继承并不能保证代码的高效复用。为了达到这个目标，我们需要巧妙地调用不同子类中的方法。本文将探讨如何通过几种方法来实现这一点，从而提升代码的复用性和效率。

理解多态与向上转型

多态是面向对象编程中的一个核心概念，它允许我们将父类引用指向子类对象，并通过这个引用调用子类的方法。这种机制被称为向上转型。在调用方法时，如果子类中重写了父类的方法，则会调用子类的方法，否则调用父类的方法。

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

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

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.makeSound(); // 输出: Dog barks
    }
}

在上述代码中，Animal 类和 Dog 类都包含一个 makeSound 方法。当我们通过 Animal 类型的引用调用 makeSound 方法时，实际调用的是 Dog 类中的方法，因为 myDog 是一个 Dog 类型的对象。

利用接口和回调函数

接口是Java中实现多态的一种方式。通过定义一个接口，我们可以让不同的子类实现相同的接口方法，然后在父类中调用这些方法。这种做法可以提高代码的复用性，并且便于维护。

interface Flyable {
    void fly();
}

class Bird implements Flyable {
    public void fly() {
        System.out.println("Bird is flying");
    }
}

class Airplane implements Flyable {
    public void fly() {
        System.out.println("Airplane is flying");
    }
}

public class Main {
    public static void main(String[] args) {
        Flyable myBird = new Bird();
        myBird.fly(); // 输出: Bird is flying
        
        Flyable myAirplane = new Airplane();
        myAirplane.fly(); // 输出: Airplane is flying
    }
}

在上述代码中，Flyable 接口定义了一个 fly 方法，Bird 类和 Airplane 类都实现了这个接口。通过 Flyable 类型的引用，我们可以调用 fly 方法，而不必关心具体是哪个子类实现了该方法。

回调函数也是一种实现多态的方法。在回调函数中，我们定义了一个函数指针（或方法引用），并在需要的时候调用这个函数。这种方法在事件驱动编程中非常常见。

interface Callback {
    void onDone();
}

public class Main {
    public static void main(String[] args) {
        Callback callback = new Callback() {
            public void onDone() {
                System.out.println("Callback executed");
            }
        };
        
        performTask(callback);
    }
    
    public static void performTask(Callback callback) {
        // 执行一些任务...
        callback.onDone(); // 调用回调函数
    }
}

在上述代码中，Callback 接口定义了一个 onDone 方法。在 performTask 方法中，我们通过传入一个实现了 Callback 接口的匿名类对象作为参数，并在任务完成后调用 onDone 方法。

使用组合而非继承

虽然继承是实现代码复用的常用方式，但在某些情况下，使用组合（将子类作为父类的成员变量）可以更好地提高代码的复用性和灵活性。

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

class Dog {
    Animal animal = new Animal();
    
    void makeSound() {
        animal.makeSound(); // 调用父类方法
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.makeSound(); // 输出: Animal makes a sound
    }
}

在上述代码中，Dog 类包含一个 Animal 类型的成员变量。在 makeSound 方法中，我们通过调用 animal 对象的 makeSound 方法来复用 Animal 类中的方法。

总结

通过巧妙地调用不同子类中的方法，我们可以提高代码的复用性和效率。本文介绍了多态、接口、回调函数和组合等几种方法，希望对您的编程实践有所帮助。在实际应用中，您可以根据具体需求选择合适的方法，以实现最佳的效果。