2

假设我有以下情况：

    abstract class A {
        abstract method1();
        abstract method2();
    }

    class B extends A {
        method1() {
            // implementation 1
        }
        method2() {
            // implementation 3
        }
    }

    class C extends A {
        method1() {
            // implementation 1
        }
        method2() {
            // implementation 4
        }
    }

    class D extends A {
        method1() {
            // implementation 2
        }
        method2() {
            // implementation 4
        }
    }

底线：同一类的几个子类，对不同的方法使用不同的方法实现。

问题是我在不同的子类中有相同的实现。我的问题是如何处理这些常见的实现？
这样做的合乎逻辑的方法是创建另一个抽象级别，但这只有在我有一个具有通用实现的方法时才有效（因为 Java 没有多重继承）。我也可以把最常用的实现放在超类中，只在其他类中以不同的方式实现。但是，我不会这样做，因为随着时间的推移，最常见的实现可能会随着其他类的添加而改变，此外，我想在超类中保持方法抽象。

是否有某种模式可以以“优雅的方式”解决我的问题？

4

2 回答 2

5

您遇到了经典的 OOP 问题，继承层次结构变得笨拙:-)

我建议的解决方案：

  • 更喜欢组合而不是继承——将实现分解为单独的对象，这些对象可以“插入”以提供所需的行为。基类中的方法只是通过其定义的接口调用实现插件。这基本上是策略模式。这是一种非常可靠的方法，尽管当您有很多不同的策略类型时，有时会容易出现大量过度设计/样板。
  • 采用基于原型的模型——使用基于原型的对象而不是传统的 OOP。这解决了所有问题——您摆脱了继承层次结构的固有限制，只需将您想要的实现复制到运行时需要它的任何对象。这是最激进的选择，但可以带来一些很大的好处。
  • 将实现分解为静态函数- 这样您可以共享实现 - 这有点混乱，因为您仍然需要执行所有覆盖，但它们只是将调用委托给正确的实现。这通常是侵入性最小的选项。
于 2012-05-23T07:07:20.050 回答
2

我会推荐作曲。考虑以下：

interface I1 {
     method1();
}

abstract class A implements I1{
    abstract method1();
    abstract method2();
}

class CommonOperations implements I1 {
    method1() {
        // implementation 1
    }
}

class B extends A {
    CommonOperations common;

    method1() {
        common.method1();
    }
    method2() {
        // implementation 3
    }
}

class C extends A {
    CommonOperations common;

    method1() {
        common.method1();
    }
    method2() {
        // implementation 4
    }
}

class D extends A {
    method1() {
        // implementation 2
    }
    method2() {
        // implementation 4
    }
}
于 2012-05-23T07:14:15.790 回答