设计模式-适配器模式

http://zz563143188.iteye.com/blog/1847029

我将讲下7种结构型模式：适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式。其中对象的适配器模式是各种模式的起源，我们看下面的图：




适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。

类的适配器模式，先看类图：

核心思想就是：有一个Source类，拥有一个方法，待适配，目标接口时Targetable，通过Adapter类，将Source的功能扩展到Targetable里，看代码：
两个基础类：接口+类 --> 新的适配器

package com.pandy.structural.adapter;
public class Source {
    public void method1() {
        System.out.println("某个类原先存在的第一个方法");
    }
}

package com.pandy.structural.adapter;
public interface Targetable {
    /* 与原类中的方法相同 */
    public void method1();

    /* 新类的方法 */
    public void method2();
}

类的适配：Adapter类继承Source类，实现Targetable接口

package com.pandy.structural.adapter.clazz;

import com.pandy.structural.adapter.Source;
import com.pandy.structural.adapter.Targetable;

/**
 * Created by pandy on 14-7-17.
 * 使用适配，达到实现类能够新增新的方法的同时，又能用已存在的方法
 *
 * 核心思想就是：有一个Source类，拥有一个方法，待适配，目标接口时Targetable，
 * 通过Adapter类，将Source的功能扩展到Targetable里
 */
public class Adapter extends Source implements Targetable {

    @Override
    public void method2() {
        System.out.println("新实现列要做的第二个方法");
    }
}

测试：

package com.pandy.structural.adapter.clazz;

import com.pandy.structural.adapter.Targetable;
public class AdapterTest {
    public static void main(String[] args) {
        Targetable target = new Adapter();
        target.method1();
        target.method2();
    }
}

输出：
某个类原先存在的第一个方法
新实现列要做的第二个方法



对象的适配器模式：，接口--->已存在的实现类封装到适配器里面
基本思路和类的适配器模式相同，只是将Adapter类作修改，这次不继承Source类，而是持有Source类的实例，以达到解决兼容性的问题。看图：

只需要修改Adapter类的源码即可：

package com.pandy.structural.adapter.wrapper;

import com.pandy.structural.adapter.Source;
import com.pandy.structural.adapter.Targetable;

/**
 * Created by pandy on 14-7-17.
 * 采用封装的方式
 * 只是将Adapter类作修改，这次不继承Source类，而是持有Source类的实例，以达到解决兼容性的问题。
 */
public class Wrapper implements Targetable {

    private Source source;

    public Wrapper(Source source){
        super();
        this.source = source;
    }
    @Override
    public void method2() {
        System.out.println("新实现列要做的第二个方法");
    }

    @Override
    public void method1() {
        source.method1();
    }
}

测试：

package com.pandy.structural.adapter.wrapper;

import com.pandy.structural.adapter.Source;
import com.pandy.structural.adapter.Targetable;
public class AdapterTest {
    public static void main(String[] args) {
        Source source = new Source();
        Targetable target = new Wrapper(source);
        target.method1();
        target.method2();
    }
}

接口的适配器模式，接口-抽象-不同的实现类->不同的业务需求
接口的适配器是这样的：有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。看一下类图：
这个很好理解，在实际开发中，我们也常会遇到这种接口中定义了太多的方法，以致于有时我们在一些实现类中并不是都需要。看代码：
接口：

package com.pandy.structural.adapter.interf;

/**
 * 统一的接口
 */
public interface Sourceable {
    public void method1();
    public void method2();
}

抽象：

package com.pandy.structural.adapter.interf;

/**
 * 默认实现方法的抽象类
 */
public abstract class AbcWrapper implements Sourceable{
    public void method1(){
        System.out.println("默认方法：抽象类实现的第一个方法");
    }
    public void method2(){
        System.out.println("默认方法：抽象类实现的第二个方法");
    }
}

第一个需求的实现类：

package com.pandy.structural.adapter.interf;

/**
 * 第一个需求的实现类，继承抽象类
 */
public class SourceSub1 extends AbcWrapper {
    public void method1() {
        System.out.println("----------->目标方法：第一个继承抽象的类，只实现第一个方法");
    }
}

第二个需求的实现类：

package com.pandy.structural.adapter.interf;

/**
 * 第二个需求的实现类，继承抽象类
 */
public class SourceSub2 extends AbcWrapper {
    public void method2() {
        System.out.println("----------->目标方法：第二个继承抽象的类，只实现另外的一个方法");
    }
}

测试：

package com.pandy.structural.adapter.interf;

/**
 * 自己要做自己想做的方法
 */
public class WrapperTest {
    public static void main(String[] args) {
        System.out.println("分开使用");
        System.out.println("第一个:");
        Sourceable source1 = new SourceSub1();
        source1.method1();
        source1.method2();

        System.out.println("第二个:");
        Sourceable source2 = new SourceSub2();
        source2.method1();
        source2.method2();
    }
}

分开使用
第一个:
----------->目标方法：第一个继承抽象的类，只实现第一个方法
默认方法：抽象类实现的第二个方法
第二个:
默认方法：抽象类实现的第一个方法
----------->目标方法：第二个继承抽象的类，只实现另外的一个方法