Question

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

我有单独的界面：Basic，Complex。所有类都实现Basic。一些类实现Complex但它们必须从Abstract类继承。

我在想装饰师，但我不知道我是不对。

代码是Java。

Answer 1

我觉得像 Builder 这样的设计模式可能适用于这种情况：首先为基本

创建一个界面

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 ）。

Answer 2

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

下面是一个简短的例子。

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到延伸Complex，但这经常是违反直觉的。但只有Complex重新定义/专门化继承的方法。

Answer 3

有时最好使用合成而不是继承。因此，不依赖于许多子类，而是在独立结构中拉出行为并注入它。可以在这里播放的设计模式是策略和依赖注入（控制反转）。

深层次结构通常是一个气味指示器，并且经常会遇到问题，因为Java不支持交易，如果您在不同的类中需要相同的行为而不能共享同一个祖先，则会出现代码重复

是否有任何设计模式可供使用？

3 个答案: