java-完全解耦

完全解耦：降低代码的限制性，是同一代码能够用到更多的程序中

 1 package interfaces.interfaceprocessor;
 2 import static net.mindview.util.Print.print;
 3 
 4 interface Processor {
 5     String name();
 6     Object process(Object input);
 7 }
 8 public class Apply{
 9     public static void process(Processor p, Object s) {
10         print("Using Processor "+ p.name());
11         print(p.process(s));
12     }
13 }

上述方法代码Apply.process（）打印出进程的名字和进程的过程。只要符合此要求的都可以利用这个代码

 1 package interfaces.interfaceprocessor;
 2 import static net.mindview.util.Print.*;
 3 
 4 public abstract class StringProcessor implements Processor {
 5     public String name() {
 6         return getClass().getSimpleName();
 7     }
 8     public abstract String process(Object input);
 9     public static String s = "if she weights the same as duck";
10     public static void main(String[] args) {
11         Apply.process(new Upcase(), s);
12     }
13 }
14 class Upcase extends StringProcessor{
15     public String process(Object input) {
16         return ((String)input).toUpperCase();
17     }
18 }

 

 

在利用Apply.process()方法时，需要一个适配器方法，本例中StringProcessor为字符串适配器，是接口Processor的实现

由于Apply.process()方法接收的参数为Proessor类型，因此必须要一个Processor接口的实现，我们把它称作适配器，该适配器也是接口Processor的实现，这样该适配器的类型也是Processor

这样就可以把该适配器的内容传到Apply.process()方法中（Apply.process(new Upacase(), s）)

package interfaces.interfaceprocessor;

class ChacaterPairSwapper{
    public String swap(String s) {
        StringBuilder sb = new StringBuilder(s);
        for(int i=0; i) {
            char c1 = sb.charAt(i);
            char c2 = sb.charAt(i+1);
            sb.setCharAt(i, c2);
            sb.setCharAt(i+1,c1);
        }
        return sb.toString();
    }
}
class SwapAdapator implements Processor{
    ChacaterPairSwapper cps = new ChacaterPairSwapper();
    public String name() {
        return ChacaterPairSwapper.class.getSimpleName();
    }
    public Object process(Object input) {
        return cps.swap((String)input);
    }
}
public class E11_Swap {
    public static void main(String[] args) {
        Apply.process(new SwapAdapator(), "1234");
    }
}

本例也是利用了Apply.process()方法，首先写一个交换一对字符的方法，再写了一个此方法的适配器，使其适配Apply.process()方法

 

这就是完全解耦，通过适配器，使得更多的代码能够用到同一方法