设计模式——里氏替换原则

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

【解决方案】当使用继承时，遵循里氏替换原则。类B继承类A时，除添加新的方法完成新增功能P2外，尽量不要重写父类A的方法，也尽量不要重载父类A的方法。

【关键点】

1、子类对象可以替换父类对象，并出现在任何父类可以出现的地方。

2、不能覆盖父类的非抽象方法子类方法

示例：

  public class C {
     public int func(int a,int b){
     return a+b;
     }
    }
public class C1 extends C{
     @Override
     public int func(int a,int b) {
     return a-b;
     }
    }
public class Client{
     public static void main(String args) {
     C c = new C1();
     System.out.println("2+1=" + c.func(2,1));
     }
    }

运转成果：2+1=1
上面的运行结果是毛病的。类C1继承C，然后需求增添新功用，类C1并没有新写一个方法，而是间接重写了父类C的func方法，违反里氏替代原则，

子类尽可能不要重写父类的方式，而是另写一个方式，以是对上面的代码加以变动，使其合适里氏替代原则，代码以下：

 public class C {
     public int func(int a,int b){
     return a+b;
     }
    }
public class C1 extends C{
     public int func2(int a,int b) {
     return a-b;
     }
    }
public class Client{
     public static void main(String args) {
     C1 c = new C1();
     System.out.println("2-1=" + c.func2(2,1));
     }
    }

运转成果：2-1=1。

当子类覆盖或实现父类的方法时，方法的前置前提（即方式的形参）要比父类方式的输入参数更宽松

import java.util.HashMap;
    public class Father {
     public void func(HashMap m){
     System.out.println("履行父类...");
     }
    }
import java.util.Map;
    public class Son extends Father{
     public void func(Map m){//方式的形参比父类的更宽松
     System.out.println("履行子类...");
     }
    }
import java.util.HashMap;
    public class Client{
     public static void main(String args) {
     Father f = new Son();//援用基类的处所能通明地利用其子类的工具。
     HashMap h = new HashMap();
     f.func(h);
     }
    }

运转成果：履行父类...

import java.util.Map;
    public abstract class Father {
     public abstract Map func();
    }
import java.util.HashMap;
    public class Son extends Father{
@Override
     public HashMap func(){//方式的返回值比父类的更严酷
     HashMap h = new HashMap();
     h.put("h","履行子类...");
     return h;
     }
    }
public class Client{
     public static void main(String args) {
     Father f = new Son();//援用基类的处所能通明地利用其子类的工具。
     System.out.println(f.func());
     }
    }

履行成果：{h=履行子类...}