Java OOP疑问：如何让walk()根据创建者调用对应efficiency()方法

你当前的核心问题是静态方法不支持多态重写，所以无法通过父类引用动态调用子类的静态方法。要实现你想要的效果，有两种直观的解决方案，其中最符合OOP多态思想的是将静态方法改为实例方法，结合动态绑定来实现。

方案一：改用实例方法实现多态 #

修改步骤： #

1. 将efficiency()从静态方法改为实例方法，让Cat可以重写该方法
2. 让Moving类持有Animal实例的引用，而非直接访问静态类成员
3. 在letsMove()中传递当前实例给Moving，确保调用对应实例的efficiency()

修改后的完整代码： #

Animal类

public class Animal {
    private int capacity;
    // 注意：静态数组是类共享的，多个实例会互相覆盖，建议改为实例变量
    public int[] animalArray;

    public Animal(int value) {
        animalArray = new int[value];
    }

    public boolean adSteps(int element){
        if (capacity >= animalArray.length) {
            return false;
        } else {
            animalArray[capacity++] = element;
        }
        return true;
    }

    public Moving letsMove() {
        // 传递当前实例给Moving
        return new Moving(this);
    }

    // 改为实例方法，允许子类重写
    public int efficiency(int steps){
        int equalSteps = steps + 10;
        return equalSteps;
    }
}

Cat类

public class Cat extends Animal{
    public Cat(int value) {
        super(value);
    }

    // 重写父类的实例方法
    @Override
    public int efficiency(int steps) {
        int equalSteps = steps + 50;
        return equalSteps;
    }
}

Moving类

public class Moving {
    private int[] movingArray;
    private int totalWay;
    // 持有Animal实例引用
    private Animal animal;

    // 构造方法接收Animal实例
    public Moving(Animal animal) {
        this.animal = animal;
        this.movingArray = animal.animalArray.clone();
    }
    
    public int walk(){
        System.out.println("Go ahead");
        for (int i = 0; i < movingArray.length; i++){
            totalWay += movingArray[i];
        }
        // 调用实例的efficiency方法，实现动态绑定
        totalWay = animal.efficiency(totalWay);
        return totalWay;
    }
}

Main类（无需修改）

public class Main {
    public static void main(String[] args) {
        // 指向Cat实例，会调用Cat的efficiency
        Animal noName = new Cat(3);
        noName.adSteps(5);
        noName.adSteps(3);
        noName.adSteps(2);
        Moving iAmMoving = noName.letsMove();
        System.out.println(iAmMoving.walk()); // 输出：60

        // 指向Animal实例，会调用Animal的efficiency
        Animal animal = new Animal(3);
        animal.adSteps(5);
        animal.adSteps(3);
        animal.adSteps(2);
        Moving animalMove = animal.letsMove();
        System.out.println(animalMove.walk()); // 输出：20
    }
}

方案二：保留静态方法（不推荐，违背OOP思想） #

如果一定要保留静态方法，可以通过传递类类型来手动判断调用：

1. 在letsMove()中传递当前实例的Class对象
2. 在Moving中根据Class类型调用对应的静态方法

示例修改：

// Animal的letsMove方法
public Moving letsMove() {
    return new Moving(this.getClass());
}

// Moving类
public class Moving {
    private int[] movingArray;
    private int totalWay;
    private Class<?> animalClass;

    public Moving(Class<?> animalClass) {
        this.animalClass = animalClass;
        this.movingArray = Animal.animalArray.clone();
    }
    
    public int walk(){
        System.out.println("Go ahead");
        for (int i = 0; i < movingArray.length; i++){
            totalWay += movingArray[i];
        }
        // 手动判断类类型调用静态方法
        if (animalClass == Cat.class) {
            totalWay = Cat.efficiency(totalWay);
        } else {
            totalWay = Animal.efficiency(totalWay);
        }
        return totalWay;
    }
}

这种方法需要手动维护类型判断，后续新增子类时都要修改Moving的代码，不符合开闭原则，不推荐使用。

关键说明 #

• 静态方法属于类本身，不属于实例，所以Java不支持静态方法的多态重写，编译时就会确定调用哪个类的静态方法
• 实例方法属于对象实例，Java会根据运行时的实际对象类型动态绑定方法，这是实现多态的核心

内容的提问来源于stack exchange，提问作者GoAhead