在 Java 中实现类适配器模式

Question

在阅读 Head First Design Patterns 中的类适配器模式时，我遇到了这句话：

类适配器...因为你需要多重继承来实现它，这在Java中是不可能的

为了实验，我尝试了以下操作：

interface MyNeededInterface{
    public void operationOne(MyNeededInterface other);
    public MyNeededInterface operationTwo();
}

public class ThirdPartyLibraryClass{
    public void thirdPartyOp();
}

假设我创建 :

class ThirdPartyWrapper extends ThirdPartyLibraryClass implements MyNeededInterface{

    @Override
    public void operationOne(ThirdPartyWrapper other){
        this.thirdPartyOp();
        dosomeExtra();
    }
    @Override
    public ThirdPartyWrapper operationTwo(){
        int somevalue = doSomeThingElse();
        return new ThirdPartyWrapper(somevalue);
    }
}

在我的代码中，我可以使用：

MyNeededInterface myclass = createThirdPartyWrapper();
myclass.operationOne(someobj);
...

这不是类适配器模式吗？

Answer 1

GoF（四人帮）告诉我们两种主要类型的适配器：

A. 类适配器。他们通常使用多重继承来使一个接口适应另一个接口。 （但是我们必须记住，在java中，不支持通过类的多重继承（有充分的理由:)）。我们需要接口来实现多重继承的概念。）

B. 对象适配器。它们取决于对象的组成。

为了说明这些概念，我将举一个简单的例子：
（来源：《Java 设计模式》一书）

interface IIntegerValue 
{
    public int getInteger();
}

class IntegerValue implements IIntegerValue
{
    @Override
    public int getInteger() 
    {
        return 5;
    }
}
// Adapter using interface
class ClassAdapter extends IntegerValue
{
    //Incrementing by 2
    public int getInteger()
    {
        return 2 + super.getInteger();
    }
}

// Adapter using composition
class ObjectAdapter implements IIntegerValue
{
    private IIntegerValue myInt;

    public ObjectAdapter(IIntegerValue myInt)
    {
        this.myInt=myInt;
    }

    //Incrementing by 2
    public int getInteger()
    {
        return 2+this.myInt.getInteger();
    }
}

class ClassAndObjectAdapter
{
    public static void main(String args[])
    {
        System.out.println("Class and Object Adapter Demo");
        ClassAdapter ca1=new ClassAdapter();
        System.out.println("Class Adapter is returning :"+ca1.getInteger());
        ClassAdapter ca2=new ClassAdapter();
        ObjectAdapter oa=new ObjectAdapter(new IntegerValue());
        System.out.println("Object Adapter is returning :"+oa.getInteger());
    }
}

控制台输出：

类和对象适配器演示
类适配器正在返回：7
对象适配器正在返回：7

Answer 2

通过使用单继承，类适配器在 Java 中是可能的。
作为傻瓜设计模式中的示例，假设我们必须调整 AWT 复选框为了与 Swing 复选框一起使用，我们可以为此编写一个类适配器。

Swing 中用于确定是否选中复选框的 UI 代码是使用 isSelected 方法完成的。但是，AWT 复选框不支持 isSelected()，而是使用 getState()。

因此，我们可以编写一个适配器来包装 SWT 复选框，并将 getState() 适配为 isSelected()

  public class CheckboxAdapter extends Checkbox
  { 

      public CheckboxAdapter(String n) 
      {
         super(n);
      }

      public boolean isSelected()
      {
         return getState();
      }
  }

现在，我们可以处理 AWT 适配的复选框，就像处理 isSelected 方法时的标准 Swing 复选框一样。

  public void itemStateChanged(ItemEvent e)
  {
      String outString = new String("Selected: ");

      for(int loopIndex = 0; loopIndex 
         <= checks.length - 1; loopIndex++){
           if(checks[loopIndex].isSelected()) {
              outString += " checkbox " + loopIndex;
           }
       }
      text.setText(outString);
   }

编辑：真正的类适配器在Java中是不可能的，如果我们可以从多个类继承，我们想在适配器类中模仿它们。

另请参阅 http://www.journaldev.com/ 1487/adapter-design-pattern-in-java-example-tutorial 用于 Java 中使用类适配器和对象适配器的两个示例，以达到相同的结果。

Answer 3

类适配器模式在 Java 中是不可能的，因为您无法扩展多个类。因此，您必须采用使用组合而不是继承的适配器模式。

下面是通过组合的适配器模式的示例：

interface Duck
{
    public void quack();
}

class BlackDuck implements Duck
{
   public void quack() { }
}

class Turkey
{
    public void gobble() { }
}

class TurkeyAdapter implements Duck
{
    private Turkey t;

    public TurkeyAdapter(Turkey t)
    {
        this.t = t;
    }

    public void quack()
    {
        // A turkey is not a duck but, act like one
        t.gobble();
    }
}

现在，您可以通过 TurkeyAdapterTurkey 传递给需要 Duck 的方法>。

class DuckCatcher
{
    public void catch(Duck duck) { }
}

通过使用适配器模式，DuckCatcher 现在还能够捕获 Turkey(Adapter) 和 Duck。

Answer 4

是的，只要您只包装单个适配器，您就可以创建带有接口的类适配器。通过多重继承，您可以采用两个或多个适配器并将它们包装到单个接口中。

Answer 5

完整的故事是这样的：类适配器模式在 Java 中是不可能的，因为 Java 不提供多重继承。

在他们的图表中，他们显示 Adapter 类子类都是 Target 和 Adaptee。您的示例是（接近）对象适配器模式。不同之处在于您在适配器类中实现了 Target，而不是仅仅对目标进行子类化（示例中的 MyNeededInterface）