如何在Java中包装抽象类层次结构

我正在编写一个库（wrapperLibrary），它包装了另一个库（dependentLibrary）的所有类，我希望强制积分器只使用wrapperLibrary中的类，而不使用dependentLibrary中的类-彻底包装它

我正试图找到一种方法来包装dependentLibrary的以下抽象层次结构：

public abstract class AOT{
    // Has few abstract methods and few default method implementation
}

public abstract class AMOT extends AOT {
    // Has a new abstract method and few overridden methods
}

public class COTM extends AMOT{
    // Implementation class of the abstract hierarchy
}

包装器应如下所示：

public abstract class AOTWrapper{
    // Has the default method implementation of AOT
}

public abstract class AMOTWrapper extends AOTWrapper {
    // Has the default method implementation of AMOT
}

public class COTMWrapper extends AMOTWrapper{
    // Implementation class of the abstract hierarchy
}

wrapperLibrary的集成商或使用者不应访问AOT/AMOT/COTM

dependentLibrary中的其他类也将AOT/AMOT/COTM作为方法参数或返回类型。因此，我们应该能够在需要时将AOT包装器转换为AOT

---

我们怎样才能做到这一点呢？

这实际上不是一个包装器，通常被称为一个特定的设计模式。它要求wrapper和wrapped类实现同一个接口，但实际上您可以通过所有wrapper的抽象父类扩展lib的最后一个子具体类，并覆盖所有相关方法，您意识到在这种情况下，所有wrapper将继承所有libs方法，但是您可以通过异常抛出来覆盖不必要的异常（例如，您可以在java.util.AbstractList的某些方法中找到类似的技巧）。然后，可能好的解决方案是使用一个工厂，它将正确地创建您的lib实例，放入包装器中，并在客户喜欢的任何类容器中提供给客户。大概是这样的：

public class Main {

    public static void main(String[] args) {

        WrapperFactory wrapperFactory = new WrapperFactory();
        COTMWrapper cotmWrapper = wrapperFactory.getWrapper(COTMWrapper.class);
        cotmWrapper.doCOTMStuff();
        cotmWrapper.doSomethingElse();
        AMOTWrapper amotWrapper = cotmWrapper;
        amotWrapper.doAOTStuff();
        AOTWrapper aotWrapper = amotWrapper;
        aotWrapper.doAOTStuff();
        AOT likeNotWrapped = cotmWrapper;
        likeNotWrapped.doSomething();
    }

}
 class WrapperFactory {

    public <T extends AOTWrapper> T  getWrapper(Class<T> type){
        COTM cotm = new COTM();
        return type.cast(new COTMWrapper(cotm));
    }
}

abstract class AOT {
    // Has few abstract methods and few default method implementation
    public abstract void doSomething();

    public void doAOTStuff() {
        // AOT stuff is doing
    }

}

abstract class AMOT extends AOT {
    // Has a new abstract method and few overridden methods
    public abstract void doSomethingElse();

    public void doSomething() {
        // AMOT stuff is doing
    }

}

class COTM extends AMOT {
    // Implementation class of the abstract hierarchy

    public void doSomethingElse() {
        doCOTMStuff();
    }

    public void doCOTMStuff() {
        // COTM stuff is doing
    }
}

abstract class AOTWrapper extends COTM {

    private AOT container;

    public AOTWrapper(AOT container) {
        this.container = container;
    }

    @Override
    public void doAOTStuff() {
        container.doAOTStuff();
    }

     @Override
    public void doCOTMStuff() {
        throw new UnsupportedOperationException();
    }

    @Override
    public void doSomething() {
        throw new UnsupportedOperationException();
    }

    @Override
    public void doSomethingElse() {
        throw new UnsupportedOperationException();
    }
    // Has the default method implementation of AOT
}

abstract class AMOTWrapper extends AOTWrapper {

    private AMOT container;

    public AMOTWrapper(AMOT container) {
        super(container);
        this.container = container;
    }

    @Override
    public void doSomething() {
        container.doSomething();
    }

    // Has the default method implementation of AMOT
}

class COTMWrapper extends AMOTWrapper {

    private COTM container;

    public COTMWrapper(COTM container) {
        super(container);
        this.container = container;
    }

    @Override
    public void doSomethingElse() {
        container.doSomethingElse();
    }

    @Override
    public void doCOTMStuff() {
        container.doCOTMStuff();
        // COTM stuff is doing
    }
//     Implementation class of the abstract hierarchy
}

---

祝你好运

这实际上不是通常称为特定设计模式的包装器。它要求wrapper和wrapped类实现同一个接口，但实际上您可以通过所有wrapper的抽象父类扩展lib的最后一个子具体类，并覆盖所有相关方法，您意识到在这种情况下，所有wrapper将继承所有libs方法，但是您可以通过异常抛出来覆盖不必要的异常（例如，您可以在java.util.AbstractList的某些方法中找到类似的技巧）。然后，可能好的解决方案是使用一个工厂，它将正确地创建您的lib实例，放入包装器中，并在客户喜欢的任何类容器中提供给客户。大概是这样的：

public class Main {

    public static void main(String[] args) {

        WrapperFactory wrapperFactory = new WrapperFactory();
        COTMWrapper cotmWrapper = wrapperFactory.getWrapper(COTMWrapper.class);
        cotmWrapper.doCOTMStuff();
        cotmWrapper.doSomethingElse();
        AMOTWrapper amotWrapper = cotmWrapper;
        amotWrapper.doAOTStuff();
        AOTWrapper aotWrapper = amotWrapper;
        aotWrapper.doAOTStuff();
        AOT likeNotWrapped = cotmWrapper;
        likeNotWrapped.doSomething();
    }

}
 class WrapperFactory {

    public <T extends AOTWrapper> T  getWrapper(Class<T> type){
        COTM cotm = new COTM();
        return type.cast(new COTMWrapper(cotm));
    }
}

abstract class AOT {
    // Has few abstract methods and few default method implementation
    public abstract void doSomething();

    public void doAOTStuff() {
        // AOT stuff is doing
    }

}

abstract class AMOT extends AOT {
    // Has a new abstract method and few overridden methods
    public abstract void doSomethingElse();

    public void doSomething() {
        // AMOT stuff is doing
    }

}

class COTM extends AMOT {
    // Implementation class of the abstract hierarchy

    public void doSomethingElse() {
        doCOTMStuff();
    }

    public void doCOTMStuff() {
        // COTM stuff is doing
    }
}

abstract class AOTWrapper extends COTM {

    private AOT container;

    public AOTWrapper(AOT container) {
        this.container = container;
    }

    @Override
    public void doAOTStuff() {
        container.doAOTStuff();
    }

     @Override
    public void doCOTMStuff() {
        throw new UnsupportedOperationException();
    }

    @Override
    public void doSomething() {
        throw new UnsupportedOperationException();
    }

    @Override
    public void doSomethingElse() {
        throw new UnsupportedOperationException();
    }
    // Has the default method implementation of AOT
}

abstract class AMOTWrapper extends AOTWrapper {

    private AMOT container;

    public AMOTWrapper(AMOT container) {
        super(container);
        this.container = container;
    }

    @Override
    public void doSomething() {
        container.doSomething();
    }

    // Has the default method implementation of AMOT
}

class COTMWrapper extends AMOTWrapper {

    private COTM container;

    public COTMWrapper(COTM container) {
        super(container);
        this.container = container;
    }

    @Override
    public void doSomethingElse() {
        container.doSomethingElse();
    }

    @Override
    public void doCOTMStuff() {
        container.doCOTMStuff();
        // COTM stuff is doing
    }
//     Implementation class of the abstract hierarchy
}

---

祝你好运

你在用什么Java？在Java1.9之前，没有办法在代码中保留公共Java类，而是阻止用户访问它们？在Java 1.9之前，没有办法在代码中保留公共Java类，但阻止用户访问它们。COTM类必须实现抽象层次结构的所有抽象方法，即AOT的doSomething（）和AMOT的doSomethingElse（）。如果我们的包装器扩展了实现类，那么没有doSomethingElse（），集成商就无法实现任何实现！我不确定你是否好。若您想说AOTWrapper必须覆盖所有COTM方法，那个么这是真的，但您将选择要包装的方法以及引发异常的方法。正如我所说，由于您没有交互界面，我看不到任何优雅的解决方案。顺便说一句，如果使用AOT AOT=new AOTWrapper（），访问范围将缩小；AOTWrapper应与AOT类似，即AOTWrapper不应具有doSomethingElse（）。积分器可以根据需要扩展AOTWrapper或AMOTWrapper。它们将看到父方法，但无法使用它们。如果你想让它干净，你可以拒绝你的包装器继承并进行如下构造：

抽象类AOTWrapper extensed AOT实现AOT接口

编写所需的接口并从另一个

接口继承它们amotter extensed AOT接口

，依此类推。COTM类必须实现所有抽象类抽象层次结构的方法，即AOT的doSomething（）和AMOT的doSomethingElse（）。如果我们的包装器扩展了实现类，那么没有doSomethingElse（），集成商就无法实现任何实现！我不确定你是否好。若您想说AOTWrapper必须覆盖所有COTM方法，那个么这是真的，但您将选择要包装的方法以及引发异常的方法。正如我所说，由于您没有交互界面，我看不到任何优雅的解决方案。顺便说一句，如果使用AOT AOT=new AOTWrapper（），访问范围将缩小；AOTWrapper应与AOT类似，即AOTWrapper不应具有doSomethingElse（）。积分器可以根据需要扩展AOTWrapper或AMOTWrapper。它们将看到父方法，但无法使用它们。如果你想让它变得干净，你可以拒绝你的包装器继承，并进行如下构造：

抽象类AOTWrapper extends AOT实现AOT接口

编写所需的接口并从另一个

接口继承它们amotinker extends AOT接口

，依此类推。