java利用接口和适配器进行完全解耦参考《thinking in java》

一.当使用父子类来实现以下东西时，其实是用了向上转型，这段代码的确简单了很多，复用性也很好，但是我们会发现Apply.process()和Processor类耦合过紧，其实apply.process()代码的复用性可以更好的。

package interfaces.classprocessor;

import java.util.*;

class Processor{
    public String name(){
        return getClass().getSimpleName();
    }
    //子类中重写次此方法时用其他类型如string  int 等
    Object process(Object input){
        return input;
    }
}

class Upcase extends Processor{
    String process(Object input){
        return ((String)input).toUpperCase();
    }
}

class Downcase extends Processor{
    String process(Object input){
        return ((String)input).toLowerCase();
    }
}

class Splitter extends Processor{
    String process(Object input){
        return Arrays.toString(((String)input).split(" "));
    }
}

public class Apply{
    public static void process(Processor p,Object s){
        System.out.println("Using Processor"+p.name());
        System.out.println(p.process(s));
    }
    public static String s="this is a Sup--Sub Coupling";
    public static void main(String[] args){
        process(new Upcase(),s);
        process(new Downcase(),s);
        process(new Splitter(),s);
    }
}

运行结果如下：

Using ProcessorUpcase
THIS IS A SUP--SUB COUPLING
Using ProcessorDowncase
this is a sup--sub coupling
Using ProcessorSplitter
[this, is, a, Sup--Sub, Coupling]

这种设计模式被称为策略设计模式，即创建一个能够根据所传递的参数对象的不同而具有不同行为的方法。

二.

　　　　看下面一段代码：

package interfaces.filters;

public class Waveform{
    private static long counter;
    private final long id=counter++;
    public String toString(){
        return "Waveform:"+id;
    }
}

package interfaces.filters;

public class Filter{
    public String name(){
        return getClass().getSimpleName();
    }
    public Waveform process(Waveform input){
        return input;
    }
}

我们发现Fileter类与Process类非常相似，他们具有相同的接口元素，但是我们却不能把Filter用于Apply.process()方法。这时候我们解决方案如下：

　　创建一个Processor接口

　　

public interface Processor{
String name();
Object process(Object input);
}

Filter实现此接口（即public class Filter implements Processor），创建一个新类StringProcessor,实现原类Processor功能，然后让Upcase DownCase Splitter继承StringProcessor，这样Filter也可以用于Apply.process()了。

三.如果Filter类是我们无法修改的，不如类库中类或者别人的jar包，此时，我们可以用适配器设计模式。适配器中的代码将接受你所拥有的接口，并产生你所需要的接口。

说白了，就是创建一个新类实现一个所拥有的接口Processor，此类中有一个Filter的实例，这样就可以实现上文中功能了，只不过是换成了一个新类。

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);
      }
}

上面三种处理方式其实是循序渐进的，都是因为大家编程中遇到了问题，或者发现代码复用性太低，然后想到的方法或者思想。