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<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()方法

 

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