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

本文探讨了在基类代码不可修改的情况下，如何为其派生类引入新的多态行为。通过创建一个继承自原基类的中间抽象类，并让所有相关派生类转而继承此中间类，我们能够优雅地实现新的多态方法，从而避免了冗余的类型判断和强制类型转换，提升了代码的可维护性和扩展性。

在软件开发中，我们经常会遇到需要对一个现有类层次结构引入新功能，并且希望这些功能能够表现出多态性行为的场景。然而，如果基类（例如，来自第三方库或遗留代码）的代码是不可访问或不可修改的，传统的通过在基类中定义抽象方法来实现多态的方式就无法应用。在这种情况下，开发者可能会倾向于使用instanceof操作符和强制类型转换来根据对象的实际类型调用不同的方法，但这会导致代码冗余、难以维护且容易出错。本文将介绍一种通过引入中间抽象类来优雅解决这一问题的方案。

问题场景分析

假设我们有一个不可修改的抽象基类 Root，以及一系列继承自 Root 的具体子类 A、B 和 C：

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特有的实现
}

现在，我们希望为 Root 及其子类引入一个名为 func() 的新功能，并且这个功能在 A、B、C 中有不同的实现。同时，我们希望能够以多态的方式调用 func()，即通过一个 Root 类型的引用来调用，但又不能修改 Root 类本身。

如果采用传统的 instanceof 方式，代码可能如下所示：

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 {
        // 处理未知类型或默认行为
    }
}

这种方法显然违背了开放/封闭原则（对扩展开放，对修改封闭），每次增加新的子类时，都需要修改 applyFuncOnRootObject 方法，并且类型转换和条件判断也使得代码变得复杂和脆弱。

引入中间抽象类实现多态

解决上述问题的关键在于引入一个中间抽象类。这个中间抽象类将继承自不可修改的 Root 类，并定义我们希望实现多态行为的抽象方法 func()。然后，让所有的具体子类 A、B、C 转而继承这个新的中间抽象类，而不是直接继承 Root。

图改改

在线修改图片文字

455
查看详情

1. 定义中间抽象类

首先，创建一个新的抽象类 MyRoot，它继承自原始的 Root 类，并声明我们需要的抽象方法 func()：

public abstract class MyRoot extends Root {
    /**
     * 定义一个新的抽象方法，用于实现多态行为。
     * 所有继承MyRoot的子类都必须提供其具体实现。
     */
    public abstract void func();
}

2. 修改现有子类的继承关系

接下来，修改 A、B、C 类，使它们继承 MyRoot 而不是 Root，并实现 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特有的其他方法和字段
}

3. 多态调用示例

现在，我们可以通过 MyRoot 类型的引用来多态地调用 func() 方法，而无需任何类型判断和强制转换：

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() 方法
    }
}

优点与注意事项

优点：

实现多态性： 在不修改原始基类 Root 的前提下，成功引入了新的多态行为 func()。
代码整洁性： 消除了 instanceof 和强制类型转换的冗余代码，使得 applyFuncPolymorphically 方法简洁且易于理解。
可维护性与扩展性： 当新增一个子类 D 时，只需让 D 继承 MyRoot 并实现 func()，而无需修改任何现有处理 MyRoot 对象的方法。这符合开放/封闭原则。
类型安全： 编译器在编译时就能检查 func() 方法的调用是否合法，避免了运行时类型转换错误。
兼容性： 由于 MyRoot 继承自 Root，因此所有 MyRoot 或其子类的实例仍然可以被视为 Root 类型，与现有依赖 Root 的代码保持兼容。

注意事项：

子类可修改性： 这个解决方案的前提是，所有需要实现新多态行为的子类（如 A、B、C）都是可以被修改的，以便它们能够继承 MyRoot 而不是 Root。如果这些子类本身也是不可修改的（例如，来自另一个第三方库），则此方案不适用，可能需要考虑适配器模式或访问者模式等其他设计模式。
新类型引入： 引入 MyRoot 实际上创建了一个新的类型层次结构。在需要使用 func() 的地方，应尽量使用 MyRoot 作为静态类型，以充分利用多态性。
抽象粒度： MyRoot 类中可以定义多个抽象方法，以引入更丰富的多态行为。