适配器模式:
适配器模式将某个类的接口转换成客户端期望的另一个接口表示,目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类:类的适配器模式、对象的适配器模式、接口的适配器模式。
1 类适配器:核心思想就是:有一个Source类,拥有一个方法,待适配,目标接口是Targetable,通过Adapter类,将Source的功能扩展到
2 对象适配器:基本思路和类的适配器模式相同,只是将Adapter类作修改,这次不继承Source类,而是持有Source类的实例,以达到解决兼容性的问题。看图:
3 接口适配器:
第三种适配器模式是接口的适配器模式,接口的适配器是这样的:有时我们写的一个接口中有多个抽象方法,当我们写该接口的实现类时,必须实现该接口的所有方法,这明显有时比较浪费,因为并不是所有的方法都是我们需要的,有时只需要某一些,此处为了解决这个问题,我们引入了接口的适配器模式,借助于一个抽象类,该抽象类实现了该接口,实现了所有的方法,而我们不和原始的接口打交道,只和该抽象类取得联系,所以我们写一个类,继承该抽象类,重写我们需要的方法就行。看一下类图:
类适配器是其他的基础
讲了这么多,总结一下三种适配器模式的应用场景:
类的适配器模式:当希望将一个类转换成满足另一个新接口的类时,可以使用类的适配器模式,创建一个新类,继承原有的类,实现新的接口即可。
对象的适配器模式:当希望将一个对象转换成满足另一个新接口的对象时,可以创建一个Wrapper类,持有原类的一个实例,在Wrapper类的方法中,调用实例的方法就行。
接口的适配器模式:当不希望实现一个接口中所有的方法时,可以创建一个抽象类Wrapper,实现所有方法,我们写别的类的时候,继承抽象类即可。
简易代码实现:类和对象适配器
public class Current {
public void use220V() {
System.out.println("使用220v的电流");
}
}
**************************************************************
/**
* 使用继承的方式实现适配器
*/
public class Adapter extends Current {
public void use18V() {
System.out.println("使用适配器adapter");
this.use220V();
}
}
**************************************************************
/**
* 使用委让的形式实现
*/
public class Adapter2 {
private Current current;
public Adapter2(Current current) {
this.current = current;
}
public Current getCurrent() {
return current;
}
public void setCurrent(Current current) {
this.current = current;
}
public void user18V(){
System.out.println("使用适配器Adapter2");
current.use220V();
}
}
**************************************************************
public class MailClass {
public static void main(String[] args) {
Current current = new Current();
current.use220V();
System.out.println("*******************************");
Adapter adapter = new Adapter();
adapter.use18V();
System.out.println("*******************************");
Adapter2 adapter2 = new Adapter2(current);
adapter2.user18V();
}
}
测试结果
使用220v的电流
*******************************
使用适配器adapter
使用220v的电流
*******************************
使用适配器Adapter2
使用220v的电流
***类适配器:
public class Adaptee {
public void sampleOperation1(){
System.out.println("this is original method!");
}
}
****************************************************************************************************************
/**
* 上面给出的是目标角色的源代码,这个角色是以一个Java接口的形式实现的。可以看出,这个接口声明了两个方法:sampleOperation1()和sampleOperation2()。
* 而源角色Adaptee是一个具体类,它有一个sampleOperation1()方法,但是没有sampleOperation2()方法。
*
* 适配器角色Adapter扩展了Adaptee,同时又实现了目标(Target)接口。
* 由于Adaptee没有提供sampleOperation2()方法,而目标接口又要求这个方法,因此适配器角色Adapter实现了这个方法。
*/
public class Adapter extends Adaptee implements Target {
@Override
public void sampleOperation2() {
System.out.println("this is the Target method!");
}
}
****************************************************************************************************************
/**
* 类适配器模式:
*
* 用电器做例子,笔记本电脑的插头一般都是三相的,即除了阳极、阴极外,还有一个地极。而有些地方的电源插座却只有两极,没有地极。
* 电源插座与笔记本电脑的电源插头不匹配使得笔记本电脑无法使用。
* 这时候一个三相到两相的转换器(适配器)就能解决此问题,而这正像是本模式所做的事情。
*
* Adaptee类并没有sampleOperation2()方法,而客户端则期待这个方法。为使客户端能够使用Adaptee类,提供一个中间环节,即类Adapter,把Adaptee的API与Target类的API衔接起来。
* Adapter与Adaptee是继承关系,这决定了这个适配器模式是类的:
*
* 目标(Target)角色:这就是所期待得到的接口。注意:由于这里讨论的是类适配器模式,因此目标不可以是类。
* 源(Adapee)角色:现在需要适配的接口。
* 适配器(Adaper)角色:适配器类是本模式的核心。适配器把源接口转换成目标接口。显然,这一角色不可以是接口,而必须是具体类。
*
*/
public interface Target {
//这个是源类Adaptee也有的方法
public void sampleOperation1();
//这是源类Adapteee没有的方法
public void sampleOperation2();
}
****************************************************************************************************************
public class MainClass {
public static void main(String[] args) {
Target target = new Adapter();
target.sampleOperation1();
target.sampleOperation2();
}
}
测试结果:
this is original method!
this is the Target method!
2 对象适配器
/**
* 对象适配器模式:
*
*
*
* Adaptee类并没有sampleOperation2()方法,而客户端则期待这个方法。
* 为使客户端能够使用Adaptee类,需要提供一个包装(Wrapper)类Adapter。
* 这个包装类包装了一个Adaptee的实例,从而此包装类能够把Adaptee的API与Target类的API衔接起来。
* Adapter与Adaptee是委派关系,这决定了适配器模式是对象的。
*/
interface Target {
/**
* 这是源类Adaptee也有的方法
*/
public void sampleOperation1();
/**
* 这是源类Adapteee没有的方法
*/
public void sampleOperation2();
}
class Adaptee {
public void sampleOperation1(){
System.out.println("this is original method!");
}
}
class Adapter implements Target{
private Adaptee adaptee;
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
public Adaptee getAdaptee() {
return adaptee;
}
public void setAdaptee(Adaptee adaptee) {
this.adaptee = adaptee;
}
@Override
public void sampleOperation1() {
adaptee.sampleOperation1();
}
@Override
public void sampleOperation2() {
System.out.println("this is the targetable method!");
}
}
public class MainClass {
public static void main(String[] args) {
Adaptee adaptee = new Adaptee();
Target target = new Adapter(adaptee);
target.sampleOperation1();
target.sampleOperation2();
}
}
测试结果:
this is original method!
this is the targetable method!
3 接口适配器
/**
* 接口的适配器模式,
*
* 接口的适配器是这样的:
* 有时我们写的一个接口中有多个抽象方法,当我们写该接口的实现类时,必须实现该接口的所有方法,
* 这明显有时比较浪费,因为并不是所有的方法都是我们需要的,有时只需要某一些,此处为了解决这个问题,
* 我们引入了接口的适配器模式,借助于一个抽象类,该抽象类实现了该接口,实现了所有的方法,而我们不和原始的接口打交道,只和该抽象类取得联系,
* 所以我们写一个类,继承该抽象类,重写我们需要的方法就行
*/
interface Sourceable {
public void method1();
public void method2();
}
abstract class Wrapper implements Sourceable {
@Override
public void method1() {}
@Override
public void method2() {}
}
class SourceSub1 extends Wrapper {
@Override
public void method1() {
// super.method1();
System.out.println("the sourceable interface's first Sub1!");
}
}
class SourceSub2 extends Wrapper {
@Override
public void method2() {
// super.method2();
System.out.println("the sourceable interface's second Sub2!");
}
}
public class MainClass {
public static void main(String[] args) {
Sourceable source1 = new SourceSub1();
Sourceable source2 = new SourceSub2();
source1.method1();
source1.method2();//这个方法里面没有实现,所以不会输出
System.out.println("****************");
source2.method1();//这个方法里面没有实现,所以不会输出
source2.method2();
}
}
测试:
the sourceable interface's first Sub1!
****************
the sourceable interface's second Sub2!