JAVA学习笔记8------适配器设计模式

适配器设计模式 
将一个类的接口转化成客户希望的另外一个接口
原有接口
适用场景：
     1、已经存在的类的接口不符合我们的需求；
     2、创建一个可以复用的类，使得该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作；
     3、在不对每一个都进行子类化以匹配它们的接口的情况下，使用一些已经存在的子类。
     其实现方式主要有两种：
     1.类的适配器模式（采用继承实现）
     2.对象适配器（采用对象组合方式实现）
// 已存在的、具有特殊功能、但不符合我们既有的标准接口的类  

class Adaptee {  
    public void specificRequest() {  
        System.out.println("被适配类具有 特殊功能...");  
    }  
}   
// 目标接口，或称为标准接口  
interface Target {  
    public void request();  
}  
// 具体目标类，只提供普通功能  
class ConcreteTarget implements Target {  
    public void request() {  
        System.out.println("普通类 具有 普通功能...");  
    }  
}   
// 适配器类，继承了被适配类，同时实现标准接口  
class Adapter extends Adaptee implements Target{  
    public void request() {  
        super.specificRequest();  
    }  
}   
// 测试类  
public class Client {  
    public static void main(String[] args) {  
        // 使用普通功能类  
        Target concreteTarget = new ConcreteTarget();  
        concreteTarget.request();  
          
        // 使用特殊功能类，即适配类  
        Target adapter = new Adapter();  
        adapter.request();  
    }  
}  

对象适配器 采用对象组合方式实现

public interface Processor{
    String name();
    Object process(Object input);
}
//用于测试的工具类
public class Apply{
    public static void process(Processp,Object s){
        print("using processor" + p.name);
        print(p.process(s));
    }
}

//正常继承
class Upcase extends StringProcessor{
    public String process(Object input){
        retrn ((String)input).toUpperCase();
    }
}
public abstract class StringProcessor implements Processor{
    public String name(){
        return getClass().getSimpleName();
    }
    public abstract String process(Object s);
    public statoc String s="ssswefwqSKDIGskdfke";

    public static void main(String[] args){
        Apply.processor(new Upcase(),s);
    }
}

Adapter模式使得由于接口不兼容不能一起工作的类可以一起工作
比如我们需需要的是

public class Waveform{
    private static long counter;
    private final long id = counter++;
    public String toString() {return "waveform"+ id}
}
public vlass Filter{
    public String name(){
        return getClass().getSimpleName();
    }
    public Waveform process (Wave input){
        return input;
    }
}

public class LowPass extends Filters{
    double cutoff;
    public LowPass(doublie cutoff){
        this.cutoff = cutoff;
    }
    public Waveform process(Waveform input){
        return input;
    }
}

如何让这两个接口共同工做
采用适配器 适配器代码接受你所拥有的接口 并产生你所需要的接口
 

class FilterAdapter implements Processor{
    Filter filter;
    public FilterAdapter(Filter filter){
        this.filter = filter;
    }
    public String name(){
        return filter.name;
    }
    public Waveform process(Object input){
        return filter.process((Waveform)input);
    }
}

//完成适配工作
public class FilterProcessor{
    public static void main(String[] args){
        Waveform w = new Waveform();
        Apply.process(new FilterAdapter(new LowPass(1.0)),w);
    }
}