设计模式6大原则：里氏置换原则

里氏置换原则（Liskov Substitution Principle），简称LSP

10年积累的成都做网站、成都网站建设经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先网站设计后付款的网站建设流程，更有日喀则免费网站建设让你可以放心的选择与我们合作。

定义：

Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it.

所有引用基类的地方必须能够透明的使用其子类对象。

也就是说，只要父类出现的地方子类就能够出现，而且替换为子类不会产生任何错误或异常。但是反过来，子类出现的地方，替换为父类就可能出现问题了。

这个原则是为良好的继承定义一个规范，简单的讲，有4层含义：

一、子类必须完全实现父类的方法

定义一个抽象类

 
 
 
    
  
  
  
  1. public abstract class ViewPoint { 
    2. 
  
  
  
  2.     //去丽江旅游 
    3. 
  
  
  
  3.     public abstract void where(); 
    4. 
  
  
  
  4. }
    5.

下面两个类是实现这个抽象类

 
 
 
    
  
  
  
  1. public class Lijiang extends ViewPoint { 
    2. 
  
  
  
  2.   
    3. 
  
  
  
  3.     @Override
    4. 
  
  
  
  4.     public void where() { 
    5. 
  
  
  
  5.         System.out.println("欢迎来到丽江..."); 
    6. 
  
  
  
  6.     } 
    7. 
  
  
  
  7.   
    8. 
  
  
  
  8. } 
    9. 
  
  
  
  9. 
  
  
  
  10. public class Zhangjiajie extends ViewPoint { 
    11. 
  
  
  
  11.   
    12. 
  
  
  
  12.     @Override
    13. 
  
  
  
  13.     public void where() { 
    14. 
  
  
  
  14.         System.out.println("欢迎来到张家界..."); 
    15. 
  
  
  
  15.     } 
    16. 
  
  
  
  16.   
    17. 
  
  
  
  17. }
    18.

人物是涂涂，在里面设置类类型来传递参数。此时涂涂要去的旅游景点还是抽象的

 
 
 
    
  
  
  
  1. public class Tutu { 
    2. 
  
  
  
  2.     //定义要旅游的景点 
    3. 
  
  
  
  3.     private ViewPoint viewpoint; 
    4. 
  
  
  
  4.     //涂涂要去的景点 
    5. 
  
  
  
  5.     public void setViewPoint(ViewPoint viewpoint) 
    6. 
  
  
  
  6.     { 
    7. 
  
  
  
  7.         this.viewpoint = viewpoint; 
    8. 
  
  
  
  8.     } 
    9. 
  
  
  
  9.       
    10. 
  
  
  
  10.     public void travelTo() 
    11. 
  
  
  
  11.     { 
    12. 
  
  
  
  12.         System.out.println("涂涂要去旅游了"); 
    13. 
  
  
  
  13.         viewpoint.where(); 
    14. 
  
  
  
  14.     } 
    15. 
  
  
  
  15. }
    16.

场景类。设置具体要去的景点

 
 
 
    
  
  
  
  1. public class Sence { 
    2. 
  
  
  
  2.     public static void main(String args[]) 
    3. 
  
  
  
  3.     { 
    4. 
  
  
  
  4.         Tutu tutu = new Tutu(); 
    5. 
  
  
  
  5.         //设置要去的旅游景点 
    6. 
  
  
  
  6.         tutu.setViewPoint(new Lijiang()); 
    7. 
  
  
  
  7.         tutu.travelTo(); 
    8. 
  
  
  
  8.     } 
    9. 
  
  
  
  9. }
    10.

运行结果：

涂涂要去旅游了
欢迎来到丽江...

二、子类可以有自己的特性

也就是说在类的子类上，可以定义其他的方法或属性

三、覆盖或者实现父类的方法时输入参数可以被放大

父类能够存在的地方，子类就能存在，并且不会对运行结果有变动。反之则不行。

父类，say()里面的参数是HashMap类型，是Map类型的子类型。（因为子类的范围应该比父类大）

 
 
 
    
  
  
  
  1. import java.util.Collection; 
    2. 
  
  
  
  2. import java.util.HashMap; 
    3. 
  
  
  
  3.   
    4. 
  
  
  
  4. public class Father { 
    5. 
  
  
  
  5.     public Collection say(HashMap map) 
    6. 
  
  
  
  6.     { 
    7. 
  
  
  
  7.         System.out.println("父类被执行..."); 
    8. 
  
  
  
  8.         return map.values(); 
    9. 
  
  
  
  9.     } 
    10. 
  
  
  
  10. }
    11.

子类，say()里面的参数变成了Map类型，Map范围比HashMap类型大，符合LSP原则。注意这里的say不是覆写父类的say，因为参数类型不同。而是重载。

 
 
 
    
  
  
  
  1. import java.util.Collection; 
    2. 
  
  
  
  2. import java.util.Map; 
    3. 
  
  
  
  3.   
    4. 
  
  
  
  4. /* 
    5. 
  
  
  
  5.  * 子类继承了父类的所有属性 
    6. 
  
  
  
  6.  */
    7. 
  
  
  
  7. public class Son extends Father { 
    8. 
  
  
  
  8.     //方法输入参数类型 
    9. 
  
  
  
  9.     public Collection say(Map map) 
    10. 
  
  
  
  10.     { 
    11. 
  
  
  
  11.         System.out.println("子类被执行..."); 
    12. 
  
  
  
  12.         return map.values(); 
    13. 
  
  
  
  13.     } 
    14. 
  
  
  
  14. }
    15.

场景类

 
 
 
    
  
  
  
  1. import java.util.HashMap; 
    2. 
  
  
  
  2.   
    3. 
  
  
  
  3. public class Home { 
    4. 
  
  
  
  4.     public static void main(String args[]) 
    5. 
  
  
  
  5.     { 
    6. 
  
  
  
  6.         invoke(); 
    7. 
  
  
  
  7.     } 
    8. 
  
  
  
  8.       
    9. 
  
  
  
  9.     public static void invoke() 
    10. 
  
  
  
  10.     { 
    11. 
  
  
  
  11.         //父类存在的地方，子类就应该能够存在 
    12. 
  
  
  
  12.         //Father f = new Father(); 
    13. 
  
  
  
  13.         Son s = new Son(); 
    14. 
  
  
  
  14.         HashMap map = new HashMap(); 
    15. 
  
  
  
  15.         //f.say(map); 
    16. 
  
  
  
  16.         s.say(map); 
    17. 
  
  
  
  17.     } 
    18. 
  
  
  
  18. }
    19.

无论是用父类还是子类调用say方法，得到的结果都是

父类被执行...

但是，如果将上面Father里的say参数改为Map，子类Son里的say参数改为HashMap，得到的结果就变成了

f.say(map)结果：父类被执行...

s.say(map)结果： 子类被执行...

这样会造成逻辑混乱。所以子类中方法的前置条件必须与父类中被覆写的前置条件相同或者更宽。

四、覆写或者实现父类的方法时输出结果可以被缩小

其实与上面的类似，也就是父类能出现的地方子类就可以出现，而且替换为子类不会产生任何错误或者异常，使用者也无需知道是父类还是子类。但是反过来就不行了，有子类出现的地方，父类未必就适应。（毕竟子类的范围要>=父类的范围）

当前标题：设计模式6大原则：里氏置换原则
文章路径：http://www.shufengxianlan.com/qtweb/news6/267606.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

营销型网站建设知识

同城分类信息

宜宾网站设计　　 　成都seo优化　　 　草坪音箱　　 　网站解决方案　　 　木包装箱　　 　黔盛装饰　　 　中国电信成都枢纽中心　　 　南宁旺客科技　　 　成都网站设计　　 　手机网站制作　　 　乐山电信机房　　 　成都网站推广　　 　成都圣月服饰　　 　清舞人间　　 　成都定制网站　　 　背发光字　　 　营销型网站建设　　 　成都响应式网站建设公司　　 　阿坝网站设计　　 　成都网站推广