java二十三种设计模式----（三）单例设计模式 ：类适配器和对象适配器

</pre>定义：适配器模式将一个类的接口（源）转换成客户期望的另外一个目标接口，使得原本由于接口不兼容而不能一起工作的哪些类可以在一起工作。<span style="white-space:pre"></span>适配器。适配就是由“源”到“目标”的适配，而当中链接两者的关系就是适配器。它负责把“源”过度到“目标”。接着讨论如何加说法语这个方法，也许你会说，为什么不直接在“源”中直接添加方法我的理解是，适配是为了实现某种目的而为一个源类暂时性的加上某种方法，所以不能破坏原类的结构。同时不这么做也符合Java的高内聚，低耦合的原理。既然不能直接加，接着我们就来说该怎么来实现为人这个“源”添加一个方法，而又不破坏“源”的本身结构。适配器模式有2种，第一种是“面向类的适配器模式”，（类适配器采用继承方式）第二种是“面向对象的适配器模式”。（对象适配器采用组合方式）把被适配者，作为一个对象组合到适配器类中，以实现目标接口的添加功能。适配器作用1，透明：通过适配器，客户端可以调用同一个接口，因而对客户来说是透明的，这样做更简单，更直接，更紧凑2，重用：复用了现存的类，解决现存类和复用环境要求不一致的问题。3，低耦合：将目标类和适配者类解耦，通过引入一个适配器类重用现有的适配者类，而无需修改原有代码（遵循开闭原则）4，灵活性和扩展性都非常好，符合开闭原则<p></p><p></p>举个我们生活中常见的例子。第一个例子：我们有时候外出旅游，由于我们的电脑电源插头是三相插头，电源只是二相插头，我们如果想给电脑充电，就需要把二相插头转换成三相插头，这时我们就需要一个转换器，而这个转换器就是我们需要的适配器。实现这一需求的过程中我们需要4部分构成。1，客户端笔记本电脑充电。（NoteBook）2，目标接口（三相插头接口）ThreePluginterface3，适配器 二相转化成三相  TwoChangeThree4，被适配类 二相电流（TwoPlug）<div><p>代码如下</p><div></div>一：使用对象适配器1，客户端笔记本电脑充电。（NoteBook）</div><div><pre name="code" class="java">package 适配器设计模式;
//客户端笔记本电脑
public class NoteBook {
	//传入三相插座
	private ThreePlugInterface plug;
	
	//定义一个构造函数
	public NoteBook(ThreePlugInterface plug){
		this.plug=plug;
	}
	
	//定义满足需求的充电动作(使用三相插座充电)
	public void charge(){
		plug.powerWithThree();
	}
	public static void main(String[] args) {
		//现在只有二相插座
		TwoPlug two=new TwoPlug();
		//声明一个用来使用的三相插座参数。但是我们只有二相插座，这时就需要使用适配器来把二相转化成三相。
		ThreePlugInterface three=new TwoChangeThreeAdapter(two);
		NoteBook NB=new NoteBook(three);
		NB.charge();
		
		System.out.println("-------------");
		three =new TwoChangeThreeAdapter2();
		NB=new NoteBook(three);
		NB.charge();
	}
}

2，目标接口（三相插头接口）ThreePluginterface

package 适配器设计模式;
/*
 * 目标接口：三相插座接口。
 */
public interface ThreePlugInterface {
	//使用三相电流供电。
	public void powerWithThree();
}

3，适配器 二相转化成三相  TwoChangeThree

package 适配器设计模式;
/*
 * 定义一个二相转化成三相的插座适配器。
 * 
 * 对象适配器：
 * 把被适配者（二相插座类）作为一个对象组合到适配器类中，用以给目标接口添加功能。
 */
public class TwoChangeThreeAdapter implements ThreePlugInterface {
	//声明一个二相插座作为成员变量。把其功能组合到三相插座类中。
	private TwoPlug plug;
	//声明一个构造函数
	 public TwoChangeThreeAdapter(TwoPlug plug) {
	
		this.plug=plug;
	}
	public void powerWithThree(){
		//使用二相插座给三相插座供电，既把二相插座的功能添加给三相插座。
		System.out.println("使用二相插座给三相插座供电(目标接口供电)");
		plug.powerWithTwo();
		
		
	}

}

4，被适配类 二相电流（TwoPlug）

package 适配器设计模式;
/*
 * 被适配类：二相插座
 */
public class TwoPlug {
	//使用二相插座供电
	public void powerWithTwo(){
		System.out.println("使用二相电流给三相插座供电（被适配类）");
	}
}

二：使用类适配器

1，客户端笔记本电脑充电。（NoteBook）

和对象适配器一样的代码
2，目标接口（三相插头接口）ThreePluginterface

和对象适配器一样的代码
3，适配器 二相转化成三相  TwoChangeThree

package 适配器设计模式;
/*
 * 采用继承方式的插座适配器。
 */
public class TwoChangeThreeAdapter2 extends TwoPlug implements ThreePlugInterface {

	public void powerWithThree() {
		this.powerWithTwo();//继承被适配类的充电方法。
		System.out.println("（继承方式的适配器）使用二相电流给三相插座供电（被适配类）");
	}

}

4，被适配类 二相电流（TwoPlug）

和对象适配器一样的代码

第二个例子：
举个简单的例子，比如有一个“源”是一个对象人，他拥有2种技能分别是说日语和说英语
而某个岗位（目标）需要你同时回说日语、英语、和法语，
好了，现在我们的任务就是要将人这个“源”适配的这个岗位中，如何适配呢？
显而易见地我们需要为人添加一个说法语的方法，这样才能满足目标的需要。


 
先说“面向类的适配器模式”。顾名思义，这类适配器模式就是主要用于，单一的为某个类而实现适配的这样一种模式，为什么说只为某个类去实现，一会提到，我们先展示这种类适配模式的代码实现。


源的代码如下：


public class Person {  
      
    private String name;  
    private String sex;  
    private int age;  
      
    public void speakJapanese(){  
        System.out.println("I can speak Japanese!");  
    }  
      
    public void speakEnglish(){  
        System.out.println("I can speak English!");  
    }  
    ...//以下省略成员变量的get和set方法  
}  


 


 目标接口的代码如下：


public interface Job {  
      
    public abstract void speakJapanese();  
    public abstract void speakEnglish();  
    public abstract void speakFrench();  
      
}  


 适配器的代码如下：

public class Adapter extends Person implements Job{  
  
    public void speakFrench() {  
          
    }  
      
}  


 


好了，代码看完然后要做一些说明了，之前遗留的一个问题，为什么称其为类适配模式呢？
很显然的，Adapter类继承了Person类，而在Java这种单继承的语言中也就意味着，
他不可能再去继承其他的类了，这样也就是这个适配器只为Person这一个类服务。所以称其为类适配模式。


 


说完类的适配模式，我们要开始说第2种对象的适配器模式了。
对象适配器模式是把“源”作为一个对象聚合到适配器类中。同样的话不多说，贴上代码：


 源的代码以及目标代码同上，再次不再赘述。
仅贴出适配器代码：


public class Adapter implements Job {  
  
    Person person;  
  
    public Adapter(Person person) {  
        this.person = person;  
    }  
  
    public void speakEnglish() {  
        person.speakEnglish();  
    }  
  
    public void speakJapanese() {  
        person.speakJapanese();  
    }  
  
    //new add  
    public void speakFrench() {  
          
    }  
  
}  


 


对象的适配器模式，把“源”作为一个构造参数传入适配器，然后执行接口所要求的方法
这种适配模式可以为多个源进行适配。弥补了类适配模式的不足。


 


现在来对2种适配模式做个分析：


1.类的适配模式用于单一源的适配，由于它的源的单一话，代码实现不用写选择逻辑，很清晰；
而对象的适配模式则可用于多源的适配，弥补了类适配模式的不足，使得原本用类适配模式需要写很多适配器的情况不复存在，
弱点是，由于源的数目可以较多，所以具体的实现条件选择分支比较多，不太清晰。


2.适配器模式主要用于几种情况：
（1）系统需要使用现有的类，但现有的类不完全符合需要。
（2）讲彼此没有太大关联的类引进来一起完成某项工作（指对象适配）。


 


最后，再来顺带谈谈默认适配器模式：这种模式的核心归结如下：当你想实现一个接口但又不想实现所有接口方法，只想去实现一部分方法时，就用中默认的适配器模式，他的方法是在接口和具体实现类中添加一个抽象类，而用抽象类去空实现目标接口的所有方法。而具体的实现类只需要覆盖其需要完成的方法即可。代码如下：


接口类：


public interface Job {  
      
    public abstract void speakJapanese();  
    public abstract void speakEnglish();  
    public abstract void speakFrench();  
    public abstract void speakChinese();  
      
}  


抽象类： 


public abstract class JobDefault implements Job{  
  
    public void speakChinese() {  
          
    }  
  
    public void speakEnglish() {  
          
    }  
  
    public void speakFrench() {  
          
    }  
  
    public void speakJapanese() {  
          
    }  
  
}  


实现类：




public class JobImpl extends JobDefault{  
      
    public void speakChinese(){  
        System.out.println("I can speak Chinese!");  
    }  
      
}  


 


好了，适配器模式就先说到这了，希望对自己和大家都有一个提高。

代码如下