设计模式之（9）——适配器模式

　　定义：适配器模式是将一个类的接口转换成客户希望的另一个接口，适配器模式使得原本由于接口不兼容而不能一起工作的类可以一起工作，在软件设计中我们需要将一些“现存的对象”放到新的环境中，而新环境要求的接口是现对象所不能满足的，我们可以使用这种模式进行接口适配转换，使得“老对象”符合新环境的要求。

　　使用场景：1、系统需要使用现有的类，而此类的接口不符合系统的需要；2、通过接口转换，将一个类插入另一个类中，用电器来打个比喻：有一个电器的插头是三脚的，而现有的插座是两孔的，要使插头插上插座，我们需要一个插头转换器，这个转换器即是适配器。

　　适配器模式涉及三个角色：

　　1、源（Adaptee）:需要被适配的对象或类型，相当于插头；

　　2、适配器（Adapter）:连接源和目标对象的中间对象，相当于转换器；

　　3、目标角色（Target）:定义了客户端期望的接口，相当于插座；

　　如何实现呢？

　　使用继承（类适配器）或者聚合（对象适配器）已有的对象实现想要的目标接口，优先推荐使用对象适配器（基于组合优先于继承）。

　　适配器模式结构图：

　　以下我们先以对象适配为例来分析，以下是源码：

package cn.com.pep.model.adapter.a1;
/**
 * 
 * @Title: AdvancedMediaPlayer  
 * @Description:  源对象的接口
 * @author wwh 
 * @date 2022-9-5 10:10:14
 */
public interface AdvancedMediaPlayer {

	/**
	 * @Title: playVlc 
	 * @Description:  
	 * @param filename
	 */
	public void playVlc(String filename);
	
	/**
	 * @Title: playMp4 
	 * @Description:  
	 * @param filename
	 */
	public void playMp4(String filename);
}

package cn.com.pep.model.adapter.a1;
/**
 * 
 * @Title: MeidaPlayer  
 * @Description:  目标对象接口
 * @author wwh 
 * @date 2022-9-5 10:08:30
 */
public interface MeidaPlayer {
    
    /**
     * @Title: play 
     * @Description:  
     * @param audioType
     * @param filename
     */
    public void play(String audioType,String filename);

}

package cn.com.pep.model.adapter.a1;

/**
 * 
 * @Title: Mp4MediaPlayer
 * @Description: 源对象
 * @author wwh
 * @date 2022-9-5 10:13:48
 */
public class Mp4MediaPlayer implements AdvancedMediaPlayer {

	@Override
	public void playVlc(String filename) {
		
	}

	@Override
	public void playMp4(String filename) {
		System.err.println("Playing mp4 and filename is:" + filename);
	}
}

package cn.com.pep.model.adapter.a1;

/**
 * 
 * @Title: VLCMediaPlayer
 * @Description: 源对象
 * @author wwh
 * @date 2022-9-5 10:12:07
 */
public class VLCMediaPlayer implements AdvancedMediaPlayer {

    @Override
    public void playVlc(String filename) {
        System.err.println("Playing vlc and filename is:" + filename);
    }

    @Override
    public void playMp4(String filename) {
        
    }

}

package cn.com.pep.model.adapter.a1;

/**
 * 
 * @Title: MediaPlayerAdapter
 * @Description: 对象适配器，通过聚合持有一个源对象的引用
 * @author wwh
 * @date 2022-9-5 10:19:10
 */
public class MediaPlayerAdapter implements MeidaPlayer {
    
    /**
     *     通过聚合的方式持有一个源对象的引用
     */
    private AdvancedMediaPlayer player;

    public MediaPlayerAdapter(String filetype) {
        if ("mp4".equalsIgnoreCase(filetype)) {
            player = new Mp4MediaPlayer();
        } else if ("vlc".equalsIgnoreCase(filetype)) {
            player = new VLCMediaPlayer();
        }
    }

    @Override
    public void play(String audioType, String filename) {
        System.err.println("执行了适配器中的play()方法");
        if ("mp4".equalsIgnoreCase(audioType)) {
            player.playMp4(filename);
        } else if ("vlc".equalsIgnoreCase(audioType)) {
            player.playVlc(filename);
        }
    }

}

package cn.com.pep.model.adapter.a1;
/**
 * @Title: AudioMediaPlayer
 * @Description: 目标对象
 * @author wwh
 * @date 2022-9-5 10:49:33
 */
public class AudioMediaPlayer implements MeidaPlayer {

    private MediaPlayerAdapter adapter;

    @Override
    public void play(String audioType, String filename) {
        if ("mp3".equalsIgnoreCase(audioType)) {
            System.out.println("Playing mp3 and filename is: " + filename);
        } else if ("mp4".equalsIgnoreCase(audioType) || "vlc".equalsIgnoreCase(audioType)) {
            adapter = new MediaPlayerAdapter(audioType);
            adapter.play(audioType, filename);
        }
    }
}

package cn.com.pep.model.adapter.a1;
/**
 * 
 * @Title: AdapterPatternDemo  
 * @Description:  测试代码
 * @author wwh 
 * @date 2022-9-5 10:56:33
 */
public class AdapterPatternDemo {
    
    public static void main(String[] args) {
        AudioMediaPlayer player = new AudioMediaPlayer();
        player.play("mp3", "红日.mp3");
        player.play("mp4", "天下无贼.mp4");
        player.play("vlc", "平凡的世界.vlc");
    }
}

　　UML类图：

　　以上就是对象适配模式，目标接口MediaPlayer中有一个play(String,String)方法，而源对象接口AdvancedMediaPlayer中并没有这个方法，我们想通过目标接口的对象AudioMediaPlayer实现播放VCL、Mp4格式的文件，就需要一个MediaPlayerAdapter来对源对象(Mp4MediaPlayer、VLCMedaiPlayer)进行适配，它通过聚合的方式持有一个AdvancedMediaPlayer类型的引用，并且它还实现了与目标对象相同的接口，自然也就包含了和目标对象相同的方法，目标对象AudioMediaPlayer关联了MediaPlayerAdapter对象的引用，当然就可以实现播放VCL、Mp4格式的文件了；

　　接下来我们说说类适配器模式：

　　类适配是通过Adapter类继承Adaptee(被适配类)，同时实现Target接口（因为Java不支持多继承，所以只能通过实现接口的方式来实现多继承）来实现的，类适配器的重点在于类，是通过构造一个继承Adaptee类来实现适配器的功能的，而上面提到的对象适配器重点在于对象，是通过直接在Adapter中聚合Adaptee类来实现的，当需要调用特殊功能的时候，直接使用Adapter中聚合的那个Adaptee对象来调用特殊的功能即可；

　　以下是类适配器的测试代码：

package cn.com.pep.model.adapter.a2;
/**
 * 
 * @Title: Adaptee  
 * @Description:  需要适配的类
 * @author wwh 
 * @date 2022-9-5 15:29:20
 */
public class Adaptee {
    
    public void specificRequest() {
        System.err.println("执行适配类的方法");
    }
}

package cn.com.pep.model.adapter.a2;
/**
 * 
 * @Title: Target  
 * @Description:  目标对象的接口
 * @author wwh 
 * @date 2022-9-5 15:31:05
 */
public interface Target {
    
    /**
     * @Title: calculate 
     * @Description:
     */
    public void calculate();
}

package cn.com.pep.model.adapter.a2;
/**
 * 
 * @Title: ConcreteTarget  
 * @Description:  目标对象
 * @author wwh 
 * @date 2022-9-5 15:49:50
 */
public class ConcreteTarget implements Target{

    @Override
    public void calculate() {
        System.err.println("执行目标类的方法");
    }
}

package cn.com.pep.model.adapter.a2;
/**
 * 
 * @Title: Adapter  
 * @Description:  类适配器，继承了需要适配的类，并且实现了目标对象的接口
 * @author wwh 
 * @date 2022-9-5 15:59:37
 */
public class Adapter extends Adaptee implements Target{

    @Override
    public void calculate() {
        specificRequest();
    }
}

package cn.com.pep.model.adapter.a2;

/**
 * 
 * @Title: ClassAdapterDemo
 * @Description: 测试类
 * @author wwh
 * @date 2022-9-5 15:57:58
 */
public class ClassAdapterDemo {

    public static void main(String[] args) {
        // 使用普通功能类
        Target concreteTarget = new ConcreteTarget();// 实例化一个普通类
        concreteTarget.calculate();

        // 使用特殊功能类，即适配类
        Target adapter = new Adapter();
        adapter.calculate();
    }
}