##适配器模式 分为：
- 类的适配器模式
- 对象的适配器模式
- 接口的适配器模式
类的适配器模式：
public class Soure{
public void method1(){
System.out.println("this is original method!");
}
}
定义一个接口，其中接口中的一个方法和Soure类的方法一样
public interface ITargettable{
与原类中的方法相同
public void method1();
新类的方法
public void method2();
}
然后我们在定义一个aptuder的类继承了source
public class Adapter extends Source implements Targetable {
@Override
public void method2() {
System.out.println("this is the targetable method!");
}
}
测试代码
public class AdapterTest {
这样一来就有了Source类的方法，和自己的方法了
public static void main(String[] args) {
Targetable target = new Adapter();
target.method1();
target.method2();
}
}
##对象的适配器模式 其实和类的适配器模式差别就在，这里不需要继承Source，而只需要将Source类当构造传递进来就行了
public class Wrapper implements Targetable {
private Source source;
将source类传递进来
public Wrapper(Source source){
super();
this.source = source;
}
@Override
public void method2() {
System.out.println("this is the targetable method!");
}
这样就行执行
@Overridesource的方法了
public void method1() {
source.method1();
}
}
测试类
public class AdapterTest {
public static void main(String[] args) {
Source source = new Source();
Targetable target = new Wrapper(source);
target.method1();
target.method2();
}
}
##接口适配器模式 接口适配器模式主要是用于解决，有时候我们写一个接口的时候，里面有很多我们需要实现的方法，如果我们直接去实现就会造成很多没有用的方法，造成浪费，而我们如果直接中间写一个抽象的继承类，我们不和原始的接口打交道，我们就和这个抽象类打交道，这样就可以，我们就只能只需要有用的方法实现就行了。
public interface Sourceable {
public void method1();
public void method2();
}
中间的类
public abstract class Wrapper2 implements Sourceable{
public void method1(){}
public void method2(){}
}
我们不和原始的接口打交道
public class SourceSub1 extends Wrapper2 {
public void method1(){
System.out.println("the sourceable interface's first Sub1!");
}
}
测试代码
public class WrapperTest {
public static void main(String[] args) {
Sourceable source1 = new SourceSub1();
source1.method1();
source1.method2();
}
}
##总结 类的适配器模式：当希望将一个类转换成满足另一个新接口的类时，可以使用类的适配器模式，创建一个新类，继承原有的类，实现新的接口即可。
对象的适配器模式：当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Wrapper类，持有原类的一个实例，在Wrapper类的方法中，调用实例的方法就行。
接口的适配器模式：当不希望实现一个接口中所有的方法时，可以创建一个抽象类Wrapper，实现所有方法，我们写别的类的时候，继承抽象类即可。
