大话设计模式之面向设计的几大原则读后感

引言：让我们重温经典，致敬经典

开放封闭原则：对扩展是开放的，对修改是关闭的

做到这个在刚开始的时候是不容易的，在刚开始是不会变化的，当发生变化的时候，我们应该创建抽象来隔离以后发生的同类变化。

举个栗子来解读上面这句话：

好比有个人，他刚开始会的技能只有唱歌，后来他又会了跳舞，再后来又会了写bug再后来又会了。。。此时我们应该把这个技能抽象出来

代码：

package com.dzf.designtest;

/**
 * <desc>
 *     开放封闭原则代码演示
 * </desc>
 * @author dingzf
 * @date 2018/3/30
 * @time 23:34
 */
public class OpenClosePrinciple {
    public static void main(String[] args) {
        //第一版
        Person person1 = new Person();
        person1.show();
        //第二版违反了开放封闭原则
        Person2 person2 = new Person2();
        person2.show();
        //改造,将变化的抽象出来，防止以后出现同样的变化
        person3 person3 = new person3();
        person3.setSkill(new SkillImpl());
        person3.shwo();
    }
}

/**
 * 刚开始类是这样的，第一版代码
 */
class Person{
    /**
     * 展示会的技能
     */
    public void show(){
        System.out.println("我会跳舞");
    }
}

/**
 * 第二版代码，我们发现这个我们违反了开发封闭原则，我们就把变化的抽象出来
 */
class Person2{
    /**
     * 展示会的技能
     */
    public void show(){
        System.out.println("我会跳舞");
        System.out.println("我会唱歌");
    }
}

/**
 * 第三版
 */
class person3{
    private Skill skill;

    public Skill getSkill() {
        return skill;
    }

    public void setSkill(Skill skill) {
        this.skill = skill;
    }

    public void shwo(){
        if(skill!=null){
            skill.show();
        }
    }
}
abstract class Skill{
    public abstract void show();
}
class SkillImpl extends Skill{
    public void show(){
        System.out.println("我会跳舞");
        System.out.println("我会唱歌");
        System.out.println("我会写bug");
    }
}

依赖倒置原则：高层模块不能依赖低层模块，两个都应该依赖抽象，抽象不应该依赖细节，细节应该依赖抽象

解释下，这个主要是为了降低耦合性，上面这句说我们可以用我们常用的service层和dao层来说明，高层不应该依赖第层，是说service层不应该依赖dao层，而都依赖接口，我们一般都会定义service层的接口和dao层的接口。抽象不应该依赖细节，细节应该依赖抽象，就是说要针对接口编程不要针对实现编程，好比我们service要调用dao层，我们要依赖的是dao层接口，而不是dao层的实现类，我们针对的是对接口，而不是针对细节，这样做我们可以更好的扩展。

职责单一原则：说一个类应该只有一种引起它变化的原因。从子面上理解，就是就专注干一件事，其实这些都是为了低耦合的。

里氏替换原则：说子类型必须能够替换掉他们的父类型。正是由于这个原则，才使得使用父类型的模块无需修改的情况下就可以扩展。不然还谈什么开放封闭啊，依赖倒置啊。这个是基础。