——里斯替换原则（LSP）小米插排更好用

什么里斯替换原则

---

定义1：如果对每一个类型为S的对象o1，都有类型T的对象o2，在程序P中，使得T定义的o1都能替代成o2，而程序P的行为没有发生变化，那么类型S是类型T的子类型。
定义2：所有应用基类的地方必须能够透明地使用其子类的对象。

2个定义都是可以的，只是第2种读起来比较绕口，第2个比较简洁，个人建议多品一品定义1。

里斯替换规则

---

1. 其他类应该依赖父类或接口

//学生
class Student{
    public String name;
}

//老师
class Teacher{
    //报名
    public static void signUp(Student student){
         System.out.println("当前报名学生姓名："+student.name);
    }
}

//学生张三
class ZhangSan extends Student{
}

class TeacherWang{
  //报名
    public static void signUp(ZhangSan zhangSan){
         System.out.println("当前报名学生姓名："+zhangSan.name);
    }
}

看看上面的区别，Teacher依赖的是Student，而TeacherWang依赖的是的ZhangSan，可以说TeacherWang是不符合LSP原则，当然我们在设计程序的时候，并不是全部都要使用这个原则，有的时候也是直接依赖子类的，这个要看具体的需求。

2. 子类必须完全是父类的方法

Class Student{
    //获取学生证
    public abstract String getStudentID();
}

Class ZhangSan extends Student{
     public String getStudentID(){
        return null;
    }
}

我们看ZhangSan是Student的子类，但是没有实现getStudentID()方法，假如学校门卫是根据学生证，让你走进校园，如果没有学生证，那就没有资格进入校园，那就相当于不是学生。

3. 子类可以有不同于父类的方法和属性
   ZhangSan、LiSi都是Student，那么他们就有所有Student的属性和方法，但是ZhangSan喜欢下象棋，LiSi喜欢打篮球，那么这样也是可以的，那么反过来讲就不成立了，难道只要是Student都喜欢打篮球和下象棋吗？

4. 重载父类的方法，参数类型>=重载参数 或 参数类型 != 重载参数

//父类
class Parent {
    public void test(HashMap hashMap){}
}

//子类
class Child extends Parent{
    @Override
    public void test(HashMap hashMap){}

    public void test(Map map){}

    public void test(String text){}
}

//程序P
class Test{
    public static void main(String[] args){
        //使用父类
        Parent parent = new Parent();
        HashMap hashMap = new HashMap();
        parent.test(hashMap);

     //用子类进行替换
     //Child child = new Child ();
     //HashMap hashMap = new HashMap();
     //child.test(hashMap);
   }
}

//根据定义1，咱们把Parent换成Child，最终调用的还是Parent里面的方法。

反之看看成立吗？

//父类
class Parent {
    
    public void test(Map map){}
}

//子类
class Child extends Parent{
   
    public void test(HashMap hashMap){}
    @Override
    public void test(Map map){}

    public void test(String text){}
}

//程序P
class Test{
    public static void main(String[] args){
        //使用父类
        Parent parent = new Parent();
        HashMap hashMap = new HashMap();
        parent.test(hashMap);

     //用子类进行替换
     //Child child = new Child ();
     //HashMap hashMap = new HashMap();
     //child.test(hashMap);
   }
}
替换之后发现child调用的不是父类的test(Map map)方法，而是自己的test(HashMap hashMap)方法，不符合定义1，替换之后不印象程序P的功能。

优缺点

---

优点

• 共享代码，减少工作量，子类共享父类的属性和方法。
• 提高代码重用性
• 提高代码的扩展性

缺点

• 集成是侵入性的，只要继承了父类，那么就必须拥有父类的所有的属性和方法。
• 降低代码的灵活性，由于继承了父类，那么父类就对子类进行了约束。
• 增强了耦合性，继承本来就是强耦合性的，父类修改属性和方法的时候，必须需要考虑子类的修改。