设计模式笔记（二）设计六大原则之二--里氏替换原则

里氏替换原则
LiskoSubstitution Principle LSP

定义：

只要父类出现的地方，子类就可以出现，而且替换为子类也不会有任何错误或异常，使用者可能根本不需要知道是父类还是子类。但是反过来就不行了，有子类出现的地方，父类未必能够适应。

此原则包含了4个含义：

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

1.因为里氏替换要求，父类出现的地方子类一定能出现。所以在写方法的时候如果用父类的参数，子类的功能可以根据需要传入。这样既得到了代码的复用，又可以多功能的实现功能。

举个栗子：

/*
 * 父类：枪
 * 有一个抽象方法：杀敌
 */
public abstract class AbstractGun {
    //枪用来干什么的？杀敌
    public abstract void shoot();
}

/*
 * 手枪的特点是携带方便，射程短
 */
public class Handgun extends AbstractGun{

    @Override
    public void shoot() {
        System.out.println("手枪射击...");
    }

}

/*
 * 步枪的特点是射程远，威力大
 */
public class Rifle extends AbstractGun{

    @Override
    public void shoot() {
        System.out.println("步枪射击...");
    }

}

/*
 * 使用枪支的士兵
 */
public class Soldier {
    //定义士兵的枪支 - 这把枪具体是手枪还是步枪等，需要上战场前通过setGun确定
    private AbstractGun gun;

    //给士兵一支枪
    public void setGun(AbstractGun _gun) {
        this.gun = _gun;
    }

    //士兵杀敌
    public void killEnemy() {
        System.out.println("士兵开始杀敌...");
        gun.shoot();
    }

}

/*
 * 战场场景测试
 */
public class Client {
    public static void main(String[] args) {
        //产生三毛这个士兵
        Soldier sanMao = new Soldier();
        //给三毛一支枪
        sanMao.setGun(new Rifle());
        //杀敌
        sanMao.killEnemy();
    }
}

士兵开始杀敌…
步枪射击…

即使这个时候我们不想用步枪了，想要用手枪，完全不用更改类设计得代码，只需要在使用的时候给士兵步枪即可：

//三毛用手枪杀敌
sanMao.setGun(new Handgun());
sanMao.killEnemy();

士兵开始杀敌…
手枪射击…

在类中调用其他类时务必要使用父类或接口，如果不能使用父类或接口，说明类的设计已经违背了LSP原则。

2.如果子类不能完整地实现父类的方法，或者父类的某些方法在子类中已经发生“畸变”，则建议断开父子继承关系，采用依赖，聚集，组合等关系代替继承。

举个栗子：
这个时候我们又有了玩具枪，想一想，玩具枪也是枪啊，理所当然我们又继承了AbstractGun

/*
 * 玩具枪
 */
public class ToyGun extends AbstractGun{

    //可是玩具枪并不能杀人啊。。。
    @Override
    public void shoot() {
        System.out.println("玩具枪射击...");
    }

}

这个时候如果三毛给的是玩具枪，哦哦

//三毛获得了玩具枪
sanMao.setGun(new ToyGun());
sanMao.killEnemy();

士兵开始杀敌…
玩具枪射击…

发现并没有达到该有的效果。
这个时候我们就需要重新设计一下类的关系。比如玩具枪的声音和形状模拟的枪支，但是它并不属于真枪的一种。

/*
 * 我是玩具枪，不是射击杀敌的真枪
 */
public abstract class AbstractToyGun {
    protected AbstractGun gun;

    //可以射击，但是属于我自己的射击，杀不死人的哦
    public abstract void shoot() ;

    public void beauty() {
        System.out.println("我模拟了真枪的外观...");
        gun.beauty();
    };


}

/*
 * 父类：枪
 * 有一个抽象方法：杀敌
 */
public abstract class AbstractGun {
    //枪用来干什么的？杀敌
    public abstract void shoot();

    //外观
    public abstract void beauty();
}

/*
 * 手枪的特点是携带方便，射程短
 */
public class Handgun extends AbstractGun{

    @Override
    public void shoot() {
        System.out.println("手枪射击...");
    }

    @Override
    public void beauty() {
        System.out.println("我有手枪外观...");
    }

}

/*
 * 步枪的特点是射程远，威力大
 */
public class Rifle extends AbstractGun{

    @Override
    public void shoot() {
        System.out.println("步枪射击...");
    }

    //步枪
    @Override
    public void beauty() {
        System.out.println("我有步枪外观...");
    }

}

/*
 * 手枪玩具枪
 */
public class ToyGun2 extends AbstractToyGun{

    public ToyGun2(AbstractGun gun) {
        super.gun = gun;
    }

    @Override
    public void shoot() {
        System.out.println("玩具枪射击...");
    }


}

//我有一个玩具枪,是一个手枪样式的
ToyGun2 toyGun = new ToyGun2(new Handgun());
toyGun.beauty();

子类可以有自己的个性

但是子类出现的地方，父类未必就可以胜任。也就是常说的向下转型是不安全的。

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

因为加入父类的参数范围比子类大，那么很有可能调用时没有实现正确的方法。

举个栗子：

/*
 * 之前说士兵可以有一把枪用来杀敌，士兵什么枪都可以有，手枪和步枪
 * 这里假设一个普通的小小兵，只可以拿手枪，当然他拿刀什么的，这里只关注枪的部分
 */
public class GeneralPerson extends Soldier{

    public void killEnemy(Handgun _gun) {
        System.out.println("小兵开始杀敌...");
        _gun.shoot();
    }
}

/*
 * 使用枪支的士兵
 */
public class Soldier {
    //士兵杀敌
    public void killEnemy(AbstractGun gun) {
        System.out.println("士兵开始杀敌...");
        gun.shoot();
    }
}

//产生三毛这个士兵
Soldier sanMao = new Soldier();
//手枪杀敌
sanMao.killEnemy(new Handgun());


//产生四毛这个小兵
GeneralPerson siMao = new GeneralPerson();
//手枪杀敌
siMao.killEnemy(new Handgun());

士兵开始杀敌…
手枪射击…
小兵开始杀敌…
手枪射击…

我们发现执行了子类的方法，明明我们希望所有的士兵不管用什么枪支杀敌都用士兵这个方法，但是子类由于参数范围比父类的小，导致这个时候扭曲了父类的意图，达到了不一样的功能。

覆写或实现父类的方法时输出结果可以被缩小。

意思是说，父类的一个方法返回值是一个类型T，子类的相同方法（重写或覆写）的返回值是S，那么里氏替换原则要求s必须小于等于T。也就是说要么S和T是同一个类型，要么S是T的子类。
覆写的时候，父类和子类的同名方法的输入参数是相同的，两个方法的返回值S小于等于T。这是覆写的要求所在。
重载的话，则要求输入参数类型或数量不同，里氏替换中要求，子类的输入参数宽于或等于父类的输入参数，也就是说这个方法时不会被调用的。