里氏原则

定义1：如果对每一个类型为 T1的对象 o1，都有类型为 T2 的对象o2，使得以 T1定义的所有程序 P 在所有的对象 o1 都代换成 o2 时，程序 P 的行为没有发生变化，那么类型 T2 是类型 T1 的子类型。

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

通俗说法:子类可以扩展父类的功能,但不能改变父类原有的功能。

以下是实例代码

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

public class OCP {
	 public static void invoker(){
	        Father f = new Father();
	        //出现父类的地方子类也可以出现
	        Son s = new Son();
	        HashMap map = new HashMap();
	        
	        //子类覆写/重载父类方法时,扩大了前置条件,这是对的,出现父类的地方可以用子类替换
	        f.doSomething(map); //syso：父类被执行
	        s.doSomething(map); //syso：父类被执行
	        
	        //子类覆写/重载父类方法时,缩小了前置条件,这是不对的,出现父类的地方不可以用子类替换
	        f.doS(map); //syso：父类被执行2
	        s.doS(map); //syso：子类被执行2
	        
	    }
	 	
	 	
	    public static void main(String[] args){
	        invoker();
	    }
	}

//父类
class Father{
    public Collection doSomething(HashMap map){
        System.out.println("父类被执行..");
        return map.values();
    }
    public Collection doS(Map map){
        System.out.println("父类被执行2..");
        return map.values();
    }
}
	
//子类
class Son extends Father{
    //重载,方法名相同但输入参数不同
    //子类重载了父类方法,但扩大了前置条件,所以子类的这个方法还是不会被执行,这样调用的时候就还是直接的父类方法
    //这才是想要的效果,体现了复用性,本来就该复用父类方法.
    public Collection doSomething(Map map){
        System.out.println("子类被执行..");
        return map.values();
    }
    
    //缩小了前置条件
    public Collection doS(HashMap map){
        System.out.println("子类被执行2..");
        return map.values();
    }
}

最后打出：

补充：

Human man = new Man();
上面代码中的"Human"称为变量的静态类型(Static Type)或者外观类型(Apparent Type),后面的"Man"则称为变量的实际类型(Actual Type).
在Java中，方法的重载是根据参数的静态类型作为依据的，属于静态分派。