适配器模式

场景：现在只有一个苹果充电接口，需要一个转接器来使它成为安卓接口。

首先创建现有的苹果

public class Iphone { 
             public void getInfo(){ 
                 System.out.println("我是苹果界面");     } } 

另一个接口可以让苹果转向Android或者转Typec的两个方法

public interface IChangeType { 
              public void changeAndroid();    //转换成安卓界面     public void changeTypeC();      //转成Type c接口 } 

再创建一个适配器，真的可以实现苹果的转移Android或者转Typec的功能。我们去超市买了一个转接器。首先，我们是否把它插入苹果的界面，所以我们可以理解苹果里的一切都给了转接器。Adapter 需要继承Iphone类，这样就有了Iphone经过特殊处理，功能得到适应Android或者Typec的
功能。需要两种方法来生成两种不同的接口吗？Adapter还需要实现IChangeType接口。

public class ClassAdapter extends Iphone implements IChangeType{ 
              //转换成安卓界面     @Override     public void changeAndroid() { 
                 getInfo();    ///需要拿到苹果界面的东西，然后在它的基础上加工改造         System.out.println("加工后······");         System.out.println("我现在是安卓界面");     }      //转成Type c接口     @Override     public void changeTypeC() { 
                 getInf();				//需要拿到苹果接口的东西，接着才好再它的基础上对它进行加工改造
        System.out.println("经过加工处理······");
        System.out.println("我现在是typec接口");
    }
}

然后再创建客户端去用

public class Client { 
        
    public static void main(String[] args) { 
        

        //当我买了一个转接器
        ClassAdapter adapter = new ClassAdapter();
        //当需要一个Android接口
        adapter.changeAndroid();		//输出： 我是苹果接口
										// 经过加工处理······
										// 我现在是安卓接口
    }
}

类适配器模式需要继承被适配者，被适配的类方法会在适配器类中暴露出来（Adapter的方法里都需要调用getInfo()方法来拿到被适配的一些东西，如果多来几个适配器，那么使用成本就增加了。）

在上面的基础上稍做修改，不去继承Iphone类(使用组合替代继承)，而是持有它的实例。

public class ObjectAdapter implements IChangeType { 
        

    private Iphone iphone;

    public ObjectAdapter(Iphone iphone) { 
        
        this.iphone = iphone;
    }

    //转成安卓接口
    @Override
    public void changeAndroid() { 
        
        iphone.getInfo();
        System.out.println("经过加工处理······");
        System.out.println("我现在是安卓接口");
    }

    //转成Type c接口
    @Override
    public void changeTypeC() { 
        
        iphone.getInfo();
        System.out.println("经过加工处理······");
        System.out.println("我现在是typec接口");
    }

}

public class Client { 
        
    public static void main(String[] args) { 
        
        ClassAdapter adapter = new ClassAdapter(new Iphone());
        adapter.changeAndroid();
    }
}

当不需要全部实现接口提供的方法时，可以先设计一个抽象类实现接口，并为该接口中每个方法提供一个默认实现（理解成空方法），那么该抽象类的子类可有选择性的覆盖父类的某些方法来实现需求。

再将上面对象适配器类进行改造，把类改为抽象类。

public abstract class AbstractAdapter implements IChangeType{ 
        
    private Iphone iphone;

    public AbstractAdapter(Iphone iphone) { 
        
        this.iphone = iphone;
    }

    @Override
    public void changeAndroid() { 
        
        iphone.getInfo();
    }

    @Override
    public void changeTypeC() { 
        
		iphone.getInfo();
    }
}

实现两个方法的时候，方法体是没有任何的逻辑处理，（空方法的含义可以表示为没有进行过任何的逻辑处理），里面调用iphone.getInfo()目的是拿到原先Iphone接口它本身的东西，有了原材料才可以对它进行加工处理，只不过处理过程不在这里实现。

public class Client { 
        
    public static void main(String[] args) { 
        

        AbstractAdapter abstractAdapter = new AbstractAdapter(new Iphone()) { 
        
            //只需要覆盖需要用的接口方法，
            //如果此时只需要Android接口，那么

            @Override
            public void changeAndroid() { 
        
                //这里写具体实现
                super.changeAndroid();
                System.out.println("经过加工处理······");
                System.out.println("我现在是安卓接口");
            }
        };

        abstractAdapter.changeAndroid();
    }
}

像这样的话真正有用的功能是苹果转安卓，虽然可以通过abstractAdapter.changeTypeC();语句调用转Typec功能，但是我们并没有真正写了此功能的逻辑处理，所以即使用了也没有效果。

注意，需要在AbstractAdapter抽象类上重写所有的接口方法，如果不实现，那么会在客户端类Client被迫强制实现所有方法，也就与我们的初衷不一样。