适配器模式，浅谈什么是适配器模式，简单分析

适配器模式

说到适配器模式很多人第一反应就是android中的listview的adapter,哈哈，其实也有那么点意思，适配器模式我们天天见却不一定能够发现：

什么是适配器模式？？？

一、作用

适配器模式（Adapter）：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

二、适用场景

1. 业务的接口与工作的类不兼容，（比如：类中缺少实现接口的某些方法）但又需要两者一起工作

2. 在现有接口和类的基础上为新的业务需求提供接口

概念：适配者模式是也是Android中应用很广泛的设计模式，如我们常见用 BaseAdpter, ArrayAdapter, CursorAdapter,就是用的适配者模式；

分类：

适配器模式分三种类型：

1，类适配模式：

Usb接口

1. public interface Usb {  
2.   
3.     void store();  
4.   
5.     void takeAlong();  
6. }  

public interface Usb {

    void store();

    void takeAlong();
}

Phone类

1. public class Phone {  
2.   
3.     public void call() {  
4.         System.out.println("Phone call");  
5.     }  
6.   
7.     public void sms() {  
8.         System.out.println("Phone sms");  
9.     }  
10.   
11.     public void takeAlong() {  
12.         System.out.println("Phone takeAlong");  
13.     }  
14. }  

public class Phone {

    public void call() {
        System.out.println("Phone call");
    }

    public void sms() {
        System.out.println("Phone sms");
    }

    public void takeAlong() {
        System.out.println("Phone takeAlong");
    }
}

适配 Xiaomi 类

/** 

 * 类的适配器模式 

 * phone + Usb 

 * 将Phone的功能扩展到Usb里 

 * @author xuzhaohu 

 *  

 */  

public class Xiaomi extends Phone implements Usb {  

  

    @Override  

    public void store() {  

        // TODO Auto-generated method stub  

        System.out.println("store implements usb");  

    }  

  

}  

/**
 * 类的适配器模式
 * phone + Usb
 * 将Phone的功能扩展到Usb里
 * @author xuzhaohu
 * 
 */
public class Xiaomi extends Phone implements Usb {

    @Override
    public void store() {
        // TODO Auto-generated method stub
        System.out.println("store implements usb");
    }

}

适配完后使用

Xiaomi mi1 = new Xiaomi();  

mi1.takeAlong();  

mi1.store();  

        Xiaomi mi1 = new Xiaomi();
        mi1.takeAlong();
        mi1.store();

输出：

Phone takeAlong
store implements usb

这样新的业务需求就可以通过适配的 Xiaomi类去满足了。是不是觉得很简单呢！！:)  有没有其他的方式去实现同样的功能呢？当然有，就是下面要讲的对象适配模式。

2，对象适配模式

/**
 * 对象的适配器模式
 *
 * @author xuzhaohu
 *
 */
public class XiaomiWrapper implements Usb {

    /**
     * 1.创建一个Wrapper类，持有原类的一个实例，
     * 2.在Wrapper类的方法中，调用实例的方法就行
     */
    private Phone phone;

    public XiaomiWrapper(Phone phone) {

        this.phone = phone;
    }

    @Override
    public void store() {
        // TODO Auto-generated method stub
        System.out.println("store implements usb");

    }

    @Override
    public void takeAlong() {
        // TODO Auto-generated method stub
        phone.takeAlong();
    }

}

调用方式：

1. XiaomiWrapper mi2 = new XiaomiWrapper(new Phone());  
2. mi2.takeAlong();  
3. mi2.store();  

（3）接口适配模式

1. /** 
2.  * 接口的适配器模式 
3.  * 1.借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法 
4.  * 2.继承类可以选择性的实现接口中的方法 
5.  *  
6.  * @author xuzhaohu 
7.  *  
8.  */  
9. public abstract class AbsPhone implements Usb {  
10.   
11.     public void store() {  
12.         System.out.println("AbsPhone implements usb's store methond");  
13.     }  
14.   
15.     public void takeAlong() {  
16.         System.out.println("AbsPhone implements usb's takeAlong methond");  
17.     }  
18. }  
19. 

20. /**
     * 接口的适配器模式
     * 1.借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法
     * 2.继承类可以选择性的实现接口中的方法
     * 
     * @author xuzhaohu
     * 
     */
    public abstract class AbsPhone implements Usb {
    
        public void store() {
            System.out.println("AbsPhone implements usb's store methond");
        }
    
        public void takeAlong() {
            System.out.println("AbsPhone implements usb's takeAlong methond");
        }
    }

适配类只跟AbsPhone打交道，根本不需要关心接口的行为，只显示自己所要关注的。

如Phone1适配只需要store()行为

1. public class Phone1 extends AbsPhone {  
2.   
3.     public void call() {  
4.         System.out.println("Phone1 call");  
5.     }  
6.       
7.     public void sms() {  
8.         System.out.println("Phone1 sms");  
9.     }  
10.   
11.     public void store() {  
12.         System.out.println("Phone1 need usb's store methond");  
13.     }  
14.   
15. }  

public class Phone1 extends AbsPhone {

    public void call() {
        System.out.println("Phone1 call");
    }
    
    public void sms() {
        System.out.println("Phone1 sms");
    }

    public void store() {
        System.out.println("Phone1 need usb's store methond");
    }

}

Phone2适配只需要takeAlong()行为

1. public class Phone2 extends AbsPhone {  
2.   
3.     public void call() {  
4.         System.out.println("Phone2 call");  
5.     }  
6.   
7.     public void sms() {  
8.         System.out.println("Phone2 sms");  
9.     }  
10.   
11.     public void takeAlong() {  
12.         System.out.println("Phone2 need usb's takeAlong methond");  
13.     }  
14.   
15. }  

public class Phone2 extends AbsPhone {

    public void call() {
        System.out.println("Phone2 call");
    }

    public void sms() {
        System.out.println("Phone2 sms");
    }

    public void takeAlong() {
        System.out.println("Phone2 need usb's takeAlong methond");
    }

}

实例化调用

1. Phone1 p1 = new Phone1();  
2. Phone2 p2 = new Phone2();  
3. p1.store();  
4. p2.takeAlong();  

        Phone1 p1 = new Phone1();
        Phone2 p2 = new Phone2();
        p1.store();
        p2.takeAlong();

输出：

Phone1 need usb's store methond
Phone2 need usb's takeAlong methond

来一次完整的调用

1. Phone1 p1 = new Phone1();  
2. Phone2 p2 = new Phone2();  
3. p1.store();  
4. p1.takeAlong();  
5. p2.takeAlong();  
6. p2.store();  

        Phone1 p1 = new Phone1();
        Phone2 p2 = new Phone2();
        p1.store();
        p1.takeAlong();
        p2.takeAlong();
        p2.store();

输出：

Phone1 need usb's store methond
AbsPhone implements usb's takeAlong methond
Phone2 need usb's takeAlong methond
AbsPhone implements usb's store methond

这样很清晰的知道适配的什么方法了。