目标是把Source的功能拓展到Targetable中去。需要一个适配器Adapter完成。

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

public interface Targetable {
	void method1();
	void method2();
}

public class Adapter extends Source implements Targetable {  
  
    @Override  
    public void method2() {  
        System.out.println("Adapter method2");  
    }  
}  

测试：

public class Test {
	public static void main(String[] args) {
		try {
			Test test = new Test();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public Test() {
		Targetable target = new Adapter();  
        target.method1();  
        target.method2();  
	}
}

或者有时候会把Source的对象引用埋入到一个适配器（wrap），适配器模式的变形：

public class Wrapper implements Targetable {
	private Source source;

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

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

	@Override
	public void method2() {
		System.out.println("Wrapper method2");
	}
}

	public Test() {
		Source source = new Source();
		Targetable target = new Wrapper(source);
		target.method1();
		target.method2();
	}

下面是接口的适配器模式。

有时候，我们使用或者感兴趣的是一个接口类中的某一两个函数，而不是全部，但是如果我们实现这个接口类，则必须实现全部的函数，显然这比较繁琐，可以简化。

public interface Sourceable {
	void method1();
	void method2();
}

public abstract class Wrapper implements Sourceable {
	@Override
	public void method1() {
	}

	@Override
	public void method2() {
	}
}

public class Source1 extends Wrapper{
	@Override
	public void method1(){  
        System.out.println("Source1 method1");  
    }  
}

public class Source2 extends Wrapper{
	@Override
	public void method2() {
		System.out.println("Source2 method2");
	}
}

	public Test() {
		Sourceable source1 = new Source1();
		Sourceable source2 = new Source2();

		source1.method1();
		source1.method2();

		source2.method1();
		source2.method2();
	}

输出：

Source1 method1
Source2 method2