Question

所以我有两个类：SoccerPlayer和IceHockeyPlayer
它们都有自己的接口，有一些方法：ISoccerPlayer和IIceHockeyPlayer

SoccerPlayer：

public class SoccerPlayer implements ISoccerPlayer {

    public String[] teammembers;

    @Override
    public void kickFootball(int meters) {
        // Kick the football
    }

    @Override
    public void runForward(double speed) {
        // Run forward
    }

    @Override
    public void addTeammembers(String[] memberNames) {
        // Add the members
    }
}

IceHockeyPlayer：

public class IceHockeyPlayer implements IIceHockeyPlayer {

    public ArrayList<String> teammembers;

    @Override
    public void hitPuck(int meters) {
        // Hit the puck
    }

    @Override
    public void skateForward(double speed) {
        // Skate forward
    }

    @Override
    public void addTeammembers(ArrayList<String> memberNames) {
        // Add the members
    }

}

接下来，我创建了一个包含SoccerPlayer和实现两个接口的IceHockeyPlayer的类，这将是我的适配器。
这个类中的方法只是调用SoccerPlayer或IceHockeyPlayer的正确方法：

public class Adapter implements ISoccerPlayer, IIceHockeyPlayer {

    public SoccerPlayer soccerplayer;
    public IceHockeyPlayer icehockeyplayer;

    public Adapter(SoccerPlayer soccerplayer, IceHockeyPlayer icehockeyplayer) {
        this.soccerplayer = soccerplayer;
        this.icehockeyplayer = icehockeyplayer;
    }

    // SoccerPlayer
    @Override
    public void kickFootball(int meters) {
        this.soccerplayer.kickFootball(meters);
    }

    @Override
    public void runForward(double speed) {
        this.soccerplayer.runForward(speed);
    }

    @Override
    public void addTeammembers(String[] memberNames) {
        this.soccerplayer.addTeammembers(memberNames);
    }

    // IceHockeyPlayer
    @Override
    public void hitPuck(int meters) {
        this.icehockeyplayer.hitPuck(meters);
    }

    @Override
    public void skateForward(double speed) {
        this.icehockeyplayer.skateForward(speed);
    }

    @Override
    public void addTeammembers(ArrayList<String> memberNames) {
        this.icehockeyplayer.addTeammembers(memberNames);
    }

}

这是适配器模式的正确实现吗？如果不是，我需要改变什么才能成为一个？

Answer 1

这更像是一个门面。

对于适配器，您可以使用

interface SportsPlayer {
    public void play(int meters);
    public void move(double speed);
}

和

等适配器

class IceHockeyPlayerAdapter implements SportsPlayer {
    private IceHockeyPlayer player;
    public IceHockeyPlayerAdapter(IceHockeyPlayer p) { player = p; }

    public void play(int meters) {
        player.playPuck(meters);
    }
    public void move(double speed) {
        player.skateForward(speed);
    }
}

将适应＆＃34;曲棍球运动员将成为＆＃34;一个SportsPlayer;所以它实际上是一个不同的方法集。

编辑：

这是真正的JDK的适配器用法。

您知道可以使用try-with-resources自动关闭资源，并且可以在提交任务后关闭ExecutorService吗？好吧，试用资源需要AutoCloseable而ExecutorService没有实现。拯救的适配器：

public class AutocloseableExecutorService implements ExecutorService, AutoCloseable {
    private ExecutorService delegate;
    public AutocloseableExecutorService(ExecutorService d) {
        delegate = d;
    }
    // delegate ExecutorService methods to implement the interface
    public void execute(Runnable r) { delegate.execute(r); 
    // ...

    // implement close() for AutoCloseable
    public void close() {
        delegate.shutdown();
    }
}

所以现在你可以像这样使用它：

public void submitTasks(Runnable... rs) {
    try (AutocloseableExecutorService executor = new AutocloseableExecutorService(
             Executors.newSingleThreadExecutor())) {
        for (Runnable r : rs) executor.submit();
    }
}

并且该方法将在该方法结束时注册该服务。

Answer 2

严格来说，它不是适配器您使用支持2个接口的对象组合：

public class Adapter implements ISoccerPlayer, IIceHockeyPlayer

GOF适配器模式通常将一个对象（但可能是多个）适配到一个特定接口，以便允许客户端操作接口类型，同时适应的对象使用适配器可能不提供客户端接口所需的方法。

例如，使用此客户端界面：

interface SportPlayer {
    void play();
}

假设SoccerPlayer没有play()方法，但功能上等效的方法有另一个名称：playSoccer()。
为了能够将SoccerPlayer对象调整为SportPlayer，您可以创建SoccerAdapter：

public class SoccerAdapter implements SportPlayer {
   private SoccerPlayer soccerPlayer;

   public SoccerAdapter(SoccerPlayer soccerPlayer){
      this.soccerPlayer = soccerPlayer;          
   }
   public void play(){
        soccerPlayer.playSoccer();
   }
}

Answer 3

不，这不是适配器模式。您可以使用适配器将调用者期望的行为/方法映射到提供者提供的内容。

示例：

假设您想构建一个处理您的玩家的机器人。它只知道一个玩家看起来像这个界面（我重用你的例子，这个问题是否有意义超出了这个问题的范围）：

interface Player {
  void shoot(int meters);
  void move(double speed);
  addTeammembers(ArrayList<String> memberNames);
}

该接口的适配器可能如下所示：

class SoccerPlayerAdapter implements Player {
  SoccerPlayer soccerplayer; //set via constructor

  void shoot(int meters) {
    soccerplayer.kickFootball(meters);
  }

  void move(double speed){
    soccerplayer.runForward(speed);
  }

  addTeammembers(ArrayList<String> memberNames) {
    soccerplayer.addTeammembers(memberNames);
  }
}

您可以看到SoccerPlayerAdapter“将”SoccerPlayer改为Player，即它将方法shoot(int meters)映射到kickFootball(int meters)等。

注意：如果接口无法直接实现，通常使用适配器，或者出于其他原因这样做没有多大意义。在你的例子中（以及我的例子），让玩家直接实现Player界面并将kickFootball(meters)重构为更通用的方法shoot(meters)等更有意义。

Answer 4

适配器模式解决了现有Consumer代码和现有Producer代码并且Consumer代码接受类型与{之间存在不兼容时的问题{1}}代码生成类型。

[Producer和Consumer代码不是标准术语，我更喜欢使用它们来使我的观点易于理解]

要解决此问题，我们会创建一个单独的Producer代码，该代码会使用Adapter代码生成的类型，并将转换代码转换为Producer代码所使用的类型

Consumer

对于代码，您可以参考（易于理解）https://www.geeksforgeeks.org/adapter-pattern/

这是适配器模式的正确实现吗？

4 个答案: