六种设计原则

 

单一职责原则

 

不要存在多于一个导致类变更的原因。通俗的说，即一个类只负责一项职责。 
问题由来：类T负责两个不同的职责：职责P1，职责P2。当由于职责P1需求发生改变而需要修改类T时，有可能会导致原本运行正常的职责P2功能发生故障。
一句话总结：不能为图代码量少，把牛头马嘴一起往一个类塞
 

里氏替换原则

1.子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。

2.子类中可以增加自己特有的方法。

3.当子类的方法重载父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。

4.当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。

一句话总结：尽量不要重写父类的已经实现了的方法，可以用接口等其他方法绕过

依赖倒置原则

高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。

这里用一个列子来说明：

 

[java] view plain copy
 
  1. import java.util.LinkedList;  
  2. import java.util.Queue;  
  3.   
  4.   
  5.   
  6. interface IEAT  
  7. {  
  8.     public void eat();//抽象吃这个动作  
  9. }  
  10. class EatApple implements IEAT  
  11. {  
  12.   
  13.     @Override  
  14.     public void eat()   
  15.     {  
  16.         //这里是吃苹果  
  17.         System.out.print("eat a apple");  
  18.           
  19.     }  
  20. }  
  21. class EatWater implements IEAT  
  22. {  
  23.   
  24.     @Override  
  25.     public void eat() {  
  26.         // 这里是吃水  
  27.         System.out.print("dringk water");  
  28.           
  29.     }  
  30.       
  31. }  
  32. public class Human  
  33. {  
  34.     public void dosomething(IEAT ieat)//我爱吃东西，吃什么呢，看传入什么  
  35.     {  
  36.         ieat.eat();  
  37.     }  
  38.     /* 
  39.     public void dosomething(String food)//我爱吃东西，吃什么呢，看传入什么 
  40.     { 
  41.         if(food.equals("apple")) 
  42.         { 
  43.             //吃苹果 
  44.         } 
  45.         if(food.equals("water")) 
  46.         { 
  47.             //喝水 
  48.         } 
  49.     } 
  50.     */  
  51.     public static void main(String[] args)  
  52.     {  
  53.         Human human=new Human();  
  54.         /* 
  55.         human.dosomething("apple"); 
  56.         human.dosomething("water"); 
  57.          */  
  58.         //给你吃个苹果  
  59.         human.dosomething(new EatApple());  
  60.         //再给你喝点水  
  61.         human.dosomething(new EatWater());  
  62.     }  
  63. }  


其中注释的就是我们常用的方法。这种方法非常不适于扩展，因为如果要吃香蕉，吃西瓜，又要在dosomething里面写一堆判断。写着写着就混了。

 

因此一句话总结：多用抽象的接口来描述相同的动作，降低实现这个动作的人和物之间的耦合度

 

接口隔离原则

 

 

客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。 
问题由来：类A通过接口I依赖类B，类C通过接口I依赖类D，如果接口I对于类A和类B来说不是最小接口，则类B和类D必须去实现他们不需要的方法。
一句话总结：就好比鱼和人两个类，鱼是游泳和腮呼吸两个动作，人是走路和吃饭两个动作，这些动作不能写在一个接口里面，把这四个动作都包含了。要拆成专门对鱼和人的两个接口才行。

 

 

迪米特法则

 

迪米特法则又叫最少知道原则，最早是在1987年由美国Northeastern University的Ian Holland提出。通俗的来讲，就是一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类来说，无论逻辑多么复杂，都尽量地的将逻辑封装在类的内部，对外除了提供的public方法，不对外泄漏任何信息。

这个有点不好记，总结就是：father1<-child1,father2<-child2,father1和father2是的手下， father1尽量通过father2去访问child2, 不要直接在类里面访问child2. 下属怎么能随便去领导家的孩子呢，小心别人说你拐卖 

 

开闭原则

 

这个没啥好说的：尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。

六种设计原则

 

单一职责原则

 

不要存在多于一个导致类变更的原因。通俗的说，即一个类只负责一项职责。 
问题由来：类T负责两个不同的职责：职责P1，职责P2。当由于职责P1需求发生改变而需要修改类T时，有可能会导致原本运行正常的职责P2功能发生故障。
一句话总结：不能为图代码量少，把牛头马嘴一起往一个类塞
 

里氏替换原则

1.子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。

2.子类中可以增加自己特有的方法。

3.当子类的方法重载父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。

4.当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。

一句话总结：尽量不要重写父类的已经实现了的方法，可以用接口等其他方法绕过

依赖倒置原则

高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。

这里用一个列子来说明：

 

[java] view plain copy
 
  1. import java.util.LinkedList;  
  2. import java.util.Queue;  
  3.   
  4.   
  5.   
  6. interface IEAT  
  7. {  
  8.     public void eat();//抽象吃这个动作  
  9. }  
  10. class EatApple implements IEAT  
  11. {  
  12.   
  13.     @Override  
  14.     public void eat()   
  15.     {  
  16.         //这里是吃苹果  
  17.         System.out.print("eat a apple");  
  18.           
  19.     }  
  20. }  
  21. class EatWater implements IEAT  
  22. {  
  23.   
  24.     @Override  
  25.     public void eat() {  
  26.         // 这里是吃水  
  27.         System.out.print("dringk water");  
  28.           
  29.     }  
  30.       
  31. }  
  32. public class Human  
  33. {  
  34.     public void dosomething(IEAT ieat)//我爱吃东西，吃什么呢，看传入什么  
  35.     {  
  36.         ieat.eat();  
  37.     }  
  38.     /* 
  39.     public void dosomething(String food)//我爱吃东西，吃什么呢，看传入什么 
  40.     { 
  41.         if(food.equals("apple")) 
  42.         { 
  43.             //吃苹果 
  44.         } 
  45.         if(food.equals("water")) 
  46.         { 
  47.             //喝水 
  48.         } 
  49.     } 
  50.     */  
  51.     public static void main(String[] args)  
  52.     {  
  53.         Human human=new Human();  
  54.         /* 
  55.         human.dosomething("apple"); 
  56.         human.dosomething("water"); 
  57.          */  
  58.         //给你吃个苹果  
  59.         human.dosomething(new EatApple());  
  60.         //再给你喝点水  
  61.         human.dosomething(new EatWater());  
  62.     }  
  63. }  


其中注释的就是我们常用的方法。这种方法非常不适于扩展，因为如果要吃香蕉，吃西瓜，又要在dosomething里面写一堆判断。写着写着就混了。

 

因此一句话总结：多用抽象的接口来描述相同的动作，降低实现这个动作的人和物之间的耦合度

 

接口隔离原则

 

 

客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。 
问题由来：类A通过接口I依赖类B，类C通过接口I依赖类D，如果接口I对于类A和类B来说不是最小接口，则类B和类D必须去实现他们不需要的方法。
一句话总结：就好比鱼和人两个类，鱼是游泳和腮呼吸两个动作，人是走路和吃饭两个动作，这些动作不能写在一个接口里面，把这四个动作都包含了。要拆成专门对鱼和人的两个接口才行。

 

 

迪米特法则

 

迪米特法则又叫最少知道原则，最早是在1987年由美国Northeastern University的Ian Holland提出。通俗的来讲，就是一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类来说，无论逻辑多么复杂，都尽量地的将逻辑封装在类的内部，对外除了提供的public方法，不对外泄漏任何信息。

这个有点不好记，总结就是：father1<-child1,father2<-child2,father1和father2是的手下， father1尽量通过father2去访问child2, 不要直接在类里面访问child2. 下属怎么能随便去领导家的孩子呢，小心别人说你拐卖 

 

开闭原则

 

这个没啥好说的：尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。

posted @ 2017-06-04 22:37  萝卜撞地球  阅读(104)  评论(0)    收藏  举报