七：里氏代换原则

一什么是里氏代换原则
里氏代换原则的严格表达是：如果对每一个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有对象o1代换成o2时，程序P的行为没有变化，那么类型T2是类型T1的子类型.
换言之，一个软件褓如果使用的量个基类的话，那么一定适用其子类，而且它根本不能察觉出基类对象和子类对象的区别.反过来不成立:如果一个软件实体用的是子类的话，那它不一定适用于基类.

二：Java语言对里氏代换的支持
在编译时期，Java语言编译器会检查一个程序是否符合里氏代换，里氏代换要求凡是基类型使用的地方，子类型一定适用，因此子类必须具备基类的全部接口。举例而言，一个基类Base声明了一个public方法method(),那么其子类sub可否将这个方法的访问权限从public改换成package或者private呢?从里氏代换的角度考察这个问题，就不难得出答案，因为客户端完全有可能调用Base的公开方法，如果以子类类取代之，这个方法却变成了私有的，客户端不能调用，显然这是违反里氏代换法则的，Java编译器根本不会让这样的程序过关。 Java语言对里氏代换支持的局限性：Java编译器不能检查一个系统在实现和商业逻辑上是否满足里氏代换法则，一个著名的例子就是"正方形类是否是长方形类的子类"的问题!!

三：里氏代换原则在设计模式中的体现
A:策略模式：策略模式讲的是："如果有一组算法，那么将每一个算法封装起来，使得它们可以互换"。封装的概念不难理解，而使得所有的算法可以互换，则需要将所有的具体策略角色放到一个类型等级结构中，使它们拥有共同的接口，显然这种互换性依赖是对里氏代换的遵守：AbstractStrategy s = new ConcreteStratetyA();从这个代码可以看出，客户端依赖于基类类型，而变量的真实类型则是具体的策略，这是个体策略角色可以"即插即用"的关键
B:合成模式
C:代理模式，代理模式给一个对象提供一个代理对象，并由代理对象控制对原对象的引用，代理模式能够成立的关键就在于代理模式与真实模式都是抽象主题角色的子类，客户端只知道抽象主题，而代理主题可以替代抽象主题出现在任何需要的地方，而将真实的主题隐藏在幕后.

四：从代码重构的角度理解
里氏代换讲的是基类和子类的关系，只有当这种关系存在时里氏代换关系才存在.如果两个具体的类A和B之间的关系违反了里氏代换原则的设计，根据具体的情况可以用下面的两种方法进行代码重构:
(1)创建一个新的抽象类C作为两个类的具体的超类，将A和B的共同行为移动到C中，从而解决A和B行为不完全一致的问题.
(2)把A和B的继承关系改写成委派关系.

五：正方形不可以作为长方形的子类

class Rectangle{ 
private long width; 
private long height; 
public long getWidth() { 
return width; 
} 
public void setWidth(long width) { 
this.width = width; 
} 
public long getHeight() { 
return height; 
} 
public void setHeight(long height) { 
this.height = height; 
} 
} 

class Square extends Rectangle{ 
private long size; 

public long getWidth() { 
return getSize(); 
} 
public void setWidth(long width) { 
setSize(width); 
} 
public long getHeight() { 
return getSize(); 
} 
public void setHeight(long height) { 
setSize(height); 
} 

public long getSize() { 
return size; 
} 

public void setSize(long size) { 
this.size = size; 
} 

} 

public class Test { 
public void resize(Rectangle r){ 
int i = 0; 
while(r.getHeight()<=r.getWidth()){ 
i++; 
r.setHeight(r.getHeight() + 1); 
if(i>100){ 
break; 
} 
System.out.println("******************************************* ************" + i); 
} 
} 
public static void main(String[] args){ 
Test t = new Test(); 
Rectangle r = new Rectangle(); 
r.setHeight(10); 
r.setWidth(20); 
Square s = new Square(); 
s.setSize(10); 
t.resize(r); 
//t.resize(s); 
} 
} 

在上面的例子中，如果resize传入的是基类Rectangle对象时，这个resize方法会将宽度不断增加，直到超过长度才停下来.但如果我们在resize方法里传入的是一个Square对象时，这个resize方法就会将正方形的边不断地增加下去，直到溢出为止。这说明什么问题：说明用子类型的对象替换父类型的对象时，得到的结果是不一样的，而里氏代换原则要求子类对象一定是可以替换父类型的对象，这和里氏代换原则相矛盾，故正方形不能是长方形的子类.

我们应当进行如下的代码重构：

public interface BaseInterface { 
public long getWidth(); 
public long getHeight(); 
} 
public class MyRectangle implements BaseInterface{ 
private long width; 
private long height; 

public long getWidth() { 
return width; 
} 
public void setWidth(long width) { 
this.width = width; 
} 
public long getHeight() { 
return height; 
} 
public void setHeight(long height) { 
this.height = height; 
} 
} 

public class MySquare implements BaseInterface{ 
private long size; 
public long getSize() { 
return size; 
} 
public void setSize(long size) { 
this.size = size; 
} 
public long getHeight() { 
return getSize(); 
} 
public long getWidth() { 
return getSize(); 
} 
} 

那么破坏里氏代换的问题在这里是怎么样避免的呢？秘密在于基类BaseInterface类没有赋值方法，因此resize方法不可能适用于BaseInterface类型，而只能用于不同的具体子类Rectangle和Square，因此里氏代换原则不可能被破坏.
如下的测试类是不行的了：

public class MyTest { 
public void resize(BaseInterface r){ 
int i = 0; 
while(r.getHeight()<=r.getWidth()){ 
i++; 
r.setHeight(r.getHeight() + 1);//出错,BaseInterface里面没有这个方法的实现 
if(i>100){ 
break; 
} 
System.out.println("******************************************* ************" + i); 
} 
} 
public static void main(String[] args){ 
MyTest t = new MyTest(); 
Rectangle r = new Rectangle(); 
r.setHeight(10); 
r.setWidth(20); 
Square s = new Square(); 
s.setSize(10); 
t.resize(r);//出错 
} 
} 

测试代码修改如下：

public class MyTest { 
public void resize(Rectangle r){ 
int i = 0; 
while(r.getHeight()<=r.getWidth()){ 
i++; 
r.setHeight(r.getHeight() + 1);//出错,BaseInterface里面没有这个方法的实现 
if(i>100){ 
break; 
} 
System.out.println("******************************************* ************" + i); 
} 
} 
public static void main(String[] args){ 
MyTest t = new MyTest(); 
Rectangle r = new Rectangle(); 
r.setHeight(10); 
r.setWidth(20); 
Square s = new Square(); 
s.setSize(10); 
t.resize(s); 
} 
} 

我们应当尽量从抽象类继承，而不从具体类继承.
我们知道，Properties是HashTable的子类，是一种特殊的HashTable，它只接受String类型的key和value,但是其超类可以接受任何类型的key和value，这就意味着Properties并不能在任何时候取代HashTable，所以Java语言的这个设计也违反了里氏代换原则.