在不修改基类的情况下实现多态性：一种中间层解决方案

public abstract class Root {
    // 现有方法和字段，不可修改
    public void commonOperation() {
        System.out.println("Performing common operation from Root.");
    }
}

public class A extends Root {
    // A特有的实现
}

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

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

public static void applyFuncOnRootObject(Root object) {
    if (object instanceof A) {
        ((A) object).func(); // 需要在A中定义func()
    } else if (object instanceof B) {
        ((B) object).func(); // 需要在B中定义func()
    } else if (object instanceof C) {
        ((C) object).func(); // 需要在C中定义func()
    } else {
        // 处理未知类型或默认行为
    }
}

public abstract class MyRoot extends Root {
    /**
     * 定义一个新的抽象方法，用于实现多态行为。
     * 所有继承MyRoot的子类都必须提供其具体实现。
     */
    public abstract void 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 Application {
    /**
     * 对MyRoot类型的对象应用func()方法。
     * 由于func()是MyRoot的抽象方法，此处将进行多态调用。
     */
    public static void applyFuncPolymorphically(MyRoot object) {
        object.func(); // 运行时将根据对象的实际类型调用对应的func()实现
    }

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

        System.out.println("--- 多态调用 func() ---");
        applyFuncPolymorphically(objA); // 输出: A 类的 func() 实现。
        applyFuncPolymorphically(objB); // 输出: B 类的 func() 实现。
        applyFuncPolymorphically(objC); // 输出: C 类的 func() 实现。

        System.out.println("\n--- 验证对 Root 现有方法的兼容性 ---");
        // 原始的 Root 方法仍然可以正常调用，因为 MyRoot 是 Root 的子类
        objA.commonOperation(); // 输出: Performing common operation from Root.

        // 如果现有代码期望 Root 类型，并且不关心 func() 方法，仍然可以正常工作
        Root genericRoot = new A();
        genericRoot.commonOperation(); // 输出: Performing common operation from Root.
        // genericRoot.func(); // 编译错误：Root 类中没有 func() 方法
    }
}