设计原则之依赖倒置

设计原则之依赖倒置（写几个类测试一下）

1. //工具接口  
2. public interface Tools {  
3.     
4.     //工具的用途  
5.     void fix();  
6. }  

1. //扳手  
2. public class Wrench implements Tools{  
3.     
4.     @Override  
5.     public void fix(){  
6.         System.out.println("Use wrench fixing...");  
7.     }  
8. }  

1. //螺丝刀  
2. public class Pliers implements Tools{  
3.     
4.     @Override  
5.     public void fix(){  
6.         System.out.println("Use pliers fixing...");  
7.     }  
8. }  

1. //工人抽象类  
2. public abstract class Worker {  
3.     
4.     //上层模块不应该依赖低层模块的实现，而应该依赖其抽象  
5.     //所以这里不依赖具体的工具类，而是工具的接口  
6.     public abstract void work(Tools tools);  
7. }  

1. //业务员（工人品种）  
2. public class FixWorker extends Worker{  
3.     
4.     //抽象不应该依赖细节，细节应该依赖于抽象  
5.     //在抽象类里，工具不做具体的用途；而在这里重新实现它的方法  
6.     @Override  
7.     public void work(Tools tools) {  
8.     
9.     }  
10. }  

1. //测试  
2. public class Main {  
3.     public static void main(String[] args) {  
4.         Wrench w = new Wrench();  
5.         Pliers p = new Pliers();  
6.         Worker worker = new FixWorker();  
7.         worker.work(p);  
8.     }  
9. }