适配器模式

定义：把一个类的接口变换成客户端所期待的另一种接口，从而是原本因接口不匹配而无法在一起工作的两个类能够一起工作。

有三种形式：

　　1.类的适配器模式：

　　当客户在接口中定义了他期望的行为时，我们就可以应用适配器模式，提供一个实现该接口的类，并且扩展已有的类，通过创建子类来实现适配。

　　概念不多说，直接举例：以ps2与usb的转接为例；

　　usb接口：

//usb接口
public interface Usb {
    
void dousb();

} 

//usb接口实现类
public class UsbImpl implements Usb{

    public void dousb() {
    System.out.println("usb插口");
        
    }

}

 

 

 

ps2接口：

 

//ps2接口
public interface PS2 {
    
 void dops2();
}

 

适配类：

//适配类
public class Adapter extends UsbImpl implements PS2{

    public void dops2() {
        super.dousb();
        
    }

}

测试如下：

public class Test  {

    public static void main(String[] args) {

        PS2 ps2 = new Adapter();
        ps2.dops2();
    }
}

输出：usb插口

 

 

　　2.对象的适配器模式：对象适配器”通过组合除了满足“用户期待接口”还降低了代码间的不良耦合。在工作中推荐使用“对象适配”。

　　还是以上面的例子，只要把适配类稍微修改下就可以；

 

//适配类
public class Adapter implements PS2{
    private Usb usb;
    
    public Adapter() {
    usb=new UsbImpl();
    }

    public void dops2() {
        usb.dousb();
        
    }

}

 

测试如下：

public class Test  {

    public static void main(String[] args) {

        PS2 ps2 = new Adapter();
        ps2.dops2();
    }
}

输出：usb插口，和上面一样

 

　　3.接口适配器：接口适配器模式是一种特殊的适配器模式，但这个适配器是由一个抽象类实现的，并且在抽象类中要实现目标接口中所规定的所有方法，但很多方法的实现都是“平庸”的实现，也就是说，这些方法都是空方法。而具体的子类都要继承此抽象类。
 目标接口：

 

public interface Sourceable {
    public void a();
    public void b();
    public void c();
    public void d();
}

 

适配类：

public abstract class Wrapper implements Sourceable{

    public void a() {
    }

    public void b() {
        
    }

    public void c() {
        
    }

    public void d() {
        
    }

}

具体实现类：

public class WrapperSub1 extends Wrapper{
public void a(){
    System.out.println("我是a()方法");
}
}

public class WrapperSub2 extends Wrapper{
public void d(){
    System.out.println("我是d()方法");
}
}

测试如下：

public class Test  {

    public static void main(String[] args) {

        Sourceable s=new WrapperSub1();
        Sourceable s2=new WrapperSub2();
        s.a();
        s.b();
        s.c();
        s.d();
        
        s2.a();
        s2.b();
        s2.c();
        s2.d();
    }
}

输出：

我是a()方法
我是d()方法

适配器模式应用场景：

类适配器与对象适配器的使用场景一致，仅仅是实现手段稍有区别，二者主要用于如下场景：

　　（1）想要使用一个已经存在的类，但是它却不符合现有的接口规范，导致无法直接去访问，这时创建一个适配器就能间接去访问这个类中的方法。

　　（2）我们有一个类，想将其设计为可重用的类（可被多处访问），我们可以创建适配器来将这个类来适配其他没有提供合适接口的类。

　　以上两个场景其实就是从两个角度来描述一类问题，那就是要访问的方法不在合适的接口里，一个从接口出发（被访问），一个从访问出发（主动访问）。

接口适配器使用场景：

　　（1）想要使用接口中的某个或某些方法，但是接口中有太多方法，我们要使用时必须实现接口并实现其中的所有方法，可以使用抽象类来实现接口，并不对方法进行实现（仅置空），然后我们再继承这个抽象类来通过重写想用的方法的方式来实现。这个抽象类就是适配器。