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

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

我有单独的界面：

Basic

，

Complex

。所有类都实现

Basic

。有些类实现了

复杂的
，但它们必须从抽象类继承

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


代码是用Java编写的。
我认为您应该使用decorator模式并使用composition。
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
来扩展
Complex
，但这通常会让人感觉违反直觉。但是只有当
Complex
重新定义/专门化继承的方法时。
我认为类似于Builder的设计模式可以很好地用于这种情况：
首先为基本

public interface Basic{ 
   public void  basicOp();
}

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

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

第三：创建实现基本接口的必需类：（Class2）

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

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

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

第五：创建扩展到抽象类之上的所有其他类（Class3、Class4、Class5）。
有时最好使用组合而不是继承。因此，不要依赖于很多子类，而是将行为拉到一个独立的结构中并注入它。这里可能用到的设计模式是策略和依赖注入（控制反转）

深层类层次结构通常是一个气味指示器，您经常会遇到问题，因为Java不支持交易，如果您在不共享同一祖先的不同类中需要相同的行为，您会得到代码重复。
在没有任何实际用例的情况下，很难说它是否可行。从理论上讲这是可能的。但是你不应该使用设计模式，因为它存在，你应该在有意义的时候使用它。根据你提供的信息，装饰器模式没有真正意义你有一个界面复合体和一个类复合体？不是一个
装饰器，因为它需要合成。这看起来像是在视觉范式中绘制的，但是继承被标记为依赖，实现被标记为继承。。这不是一个构建器模式。没有产品，也没有构建者来构建产品。是的，当然，这不完全是构建者设计模式，我告诉过一些类似的东西。这不是正确的答案，在你的代码文本中，基本和复杂之间没有关联。他提供的图像与他的文本不符。由于OP没有对评论做出反应，我将继续回答这个问题，直到他提供更多的意见。
public abstract class AbstractClassComplexA implements Complex{ 
   @Override 
   public complexOp() { ... } 

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