6大设计原则（2）：里氏替换原则

里氏替换原则：LSP

定义：

假设对于每个类型为S的对象o1。都有类型为T的对象o2。使得以T定义的全部程序P在全部的对象o1都换为o2时，程序的行为没有发生变化。那么S是T的子类型。

 

在继承的时候，父类出现的地方子类就能够出现，子类可替代父类，由于子类中有父类的方法，然而父类却不能够替代子类，由于子类中可能有父类没有的方法。这就是所谓的向下转型是不安全的。

 

使用继承有非常多长处,能够提高代码的重用性。提高可扩展性、开放性，可是不可否认，继承也是有缺点的：

1.继承是侵入性的，仅仅要继承，就必须拥有父类的全部属性和方法；

2.减少代码的灵活性

3.增强了耦合性。

解决方式就是里氏替换原则。

 

4个含义：

1.子类必须全然实现父类的方法

2.子类能够有自己的方法

3.覆盖或实现父类的方法时，输入參数能够被放大

4.覆写或实现父类的方法时。输出结果能够被缩小

 

前两个含义比較好理解。这里就不再赘述，主要说一下3和4。

先说第3个，覆盖或实现父类的方法时。输入參数能够被放大。

先看一个样例：

class Father {
	public Collection dosomething(HashMap map) {
		System.out.println("父类被运行--->");
		return map.values();
	}
}

class Son extends Father {
	public Collection dosomething(Map map) {
		System.out.println("子类被运行--->");
		return map.values();
	}
}

public class Client {
	public static void main(String[] args) {
		// 父类存在的地方就能够替换为子类
		Father f = new Father();
		HashMap map = new HashMap();
		f.dosomething(map);
	}
}

 

代码执行结果是：

父类被运行--->

 

依据里氏替换原则，将父类改为子类：

 

public class Client {
	public static void main(String[] args) {
		// 父类存在的地方就能够替换为子类
		// Father f = new Father();
		Son f = new Son();
		HashMap map = new HashMap();
		f.dosomething(map);
	}
}

 

然而输出结果还是父类被运行。

。。

父类方法的參数是HashMap。而子类方法的參数是Map。也就是说子类的參数类型范围大，子类取代父类传递到调用者中，子类的方法永远不会被运行。

假设想要运行子类中的方法的话就须要覆写父类中的方法。覆写就是父类中的方法一模一样的出如今子类中。

 

class Father {
	public Collection dosomething(HashMap map) {
		System.out.println("父类被运行--->");
		return map.values();
	}
}

class Son extends Father {
	// public void dosomething(Map map) {
	// System.out.println("子类被运行--->");
	// }
	@Override
	public Collection dosomething(HashMap map) {
		// TODO Auto-generated method stub
		System.out.println("子类被运行--->");
		return map.values();
	}
}

public class Client {
	public static void main(String[] args) {
		// 父类存在的地方就能够替换为子类
		// Father f = new Father();
		Son f = new Son();
		HashMap map = new HashMap();
		f.dosomething(map);
	}
}

 

这是正常的。

 

 

假设父类參数的參数类型范围大于子类输入參数类型的话，会出现什么问题呢？会出现父类存在的地方，子类就未必能够存在，由于一旦把子类作为參数传入，调用者就非常可能进入子类的方法范畴。

改动一下上面的代码。扩大父类參数范围。缩小子类參数范围。

 

class Father {
	public Collection dosomething(Map map) {
		System.out.println("父类被运行--->");
		return map.values();
	}
}

class Son extends Father {
	public Collection dosomething(HashMap map) {
		System.out.println("子类被运行--->");
		return map.values();
	}

}

public class Client {
	public static void main(String[] args) {
		// 父类存在的地方就能够替换为子类
		Father f = new Father();
		Son f1 = new Son();
		HashMap map = new HashMap();
		f.dosomething(map);
		f1.dosomething(map);
	}
}

 

f运行父类的方法，f1运行子类的方法。

 

这就不正常了

 

子类在没有覆写父类方法的情况下。子类方法被运行了。所以，子类中方法的參数范围（前置条件）必须与父类的參数范围（前置条件）同样或者更加宽松。

 

再来说一下第4个含义，覆写或实现父类的方法时，输出结果能够被缩小。

什么意思呢？父类方法的返回值是类型T，子类同样方法（重载或覆写）的返回值是S，那么里氏替换原则就要求S必须小于等于T。也就是说。要么S和T类型同样，要么S是T的子类。

对于覆写而言，父类和子类中的方法时一模一样的，所以返回类型也应当是一样的。

对于重载，也就是第3个含义所讲到的，子类的输入參数宽于或等于父类的參数，也就是说这种方法时不会被调用的。