设计模式——适配器

又分为三种：

类的适配器模式：

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包装类来实现