接口 的使用 到底 有什么 益处？完全 解耦（ decoupling）

package interfaces.classprocessor;

import java.util.Arrays;

public class Apply {
	public static void process(Processor p,Object i){
		System.out.println("using processor"+p.name());
		System.out.println(p.process(i));
	}
	public static void main(String[] args) {
		String s="i love you , lie or die";
		process(new Upercase(),s);
		process(new Splitter(),s);
		process(new Lowercase(),s);
		
	}

}
class Processor{
	public String name(){
		return getClass().getSimpleName();
	}
	 Object process(Object input){
		return input;
	}
}
class Upercase extends Processor{
	String process(Object input){
		return ((String)input).toUpperCase();
	}
	
}
class Splitter extends Processor{
	String process(Object input){
		return Arrays.toString(((String)input).split(" "));
	}
}
class Lowercase extends Processor{
	String process(Object input){
		return ((String)input).toLowerCase();
	}
	
}

如以上代码 ，processor 是一个基类，用来创建不同类型的Processor.让Apply.process()接受 processor 类型，以及object 类型，打印结果。现在 我们遇到了一个 类filter，它与Processor具有相同的接口。同样适用于 Apply.process，但是 他并非 继承 processor,所以不能将filter用于 Apply.process()方法。这里主要是由于 Processor 和Apply.process()耦合 过紧。这使得 代码复用 被禁止。问题来了如果 Processor是一个接口，那么这些限制会变得松动。

package interfacesProcessor;

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

public class Apply {
	public	static  void process(Processor p,Object i){
		System.out.println(p.name());
		System.out.println(p.process(i));
	}
}
package interfacesProcessor;

import java.util.Arrays;

public abstract class StringProcessor implements Processor{
	public static String s="i love you lie or die";
	public String name(){
		return getClass().getSimpleName();
	}
	public abstract String  process(Object input);
	public static void main(String[] args){
		Apply.process(new UperCase(), s);
		Apply.process(new LowerCase(), s);
		Apply.process(new Splitter(), s);
	}
}
	class UperCase extends StringProcessor{

		@Override
		public String process(Object input) {
			
			return input.toString().toUpperCase();
		}
	}
	class LowerCase extends StringProcessor{

		@Override
		public String process(Object input) {
			return input.toString().toLowerCase();
		}
		
	}
	class Splitter extends StringProcessor{

		@Override
		public String process(Object input) {
			return Arrays.toString(((String)input).split(" "));
		}
		
	}

用以下代码进行复用：

package interfaces.filter;

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

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

}
package interfaces.filter;

public class LowPass extends Filter {
	double cutOff;
	public LowPass(double cutOff){
		this.cutOff=cutOff;
	}
	public Waveform process(Waveform input){
		return input;
	}
}
package interfaces.filter;

public class Waveform {
	private static long count;
	private final long id=count++;
	public String toString(){
		return "waveform"+id;
	}
}
package interfacesProcessor;

import interfaces.filter.Filter;
import interfaces.filter.HighPass;
import interfaces.filter.LowPass;
import interfaces.filter.Waveform;

public class FilterAdapter implements Processor {
	Filter filter;
	 public FilterAdapter(Filter filter) {
		this.filter=filter;
	}
	@Override
	public String name() {
		// TODO Auto-generated method stub
		return filter.name();
	}

	

	public static void main(String[] args){
		Waveform w=new Waveform();
		Apply.process(new FilterAdapter(new LowPass(3.0)), w);
		Apply.process(new FilterAdapter(new HighPass(2.0)), w);
	}
	@Override
	public Waveform process(Object input) {
		
		return filter.process((Waveform)input);
	}

}

总结：接口可以使我们 编写 复用性很好的代码。但是 是不是 应该总是 选择 接口 而不是具体的类？留给 你们去思考