1.1开闭原则

开闭原则（open-closed principle，OCP）是指一个软件实体（如类，模块和函数）应该对扩展开放，对修改关闭。所谓的开闭，也正是对扩展和修改两个行为的一个原则。
强调用抽象构建框架，用实现扩展细节，可以提高软件系统的可复用性及可维护性；例如版本更新时，我们尽可能不修改源代码就可以添加新功能。

首先创建一个课程接口JavaCourse

/**
 * TODO 开闭原则——课程接口
 * @author ss_419
 */
public interface ICourse {
    Integer getId();
    String getName();
    Double getPrice();
}

整个课程有许多分类，Java、Python、Js等等…

紧接着我们创建一个Java课程类，该类实现课程接口

/**
 * TODO Java课程类
 *
 * @author ss_419
 * @version 1.0
 * @date 2023/1/29 10:37
 */
public class JavaCourse implements ICourse{
    private Integer id;
    private String name;
    private Double price;

    public JavaCourse(Integer id, String name, Double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    @Override
    public Integer getId() {
        return this.id;
    }

    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public Double getPrice() {
        return this.price;
    }
}

突然有一天，老板说把Java课程的价格做一下优惠，但是如果修改JavaCourse中的getPrice()方法，则存在一定的风险，可能影响其他地方的调用结果，为了避免此类事件发生，我们就需要在不修改原有代码的前提下，实现这个价格优惠的功能

解决方案：创建一个处理优惠逻辑的类JavaDiscountCourse

/**
 * TODO 开闭原则——JavaCourse降价活动
 *
 * @author ss_419
 * @version 1.0
 * @date 2023/1/29 10:38
 */
public class JavaDiscountCourse extends JavaCourse{
    public JavaDiscountCourse(Integer id, String name, Double price) {
        super(id, name, price);
    }

    /**
     * 出现降价活动不能够直接去修改JavaCourse中的getPrice()方法，所以通过继承JavaCourse类，来返回原商品降价之后的价格
     */
    /**
     * 获取商品原价格
     * @return
     */
    public Double getOriginPrice() {
    	System.out.println("原商品价格");
        return super.getPrice();
    }

    public Double getPrice(){
        System.out.println("降价后的商品价格");
        return super.getPrice() * 0.618;
    }

}

1.2依赖倒置原则

依赖倒置原则（Dependence Inversion Principle,DIP）是指设计代码结构时，高层模块不应该依赖低层模块，二者都应该依赖其抽象。
抽象不应该依赖与细节，细节应该依赖抽象。
通过依赖倒置，可以减少类与类之间的耦合性，提高系统的稳定性，提高代码的可读性和可维护性，并且能降低修改程序所造成的风险。

创建一个Tom类：

/**
 * TODO 依赖倒置——初始状态
 *
 * @author ss_419
 * @version 1.0
 * @date 2023/1/29 11:42
 */
public class Tom {
    public void studyJavaCourse(){
        System.out.println("studyJavaCourse");
    }
    public void studyPythonCourse(){
        System.out.println("studyPythonCourse studyPythonCourse");
    }

    public static void main(String[] args) {
        Tom tom = new Tom();
        tom.studyJavaCourse();
        tom.studyPythonCourse();
    }
}

目前Tom是在学习Java和Python，但是后续想学习其他课程的时候，就需要添加一个方法，没多学习一个就得多添加一个方法，这个时候，因为业务扩展，要从低层到高层（调用层）依次修改代码，这样极其不方便。

因此，我们接下来做一些优化：

创建一个课程接口ICourse：

/**
 * TODO 依赖倒置
 * @author ss_419
 */
public interface ICourse {
    void study();
}

编写JavaCourse类：

/**
 * TODO
 *
 * @author ss_419
 * @version 1.0
 * @date 2023/1/29 12:10
 */
public class JavaCourse implements ICourse{
    @Override
    public void study() {
        System.out.println("Java课程.....");
    }
}

编写PythonCourse类：

/**
 * TODO
 *
 * @author ss_419
 * @version 1.0
 * @date 2023/1/29 12:12
 */
public class PythonCourse implements ICourse{
    @Override
    public void study() {

        System.out.println("Python课程学习......");
    }
}

修改Tom类：

public class Tom {
    /**
     * DIP优化版本
     * @param course
     */
    public void study(ICourse course){
        course.study();
    }
 }

新的调用方式：

public static void main(String[] args) {
        Tom tom = new Tom();
        // 新的调用方式
        tom.study(new JavaCourse());
        tom.study(new JavaCourse());
        tom.study(new PythonCourse());
//        tom.studyJavaCourse();
//        tom.studyPythonCourse();
    }

DIP构造器注入方式

在使用构造器注入时，在调用的时候，每次都要创建实例

public class Tom {
    private ICourse course;

    /**
     * DIP——构造器注入方式
     * @param course
     */
    public Tom(ICourse course) {
        this.course = course;
    }
    public void study(){
        course.study();
    }
}

调用方式：

public static void main(String[] args) {
        Tom tom = new Tom(new JavaCourse());
        tom.study();
     }

当Tom时全局单例，只能选择用Setter方式来注入

public class Tom {
    private ICourse course;

    /**
     * 使用setter方式来注入
     * @param course
     */
    public void setCourse(ICourse course) {
        this.course = course;
    }
    public void study(){
        course.study();
    }
}

调用代码：

public static void main(String[] args) {
        Tom tom = new Tom();
        tom.setCourse(new JavaCourse());
        tom.study();
        tom.setCourse(new PythonCourse());
        tom.study();
    }

单一职责原则

单一职责（Simple Responsibility Pinciple，SRP）是指不要存在多于一个导致类变更的原因
假设我们有一个类负责两个职责，一旦发生需求变更，修改其中一个职责的逻辑代码，有可能导致另一个职责的功能发生故障，这样一来，这个类就存在两个导致类变更的原因。
为了避免上述情况的出现，我们将两个职责用两个类来实现，进行解耦。后期需求变更维护互不影响。
总体来说，就是一个类、接口或方法只负责一项职责

课程有直播课和录播课两类；直播课不能快进和快退，录播课可以任意地反复观看，功能职责不一样。

首先创建一个Course类:

/**
 * TODO 单一职责Simple Responsibility Pinciple
 * @author ss_419
 */
public class Course {
    public void study(String courseName){
        if ("直播课".equals(courseName)){
            System.out.println("不能快进==>" + courseName);
        }else if ("录播课".equals(courseName)){
            System.out.println("可以快进==>"+courseName);
        }
    }

	// 调用方法
    public static void main(String[] args) {
        Course course = new Course();
        course.study("直播课");
        course.study("录播课");
    }
}

从上面的代码，我们可以看出Course承担了两种处理逻辑。后续如果对其中一种课程进行加密，由于两种课程的加密逻辑一定不相同，必须修改代码。而修改代码的逻辑势必会相互影响，容易带来不可控的风险。

接下来我们对职责进行解耦

首先创建两个类LiveCourse和ReplayCourse

/**
 * TODO SRP优化版
 *
 * @author ss_419
 * @version 1.0
 * @date 2023/1/29 14:47
 */
public class LiveCourse {
    public void study(String courseName){
        System.out.println("我是直播课程==>" + courseName);
    }
}

/**
 * TODO
 *
 * @author ss_419
 * @version 1.0
 * @date 2023/1/29 14:49
 */
public class ReplayCourse {
    public void study(String courseName){

        System.out.println("我是录播课程==>"+courseName);
    }
}

调用过程

public static void main(String[] args) {
        LiveCourse liveCourse = new LiveCourse();
        liveCourse.study("直播课");
        ReplayCourse recordCourse = new ReplayCourse();
        recordCourse.study("录播课");
    }

通过创建两个单独的类，就实现了将两个职责从原先的Course中拆分的操作

接口隔离原则

接口隔离原则（Interface Segregation Pinciple，ISP）是指用多个专门的接口，而不使用单一的总接口，客户端不应该依赖它不需要的接口。

符合高内聚、低耦合的设计思想

一个类对另一个类的依赖应该建立在最小的接口之上。
建立单一接口，不要监理庞大臃肿的接口。
尽量细化接口，接口中的方法尽量少（适度即可）。

1创建一个IAnimal接口：

/**
 * TODO 接口隔离原则
 * @author ss_419
 */
public interface IAnimal {
    void eat();
    void fly();
    void swim();
}`在这里插入代码片`

2创建Bird类：

/**
 * TODO
 *
 * @author ss_419
 * @version 1.0
 * @date 2023/1/29 15:05
 */
public class Bird implements IAnimal{
    @Override
    public void eat() {
        System.out.println("bird eat");
    }

    @Override
    public void fly() {
        System.out.println("bird fly");
    }

    @Override
    public void swim() {

    }
}

3创建Dog类：

/**
 * TODO
 *
 * @author ss_419
 * @version 1.0
 * @date 2023/1/29 15:11
 */
public class Dog implements IAnimal{
    @Override
    public void eat() {
        System.out.println("I am a dog 吧唧吧唧");
    }

    @Override
    public void fly() {

    }

    @Override
    public void swim() {
        System.out.println("Dog swim....");
    }
}

通过2、3可以看出，Bird的swim方法只能空着（因为鸟不能游泳。。。。），而且Dog的fly方法也是实现不了的。

这个时候我们针对不同的动物行为来设计不同的接口，分别设计IEatAnimal、IFlyAnimal、ISwimAnimal接口：

/**
 * TODO
 *
 * @author ss_419
 * @version 1.0
 * @date 2023/1/29 15:16
 */
public interface IEatAnimal {
    void eat();
}

/**
 * @author ss_419
 */
public interface IFlyAnimal {
    void fly();
}

/**
 * @author ss_419
 */
public interface ISwimAnimal {
    void swim();
}

实现上面三个接口之后，修改dog类如下：

/**
 * TODO
 *
 * @author ss_419
 * @version 1.0
 * @date 2023/1/29 15:11
 */
public class Dog implements IEatAnimal, ISwimAnimal {

    @Override
    public void eat() {
        System.out.println("dog --> eat");
    }

    @Override
    public void swim() {
        System.out.println("dog --> swim");
    }
}

这样一来就不会存在实现类中不需要的方法了，防止客户端使用了它不需要的接口。

迪米特原则

迪米特原则（Law Of Demeter LoD）是指一个对象应该对其他对象保持最少的了解，又叫最少知道原则（Least Knowledge Pinciple，LKP），尽量降低类与类之间的耦合度。

只和朋友交流，不和陌生人说话

1、首先创建一个Course类

public class Course {
}

2、创建一个TeamLeader，用于统计Course信息

public class TeamLeader {
    public void checkNumberOfCourses(){
        List<Course> courseList = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            courseList.add(new Course());
        }
        System.out.println("目前已发布的课程数量是："+courseList.size());
    }
}

3、创建一个Boss，老板想看课程数量：

public class Boss {
    public void commandCheckNumber(TeamLeader teamLeader){
        // 通过TeamLeader来查询Course信息
        teamLeader.checkNumberOfCourses();
    }
}

4、调用方法：

public static void main(String[] args) {
        Boss boss = new Boss();
        // 这样一来，Boss就和Course分离开来了，boss不用去关心Course的具体实现，他只想知道有多少个课程数量
        boss.commandCheckNumber(new TeamLeader());
    }

这样一来，Boss就和Course分离开来了，boss不用去关心Course的具体实现，他只想知道有多少个课程数量

里氏替换原则

里氏替换原则（Liskov Substitution Princple，LSP）是指如果对每一个类型为T1的对象O1，都有类型为T2的对象O2，使得以T1定义的所有程序P在所有的对象O1都替换成O2时，程序P的行为没有发生变化，那么类型T2是类型T1的子类型。

一个软件实体如果适用于一个父类，那么一定适用于其子类，所有引用父类的地方必须能透明地使用其子类的对象，子类对象能够替换父类对象，而程序逻辑不变。
子类可以扩展父类的功能，但不能改变父类原有的功能

子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法
子类可以增加自己持有的方法
当子类的方法重载父类的方法时，方法的前置条件（即方法的输入/入参）要比父类方法的输入参数更宽松
当子类的方法实现父类的方法时（重写/重载或实现抽象方法），方法的后置条件（即方法的输出/返回值）要比父类更严格或与父类一样。（上转型或者转同型）

【Spring 5核心原理】1设计模式1.1开闭原则1.2依赖倒置原则单一职责原则接口隔离原则迪米特原则里氏替换原则

1.1开闭原则

1.2依赖倒置原则

单一职责原则

接口隔离原则

迪米特原则

里氏替换原则

继续阅读

关于Gradle配置的小结

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method