无法修改基类时实现多态的策略：引入中间抽象层设计模式

public static void applyFuncOnRootObject(Root object) {
    if (object instanceof A) {
        ((A) object).func();
    } else if (object instanceof B) {
        ((B) object).func();
    }
    // ... 更多类型判断
}

// 原始的、不可修改的基类
public abstract class Root {
    // ... 可能包含一些现有功能或抽象方法 ...
    public void commonMethod() {
        System.out.println("Root 的通用方法");
    }
}

// 原始的子类，它们直接继承 Root
public class A extends Root {
    // ... A 类的特有实现 ...
}

public class B extends Root {
    // ... B 类的特有实现 ...
}

public class C extends Root {
    // ... C 类的特有实现 ...
}

// 原始的、不可修改的基类
public abstract class Root {
    public void commonMethod() {
        System.out.println("Root 的通用方法");
    }
}

// 引入的中间抽象层：继承自 Root，并定义了我们想要的多态方法
public abstract class MyRoot extends Root {
    // 定义一个抽象方法，要求所有继承 MyRoot 的子类必须实现它
    public abstract void func();
}

// 子类现在继承 MyRoot，并实现 func() 方法
public class A extends MyRoot {
    @Override
    public void func() {
        System.out.println("A 类的 func 实现");
    }
    // ... A 类的其他特有实现 ...
}

public class B extends MyRoot {
    @Override
    public void func() {
        System.out.println("B 类的 func 实现");
    }
    // ... B 类的其他特有实现 ...
}

public class C extends MyRoot {
    @Override
    public void func() {
        System.out.println("C 类的 func 实现");
    }
    // ... C 类的其他特有实现 ...
}

public class PolymorphismDemo {
    // 接受 MyRoot 类型的对象，直接调用其 func() 方法
    public static void applyFuncOnMyRootObject(MyRoot object) {
        object.func(); // 无需类型判断和强制转换
    }

    public static void main(String[] args) {
        MyRoot objA = new A();
        MyRoot objB = new B();
        MyRoot objC = new C();

        System.out.println("--- 调用 applyFuncOnMyRootObject 方法 ---");
        applyFuncOnMyRootObject(objA); // 输出: A 类的 func 实现
        applyFuncOnMyRootObject(objB); // 输出: B 类的 func 实现
        applyFuncOnMyRootObject(objC); // 输出: C 类的 func 实现

        System.out.println("\n--- 直接调用 commonMethod (继承自 Root) ---");
        objA.commonMethod(); // 仍然可以访问 Root 的方法
    }
}