Question

说我有以下情况：

    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没有多个继承）。我还可以将最常用的实现放在超类中，并且只在其他类中以不同方式实现它。但是，我不这样做，因为随着时间的推移，最常见的实现可能会随着其他类的添加而改变，此外，我希望将方法保持在超类中。

是否有一些模式能够以“优雅的方式”解决我的问题？

Answer 1

你遇到了经典的OOP问题，继承的heirarchies变得笨拙： - ）

我建议的解决方案：

首选组合继承 - 将实现分解为可以“插入”以提供所需行为的单独对象。基类中的方法只是通过其定义的接口调用实现插件。这基本上是Strategy Pattern。这是一种非常可靠的方法，但是当你有很多不同的策略类型时，有时会变得容易出现大量的过度工程/样板。
采用基于原型的模型 - 使用prototype-based对象而不是传统的OOP。这解决了所有问题 - 您逃避了继承层次结构的固有限制，并且可以将您想要的实现复制到运行时需要它的任何对象。这是最激进的选择，但可以带来一些很大的好处。
因子实现了成静态函数 - 这种方式，您可以共享的实现 - 这是一个有点乱，因为你仍然需要做的所有的覆盖，但他们只是变成单行委托调用正确的实施。这通常是最不具侵入性的选择。

Answer 2

我会推荐Composition。请考虑以下事项：

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
    }
}

不同子类中的相同实现

2 个答案: