面向对象设计原则之里氏替换原则

里氏替换原则：第一种定义：一个子类型一定可以替换父类型。假设S是T的一个子类，那么如果我们将一个程序中所有的T变量都用S来代替，那么程序依然可以运行正确。

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

总之就是子类可以替换父类的位置并且程序功能不受影响。

在面向对象的语言中，继承是必不可少的，它的优点：

1.代码共享，减少创建类的工作量，每个子类都拥有父类的方法和属性
2.提高代码的重用性
3.子类可以形似父类，但是又异于父类。
4.提高代码的可扩展性，实现父类的方法就可以了。许多开源框架的扩展接口都是通过继承父类来完成。
5.提高产品或项目的开放性

好用的同时也伴随着缺点：

1.继承是侵入性的，只要继承，就必须拥有父类的所有方法和属性
2.降低了代码的灵活性，子类必须拥有父类的属性和方法，让子类有了一些约束
3.增加了耦合性，当父类的常量，变量和方法被修改了，需要考虑子类的修改，这种修改可能带来非常糟糕的结果，要重构大量的代码。

里氏替换原则的四大规范：

一.子类必须完全实现父类的方法

我们做程序设计时，经常会定义一个接口或抽象类，然后编码实现，调用类则直接传入接口或抽象类，其实这已经使用了里氏替换原则。下面我们上一个例子：

我们首先写一个枪支抽象的父类：

public abstract class AbstractGun
{
    //枪支射击的抽象方法
    public abstract void Shoot();
	
}

它的子类：手枪，机枪，步枪的实现类：

using UnityEngine;

public class HandGun : AbstractGun
{
    public override void Shoot()
    {
        Debug.Log("手枪射击");
    }
}

using UnityEngine;

public class Rifle : AbstractGun
{
    public override void Shoot()
    {
        Debug.Log("步枪射击");
    }
}

using UnityEngine;

public class CachineGun : AbstractGun
{
    public override void Shoot()
    {
        Debug.Log("机枪射击");
    }
}

我们定义一个士兵进行射击：

using UnityEngine;

public class Soilder
{

    private AbstractGun gun;

    public void SetGun(AbstractGun gun)
    {
        this.gun = gun;
    }

    public void KillEnemy()
    {
        Debug.Log("士兵开始射击...");
        this.gun.Shoot();
    }
	
}

接下来进行调用：

using UnityEngine;

public class Manager : MonoBehaviour
{
    private void Start()
    {
        Soilder soilder = new Soilder();
        //设置士兵手握手枪
        soilder.SetGun(new HandGun());
        soilder.KillEnemy();
        //拿步枪
        soilder.SetGun(new Rifle());
        soilder.KillEnemy();
        //拿机枪
        soilder.SetGun(new CachineGun());
        soilder.KillEnemy();
      
    }

}

运行后结果：

注意：如果子类不能完全的实现父类的方法，或者父类的一些方法在子类中已经发生一些畸变，则建议断开继承，采用依赖，聚集，组合等关系代替继承。

二.子类可以有自己的个性

子类当然可以有自己的属性和方法。但是，里氏替换原则可以正着用，但是不能反着用。在子类出现的地方，父类就未必可以胜任。还是以刚才的枪支为例，在步枪中有一些

枪支比较有名，比如AK47,AUG狙击枪等；我们可以把这两个枪支继承父类步枪。

AUG狙击步枪：

using UnityEngine;

public class AUG : Rifle
{
    public void ZoomOut()
    {
        Debug.Log("通过放大镜观察");

    }

    public void Shoot()
    {
        Debug.Log("AUG射击...");
    }
	
}

狙击手类：

public class Snipper
{
    public void KillEnemy(AUG aug)
    {
        aug.ZoomOut();
        aug.Shoot();
    }
	
}

接下来进行调用：

using UnityEngine;

public class Manager : MonoBehaviour
{
    private void Start()
    {
        Snipper snipper = new Snipper();
        snipper.KillEnemy(new AUG());

    }

}

结果显示：

在这里，系统直接调用了子类，狙击手类是依赖枪支，所以我直接把子类的AUG传递进来，这个时候我们可以把父类传递进来吗？让我们来修改测试一下：

using UnityEngine;

public class Manager : MonoBehaviour
{
    private void Start()
    {
        Snipper snipper = new Snipper();
        snipper.KillEnemy((AUG)new Rifle());

    }

}

结果是：

出现异常，从里氏替换原则来看就是有子类出现的地方父类不一定能出现。

三.覆盖或实现父类的方法时输入参数可以被放大

简单来说就是子类的输入参数类型要大于父类的输入参数类型。

四.覆盖或实现父类的方法时输出的结果可以被缩小。
父类的一个方法的返回值是一个类型T，子类的相同方法的返回值为S，那么里氏替换原则就要求S必须小于等于T。


采用里氏替换原则的目的就是增强程序的健壮性，版本升级时也可以保持非常好的兼容性。即使增加子类，原有的子类还可以继续运行。在实际项目中，每个子类对应不同的业务含义，使用父类作为参数，传递不同的子类完成不同的业务逻辑，非常完美。

总之，里氏替换原则就是子类可以替换父类的位置并且程序功能不受影响。