有什么设计模式可以使用吗？答案

【问题标题】：Is there any design pattern to use?有什么设计模式可以使用吗？
【发布时间】：2015-01-12 18:34:16
【问题描述】：

我应该为以下问题使用并命名一个设计模式：

我有单独的接口：Basic、Complex。所有类都实现Basic。一些类实现了Complex，但它们必须从抽象类继承。

我在考虑装饰器，但我不知道我是否正确。

代码是用 Java 编写的。

【问题讨论】：

在没有任何实际用例的情况下，恕我直言，很难说它是否可能有意义。从理论上讲是可以的。但是你不应该使用设计模式，因为它存在，你应该在有意义的时候使用它。
根据您提供的装饰器模式的信息并没有真正意义
你有一个接口 Complex 和一个类 Complex？
不是decorator，因为它需要合成。
这个貌似是用Visual Paradigm画的，但是继承被标记为依赖，实现被标记为继承..o_o

标签： java design-patterns

【解决方案1】：

我认为像 Builder 设计模式这样的东西可以很好地解决这种情况：首先为Basic

创建一个界面

public interface Basic{ 
   public void  basicOp();
}

第二个：为复合体创建一个接口：

public interface Complex{ 
   public void complexOp();
   public Basic basicOp();
}

第三：创建实现基本接口的所需类：(Class2)

public class abstractBasicA implements Basic { 
   @Override
   public void basicOp() { ... }
}

第四：为复杂接口创建抽象所需类

public abstract class AbstractClassComplexA implements Complex{ 
   @Override 
   public complexOp() { ... } 

   @Override 
   public abstract Basic basicOp(){...}
}

第五：创建所有其他扩展于抽象类之上的类（Class3, Class4, Class5）。

【讨论】：

这不是构建器模式。没有产品，也没有构建产品的构建器。
是的，当然，这不完全是 Builder 设计模式，我说了一些类似的话

【解决方案2】：

我认为你应该使用装饰器模式并使用组合。 Complex 应该有一个 Basic 成员，它可以管理 Complex 类型的 Basic 部分。

下面是一个简短的例子。

package main;

public class Main {

    public static void main(String[] args) {
        Basic basic = new BasicImpl();
        basic.basicOp();
        // main.BasicImpl.op()

        Complex ca = new ConcreteComplexA(basic);
        ca.basicOp();
        ca.complexOp();
        // main.BasicImpl.op()
        // main.ConcreteComplexA.complex()

        Complex cb = new ConcreteComplexB(basic);
        cb.basicOp();
        cb.complexOp();
        // main.BasicImpl.op()
        // main.ConcreteComplexB.complex()
    }
}

interface Basic {

    void basicOp();
}

interface Complex extends Basic {

    void complexOp();
}

class BasicImpl implements Basic {

    @Override
    public void basicOp() {
        System.out.println("main.BasicImpl.basicOp()");
    }
}

abstract class AbstractComplex implements Complex {

    private final Basic basic;

    public AbstractComplex(Basic basic) {
        this.basic = basic;
    }

    @Override
    public void basicOp() {
        basic.basicOp();
    }
}

class ConcreteComplexA extends AbstractComplex {

    public ConcreteComplexA(Basic basic) {
        super(basic);
    }

    @Override
    public void complexOp() {
        System.out.println("main.ConcreteComplexA.complex()");
    }
}

class ConcreteComplexB extends AbstractComplex {

    public ConcreteComplexB(Basic basic) {
        super(basic);
    }

    @Override
    public void complexOp() {
        System.out.println("main.ConcreteComplexB.complex()");
    }
}

如果你想要干净的子类型，你必须强制行为一致性，即遵守你继承的类型（及其方法）的所有不变量，你需要Basic来扩展@ 987654327@，但这种感觉经常违反直觉。但前提是Complex 重新定义/专门化了继承的方法。

【讨论】：

这不是正确答案，您的代码中基本和复杂之间没有关联
我为 OP 文本建模。他提供的图像不反映他的文字。而且由于 OP 没有对 cmets 做出反应，我将继续使用这个答案，直到他提供更多输入。

【解决方案3】：

有时最好使用组合而不是继承。所以与其依赖很多子类，不如把行为拉出一个独立的结构，注入进去。可以在这里使用的设计模式是策略和依赖注入（控制反转）。

深层类层次结构通常是一种气味指标，并且您经常会遇到问题，因为 Java 不支持交易，并且如果您需要在不共享相同祖先的不同类中具有相同的行为，您会遇到代码重复。

【讨论】：