基本介绍
- 如果对每个类型为T1的对象o1,都有类型为T2的对象o2,使得以T1定义的所有程序p在所有的对象o1都替换成o2时,程序p的行为没有发生变化,那么类型T2是类型T1的子类型。换句话说,所有引用基类的地方必须能透明的使用其子类的对象
- 在使用继承时,遵循里氏替换原则,在子类中尽量不要重写父类分方法
- 里氏替换原则告诉我们,继承实际上让两个类耦合性增强了,在适当的情况下可以通过聚合,组合,依赖来解决问题
应用实例
方案1
package com.szh.principle.liskov;
/*
1.发现原来运行正常的相减的功能出现错误,原因是类B重写了父类的方法,在实际编程过程中,
我们常常会通过重写父类的方法完成新的功能,这样写起来虽然简单,但整个继承体系的复用性
比较差,特别是运行多态比较频繁的时候。
2.通用方法:原来的父类和子类都继承一个更通俗的基类,原有的继承关系去掉,采用依赖,聚
合,组合等关系替代。
*/
public class Liskov1 {
public static void main(String[] args) {
A a = new A();
System.out.println("11 - 3 = "+a.fun1(11,3));
System.out.println("1 - 8 = " + a.fun1(1,8));
System.out.println("------------------");
//B重写了A中的fun1
B b = new B();
System.out.println("11 - 3 = "+b.fun1(11,3));
System.out.println("1 - 8 = " + b.fun1(1,8));
}
}
//A类
class A{
//返回两数之差
public int fun1(int num1,int num2){
return num1 - num2;
}
}
//B类继承A
//增加一个新功能:完成两数之和,然后和9求和
class B extends A{
//B重写A的fun1方法
public int fun1(int a,int b){
return a + b;
}
public int fun2(int a, int b){
return fun1(a,b) + 9;
}
}
方案2
package com.szh.principle.liskov;
public class Liskov2 {
public static void main(String[] args) {
A a = new A();
System.out.println("11 - 3 = "+a.fun1(11,3));
System.out.println("1 - 8 = " + a.fun1(1,8));
System.out.println("------------------");
//因为B类不再继承A类,因此调用者,不会再认为fun1是求减法
//调用完成的功能会很明确
B b = new B();
System.out.println("11 + 3 = "+b.fun1(11,3));
System.out.println("1 + 8 = " + b.fun1(1,8));
//使用组合还是可以使用A类的相关方法
System.out.println("11 - 3 = "+b.fun3(11,3));
System.out.println("1 - 8 = " + b.fun3(1,8));
}
}
//创建一个更加基础的基类
class Base {
//把更加基础的方法和成员写到Base类中
}
//A类
class A extends Base{
//返回两数之差
public int fun1(int num1,int num2){
return num1 - num2;
}
}
//B类继承A
//增加一个新功能:完成两数之和,然后和9求和
class B extends Base{
//如果B需要使用A类的方法,使用组合关系
private A a = new A();
//B重写A的fun1方法
public int fun1(int a,int b){
return a + b;
}
public int fun2(int a, int b){
return fun1(a,b) + 9;
}
//假如想使用A的方法
public int fun3(int a,int b){
return this.a.fun1(a,b);
}
}