java-完全解耦

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

package interfaces.interfaceprocessor;
import static net.mindview.util.Print.print;

interface Processor {
    String name();
    Object process(Object input);
}
public class Apply{
    public static void process(Processor p, Object s) {
        print("Using Processor "+ p.name());
        print(p.process(s));
    }
}

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

package interfaces.interfaceprocessor;
import static net.mindview.util.Print.*;

public abstract class StringProcessor implements Processor {
    public String name() {
        return getClass().getSimpleName();
    }
    public abstract String process(Object input);
    public static String s = "if she weights the same as duck";
    public static void main(String[] args) {
        Apply.process(new Upcase(), s);
    }
}
class Upcase extends StringProcessor{
    public String process(Object input) {
        return ((String)input).toUpperCase();
    }
}

 

 

在利用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<sb.length()-1; i=i+2) {
            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()方法

 

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