设计模式——适配器

又分为三种：

类的适配器模式：

package designpattern.structure.adapter.classadapter;

public interface ITarget {

public void method1();

public void method2();
}

package designpattern.structure.adapter.classadapter;

public class Source {

public void method1() {
System.out.println("Source.method1()");
}

}

package designpattern.structure.adapter.classadapter;

public class SourceAdapter extends Source implements ITarget {

public void method2() {
System.out.println("Adapter.method2()");
}

}

package designpattern.structure.adapter.classadapter;

/*
*
* 类的适配模式：
* 即想让没有实现ITarget接口的Source类为 ITarget 工作
* ———— 具体来说是想让ITarget在适当时候调用Source ， 别的时候，则不需要（别的时候通过适配来工作）
*
*/
public class Client {

/**
* @param args
*/
public static void main(String[] args) {

ITarget target = new SourceAdapter();
target.method1();
target.method2();
}

}

对象的适配器模式：

package designpattern.structure.adapter.objectadapter;

public interface ITarget {

public void method1();

public void method2();
}

package designpattern.structure.adapter.objectadapter;

public class Source {

public void method1() {
System.out.println("Source.method1()");
}

}

package designpattern.structure.adapter.objectadapter;
public class Wrapper implements ITarget {

private Source source;

public Wrapper(Source source){
super();
this.source = source;
}

public void method2() {
System.out.println("this is the wrapped method!");
}

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

package designpattern.structure.adapter.objectadapter;

/*
*
* 类的适配模式：
* 即想让没有实现ITarget接口的Source类为 ITarget 工作
* ———— 具体来说是想让ITarget在适当时候调用Source ， 别的时候，则不需要（别的时候通过适配来工作）
*
*/
public class Client {

/**
* @param args
*/
public static void main(String[] args) {

ITarget target = new Wrapper(new Source());
target.method1();
target.method2();
}

}

接口的适配器模式：

package designpattern.structure.adapter.interfaceadapter;

public interface ITarget {

public void method1();

public void method2();
}

package designpattern.structure.adapter.interfaceadapter;
public abstract class Wrapper implements ITarget {

public void method2() {  ----- 钩子方法实现！！ 一般表明暂时不想去实现
}

public void method1() {
}
}

package designpattern.structure.adapter.interfaceadapter;

public class Sub1 extends Wrapper {

public void method1() {
System.out.println("Sub1.method1()");
}

}
package designpattern.structure.adapter.interfaceadapter;

public class Sub2 extends Wrapper {

public void method2() {
System.out.println("Sub2.method2()");
}

}

package designpattern.structure.adapter.interfaceadapter;

/*
*
* 接口的适配模式：
*
*/
public class Client {

/**
* @param args
*/
public static void main(String[] args) {

ITarget target = new Sub1();
target.method1();
target.method2();

target = new Sub2();
target.method1();
target.method2();

}

}

总结：

其实，它主要是为了使不兼容的两个（多个？）接口/类一起工作。

——一起工作的意思是说，调用A接口方法m1的时候，我想实际调用B类的m1实现——B类必须有m1(就是说A接口的其中一个方法)，否则也无需适配，直接重新实现A接口就行了？不是吗？

—— 接口可以有很多方法，但是目标类必须有它其中一个实现，—— 这样才能适配啊！！

—— 可以通过添加Adapter、Wrapper包装类来实现