4. 里氏替换原则

一、Liskov Substitution Principle

• 在使用继承时，在子类中尽量不要重写父类的方法；
• 继承实际上是让两个类的耦合性增强了，在适当情况下，可以通过聚合，组合，依赖等来解决问题；

1. 子类重写父类

package com.day.dreamer.seven.liskvo;

public class TraditionalLiskvo {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.eat();

        /**
         * 由于子类无意识情况下
         * 重写了父类的方法，因此调用的时候用的是子类的方法
         */
        Cat cat = new Cat();
        cat.eat();
    }
}

class Animal{
    public void eat(){
        System.out.println("动物吃食物");
    }
}

class Cat extends Animal{
    /**
     * 子类中无意识的情况下，将父类的方法进行了重写
     */
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

2. 改进

package com.day.dreamer.seven.liskvo;

public class ImprovedLiskvo {
    public static void main(String[] args) {
        Cycle cycle = new Cycle();
        cycle.function();

        Bicycle bicycle = new Bicycle(cycle);
        bicycle.function();
    }
}

/**
 * 将此类提为基类，然后下面两个类脱离继承关系
 */
class Base{
    public void work(){
        System.out.println("测试方法");
    }
}

class Cycle extends Base{
    public void function(){
        System.out.println("交通工具：正常使用");
    }
}

class Bicycle extends Base{
    private Cycle cycle;

    /**
     * 通过组合的方式来进行
     * @param cycle
     */
    public Bicycle(Cycle cycle){
        this.cycle = cycle;
    }

    public void function(){
        cycle.function();
        System.out.println("自行车：正常使用");
    }
}