java适配器模式--可能是你经常用的模式

  在本博客之前的设计模式中，已经把创建型模式的讲完了。这篇文章，我们来开始接触结构型模式，结构型模式有7种之多，不过博主我会陪你一个一个来探讨，逐个击破。

  首先适配器模式的作用在于串联不同类的方法和功能。起到一个转换，和匹配的作用。就好像我们常见的港版iPhone手机的充电器需要的转接头一样。

  适配器模式分为三种模式，类的适配器模式、对象的适配器模式、接口的适配器模式。这3种模式实现的方式各有不同，我们先来看看类的适配器模式吧。上代码：

/**
 * 插座类
 * 方法就是可以给使用的设备充电
 */
public class Plug {
    public void charging(){
        System.out.println("充电");
    }
}

  我们先创建一个插座类，类里面加上充电的方法。

/**
 * 表示充电过程的接口
 *
 */
public interface IPlugAction {
    /**
     * 充电动作
     */
    public void charging();
    /**
     * 充电条件
     * 把充电器插到插座上
     */
    public void putChargerToPlug();
}

  然后这是一个充电过程的接口。包含了之前插座类的充电的方法。

  

/**
 * 继承了Plug类和实现了IPlugAction接口的充电类
 */
public class GetCharge extends Plug implements IPlugAction {
    @Override
    public void putChargerToPlug() {
        System.out.println("把充电器插到插座上");
    }
} 

public class ChargeTest {
    public static void main(String[] args) {
        GetCharge getCharge = new GetCharge();
        getCharge.charging();
        getCharge.putChargerToPlug();
    }
}

   接着，我们创建这个类的适配器中最重要的类，GetCharge。这个类继承了Plug类和实现了充电过程的接口。最后，我们就可以发现GetCharge类通过继承类的方式来省去了其中一个方法的重写，达到了自己的充电过程。这种方式就叫做类的适配器模式。在后面的输出中，我们就可以看到完整的充电过程。

"C:\Program Files\Java\jdk1.8.0_60\bin\java"...
把充电器插到插座上
充电
Process finished with exit code 0

  那对象的适配器模式是和类的适配器模式差不多吗？答案是Yes！类的适配器是通过继承类的方式，而对象的适配器则是通过实例化一个对象来达到目的。所以我们只修改了GetCharge类，就完成了对象的适配器模式了。我们看看修改过后的GetCharge类吧

/**
 * 继承了Plug类和实现了IPlugAction接口的充电类
 */
public class GetCharge implements  IPlugAction {
    private Plug plug;

    public GetCharge(Plug plug) {
        this.plug = plug;
    }

    @Override
    public void putChargerToPlug() {
        System.out.println("把充电器插到插座上");
    }

    @Override
    public void charging() {
        plug.charging();
    }
}

  其实这也是一种变通的方法来实现充电过程了。没什么好深究的了。那最后的接口的适配器模式又是怎么样的呢？

  接口的适配器模式其实是使用了抽象类作为承接的方式。我们都知道抽象类实现接口的时候可以不实例化。而我们之前的做法也是想着不实现接口里面的所有方法。那就简单了，我们先让抽象类去实现这个充电过程的接口，然后我们再继承这个抽象类，这样我们再在继承了抽象类的GetCharge类里面实现一个充电的方法就好了。这种场景也经常发生在我们项目中，当你想要实现一个接口，但是又不想将这个接口中所有的方法都实现的情况。这时候，就可以使用接口的适配器模式，也就是弄一个抽象类来解决咯。

public abstract class AbstractCharge implements IPlugAction{

    public void charging(){}

    public void putChargerToPlug(){}
}

 创建一个抽象类来实现IPlugAction接口。

public class Charge1 extends AbstractCharge {
    public void charging(){
        System.out.println("充电1");
    }
}

public class Charge2 extends AbstractCharge {
    public void putChargerToPlug(){
        System.out.println("把充电器插到插座上");
    }
}

  再来2个类继承抽象类。

  

public class ChargeTest {
    public static void main(String[] args) {
        Charge1 charge1 = new Charge1();
        Charge2 charge2 = new Charge2();
        System.out.println(1);
        charge1.charging();
        System.out.println(2);
        charge1.putChargerToPlug();
        System.out.println(3);
        charge2.charging();
        System.out.println(4);
        charge2.putChargerToPlug();
    }
}

1
充电1
2
3
4
把充电器插到插座上

  在测试方法中，我们可以看到，继承了抽象类的子类Charge1调用的charging方法是自己重写后的。没有重写的方法调用的是抽象类的，自然就没有打印结果了。

  这就是java的适配器模式了，不复杂。学习了以后，细心看看自己的项目吧，没准也有用到的地方呢。

照旧分享一首歌的歌词

Cause baby life is tired when you're on the road.

There's lots of pretty faces that I don't know.

I could hava a million people at my show .

I'd rather come home

                                                                                                                                                         --Home