策略设计模式，适配器设计模式，以及完全解耦

在think in Java第四版中文版P175接口这一章中有这样一段代码：

package WaveFilterPrev;

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

package WaveFilterPrev;

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

<pre class="java" name="code">package WaveFilterPrev;

public class LowPass extends Filter {
  double cutoff;
  public LowPass(double cutoff) { this.cutoff = cutoff; }
  public Waveform process(Waveform input) {
    return input; // Dummy processing
  }
} ///:~

package WaveFilterPrev;

public class HighPass extends Filter {
  double cutoff;
  public HighPass(double cutoff) { this.cutoff = cutoff; }
  public Waveform process(Waveform input) { return input; }
} ///:~

package WaveFilterPrev;

public class BandPass extends Filter {
  double lowCutoff, highCutoff;
  public BandPass(double lowCut, double highCut) {
    lowCutoff = lowCut;
    highCutoff = highCut;
  }
  public Waveform process(Waveform input) { return input; }
} ///:~

当我们需要从创建一个能够根据传递参数对象不同而具有不同的方法，被称为策略设计模式。

在策略设计模式中我们需要一个Apply的类。在Apply类中有一个Apply.process(Processor p,Object o)的方法。此方法能够接受任何类型的Processor，并将其应用到一个Object对象。显然该Processor类拥有同一个接口。

好了，回到代码上,Filter,Processor拥有相同的接口元素，但并非继承Processor。因此不能将Filter用于ApplyProcessor().这里主要是Apply.process()与processor之间耦合过紧，超出了所需要的程度。

耦合性，网文解释：耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决与模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个准则就是高内聚低耦合。

如果Processor是一个接口，那么这些限制就会变得松动。使得你可以复用Apply.processor()的代码。

先修改程序如下：

package WaveformProcessor;

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

}
package WaveformProcessor;

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


package WaveformProcessor;

public class FilterAdapter implements Processor{
    Filter filter;

    FilterAdapter(Filter f){
    	this.filter = f;
    }
	
	public String name() {
		return filter.name();
	}

	@Override
	public Object process(Object input) {
		return filter.process((Waveform)input);
	}
	

}

package WaveformProcessor;

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

}

package WaveformProcessor;

public class HighPass extends Filter{
    double cutOff;
    HighPass(double co){
    	cutOff =  co;
    }
    public Waveform process(Waveform input){
    	input.setHighCut(cutOff);
		return input;
	}
	
}

package WaveformProcessor;

public class LowPass extends Filter {
	double cutOff;
	LowPass(double co){
		cutOff = co;
	}
	public Waveform process(Waveform input){
		input.setLowCut(cutOff);
		return input;
	}

	
}

package WaveformProcessor;

public class BandPass extends Filter {
      double highCutOff;
      double lowCutOff;
      BandPass(double lo,double ho){
    	  highCutOff = ho;
    	  lowCutOff = lo;
      }
	
      public Waveform process(Waveform input){
    	  input.setLowCut(lowCutOff);;
    	  input.setHighCut(highCutOff);;
  		return input;
  	}
}

package WaveformProcessor;

public class BandPass extends Filter {
      double highCutOff;
      double lowCutOff;
      BandPass(double lo,double ho){
    	  highCutOff = ho;
    	  lowCutOff = lo;
      }
	
      public Waveform process(Waveform input){
    	  input.setLowCut(lowCutOff);;
    	  input.setHighCut(highCutOff);;
  		return input;
  	}
}

package WaveformProcessor;

public class Waveform {
	private double lowCut =-100;//代表无限低的频率
	private double highCut = 100;//代表无限高的频率
	private static int counter;
	private final long id =counter++;
	public String toString(){
		return "Waveform "+id+" myLowCut is "+lowCut+" My HighCut is "+highCut;
	}
	
	public void setLowCut(double lowPass){
		this.lowCut = lowPass;
	}
	
	public void setHighCut(double hiPass){
		this.highCut = hiPass;
	}
	
	

}

package WaveformProcessor;

public class FilterProcessor {
	public static void main(String args[]){
		Apply.applyProcessor(new FilterAdapter(new LowPass(-10.0)), new Waveform());
		Apply.applyProcessor(new FilterAdapter(new HighPass(10.0)), new Waveform());
		Apply.applyProcessor(new FilterAdapter(new BandPass(-10.0,10.0)),  new Waveform());
	}

}

output：

WaveformProcessor.LowPass
Waveform 0 myLowCut is -10.0 My HighCut is 100.0
WaveformProcessor.HighPass
Waveform 1 myLowCut is -100.0 My HighCut is 10.0
WaveformProcessor.BandPass
Waveform 2 myLowCut is -10.0 My HighCut is 10.0

在实际编程中你会碰到你无法修改你要是用的类，这是你可以使用适配器设计模式：在适配器中接收你拥有的接口，产生你需要的接口如上面代码中的FilterAdapter。在filterAdapter中接收了所拥有的接口Filter，然后生成了我们想要Processor接口对象。当然了，在FilterAdapter中用到了代理。

  将接口从具体实现中解耦，使得接口可以拥有各种不同的具体实现。因此代码也变得更有复用性。

参考资料：《Java编程思想》第四版