关于java设计模式的建议答案

【问题标题】：suggestion on design pattern in java关于java设计模式的建议
【发布时间】：2014-09-25 12:34:10
【问题描述】：

我需要一些关于 Java 中以下问题的设计模式的有用建议。

我有三个班级：

class A extends X implement Y {
    doA()
}
class B extends X implement Y {
    doB()
}
class C extends X implement Y {
    doC()
}

现在我想创建一个类D，它应该分别重用类A、B和C的方法doA、doB和doC。

谁能针对上述问题提出设计建议？

【问题讨论】：

A B C 扩展 X 并实现 Y 对您的问题重要吗？
doA、doB、doC到底是什么...它们是和X基类还是Y接口有关？
它需要扩展 X 类，因为 X 类将具有一些通用功能。 doA、doB 和 doc 具有与 A、B 和 C 类相关的特定功能。我想以某种方式在 D 类中重用这些 doA、doB 和 doC 方法。

标签： java design-patterns

【解决方案1】：

我认为您需要使用范例“Prefer composition over inheritance”。设计包含A、B、C 实例的类D，并根据需要调用它们的方法。此外，D 可以在必要时实现 Y，并将相应的 API 调用委托给 A 或 B 或 C。

【讨论】：

【解决方案2】：

这不是直接可能的。

如果您的设计允许，您最好的选择是将X 重新创建为接口，并将其他接口重新创建为扩展X 的接口。这将允许D 实现所有其他的。

如果做不到这一点，你可能（取决于你想要做什么）让D 持有A、B 和C 的私有实例，然后让它委托您提到这些实例的方法。但请记住，如果您这样做，您将拥有三个不同的 X 实例。

正确的答案可能是你的类层次结构已经不是它应该的样子了！但是问题中没有足够的细节来确定。

【讨论】：

【解决方案3】：

你可以试试这样的：

class A extends X implement Y{
  doA()
}
class B extends X implement Y{
  doB()
}
class C extends X implement Y{
   doC()
}

interface Delegator { 
    doSomething();
}

class DBuider {

    public DBuider with(Delegator d) {
        // create chain and store it
        return this;
    }

    Chain build() {
        // return new D with resulted chain
    }

    class Chain {
        Delegator del;
        Chain next;
    }
}

class D implements Y {
    Chain c;

    static DBuilder create() {
        return new DBuilder();
    }

    doD() {
        Chain t = c;
        while (t != null) {
            t.del.doSomething();
            t = t.next;
        }
    }
}

----- Usage -----

D.create().with(() -> new A().doA()).with(() -> new B().doB()).build().doD();

【讨论】：

【解决方案4】：

您可以从现有的课程中组成新的 D 课程：

class D {
    private A a = new A();
    private B b = new B();
    private C c = new C();

    public void foo() {
        this.a.doA();
        this.b.doB();
        this.c.doC();
    }
}

【讨论】：

【解决方案5】：

在不了解所有细节的情况下，这感觉像是一个构图问题。

Class D
{
   private A _a = new A();
   private B _b = new B();
   private C _c = new C();

   doA()
   {
      _a.doA();
   }

   doB()
   {
     _b.doB();
   }

   doC()
   {
     _c.doC();
   }
}

根据您要执行的操作，这实际上可能合适，也可能不合适。

【讨论】：