设计模式——7大设计原则

单一职责原则（Single responsibility principle）

核心思想

        每个方法、每个类、每个框架都只负责一件事情

例如：         

Math.round() ，只负责完成四舍五入的功能，其他的不管（方法）

Reader类，只负责读取文本文件（类）

SpringMVC，只负责简化MVC开发（框架）

优点：

        1.代码重用性提高

        2.代码可读性提高，此时的代码，就像一个大纲一样

        例如在唯品会开发手册中写道

方法的语句在同一个抽象层级上

反例：一个方法里，前20行代码在进行很复杂的基本价格计算，然后调用一个折扣计算函数，再调用一个赠品计算函数。

此时可将前20行也封装成一个价格计算函数，使整个方法在同一抽象层级上

里氏替换原则（Liskov Substitution Principle）

核心思想

        任何能使用父类的地方，都应该能透明的替换为子类对象 

Fu fu = new Zi();

也就是说，子类对象可以随时随地替换父类对象，并且替换完后，语法也不会报错，业务逻辑也不会出现问题！

什么时候两个类可以发生继承

        1）有没有“is a”关系

        2）在两个类有了“is a”关系后，还要考虑子类对象在替换了父类对象之后，业务逻辑会不会发生变化，如果变化了就不能发生继承关系        

例如 “正方形不是长方形”、“鸵鸟不是鸟”

依赖倒置原则（Dependence Inversion Principle）

核心思想

        上层不能依赖于下次，它们都应该依赖于核心抽象

开闭原则（Open Closed Principle）

核心思想

        对扩展开放、对修改关闭

百度词条

在面向对象编程领域中，开闭原则规定"软件中的对象（类，模块，函数等等）应该对于扩展是开放的，但是对于修改是封闭的"，这意味着一个实体是允许在不改变它的源代码的前提下变更它的行为。 该特性在产品化的环境中是特别有价值的，在这种环境中，改变源代码需要代码审查，单元测试以及诸如此类的用以确保产品使用质量的过程。

迪米特法则（最少知道原则）

核心思想：

          一个类，对于其他类，要知道的越少越好（主要体现了封装的思想）

        只和朋友通信

例如电脑关机

class Computer{
    public void saveData(){
        System.out.println("保存数据");
    }

    public void killProcess(){
        System.out.println("关闭程序");
    }

    public void closeScreen(){
        System.out.println("关闭屏幕");
    }

    public void poweroff(){
        System.out.println("断电");
    }
}

class Person{
    
    private Computer c = new Conputer;
    // 所以这个Person对于Computer的细节过于多了
    // 对于Person而言，只需要关机按钮在哪里就行了，不需要了解其他细节

    public void shutdownComputer(){
        // 这是正常的关机过程
        c.saveData();
        c.killProcess();
        c.closeScreen();
        c.poweroff; 
        // 但是不排除不会使用电脑的人
        // 可能操作就会变成如下情况：
        c.poweroff;  // 一来就断电了，不合逻辑
        c.saveData();
        c.killProcess();
        c.closeScreen();
        
    }
}

接口隔离原则

核心思想

        把总接口拆分为小接口

例如：

public interface Animal{
    void eat();
    void fly();
    void swim();
}

应该拆分为三个小接口（不是所有的动物都满足这些接口）

public interface Flyable(){
    void fly();
}

public interface Swiming(){
    void swim();
}

public interface Eatable(){
    void eat();
}

例如进行dao层代码编写时，是不会制作如下接口的

interface Dao{

    void save(User u);
    void delete(Integer uid);
    void update(User u);
    List<User> select();
    

    void save(Car c);
    void delete(Integer cid);
    void update(Car u);
    List<Car> select();

    void save(Book u);
    void delete(Integer bid);
    void update(Book u);
    List<Book> select();
}

class UserDao implement Dao{
    ...
}

而是拆分为不同类对应的Dao （也可以理解为单一职责原则）

组合由于继承原则

类与类的关系：

        继承： 一个类继承另外一个类

        依赖：一个类的对象作为另外一个类的局部变量

        关联：一个类的对象作为另外一个类的字段

        关联又可以细分为：

               组合：关系强（鸟和翅膀）

               聚合：关系弱（大雁和雁群）

写在最后

内容参考与：【高鹏-Java设计模式】 https://www.bilibili.com/video/BV1Qx411o7tN?p=12&share_source=copy_web&vd_source=e352c0d6d68ce162140c50b1ff1a8376