“这是我参与8月更文挑战的第20天，活动详情查看：8月更文挑战”

一、Open-Closed Principle开闭原则

（一）、开闭原则定义

​ 开闭原则是指一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。所谓的开闭，也正是对扩展和修改两个行为的一个原则。强调的是用抽象构建框架，用实现扩展细节。可以提高软件系统的可复用性以及可维护性。

​ 开闭原则，是面向对象设计中最基础的设计原则。它指导我们如何建立文档灵活的系统，例如：我们进行版本更新时，尽可能不修改源代码，但是可以增加新功能。

​ 开闭原则就是在我们需要发生变化时，应该是进行代码的拓展，而不是进行修改源码。实现开闭原则的核心思想就是面向抽象编程。

（二）、开闭原则优点

​ （1）、可复用性高：灵活的增加新功能

​ （2）、可维护性高：不需要修改底层源码，只需要对相应功能进行更新

（三）、案例代码

1、书籍接口代码

public interface Book {
    public String getName();
    public String getAuthor();
    public Double getPrice();
}

2、Java类书籍

public class JavaBook implements Book{
    private String name;
    private String author;
    private Double price;

    public JavaBook(String name, String author, Double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }

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

    @Override
    public String getAuthor() {
        return this.author;
    }

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

3、Java类折扣书籍

​ 当我们需要折扣出售书籍时，我们并非在JavaBook的基础上修改getPrice方法中的源码，这样会导致我们无法获得原价，此时我们需要进行添加多一个方法，并且由于以后折扣出售会有不同的处理方案，所以我们应选择拓展这个类。

public class JavaDiscountPrice extends JavaBook{
    public JavaDiscountPrice(String name, String author, Double price) {
        super(name, author, price);
    }

    public Double getJavaDiscountPrice() {
        return super.getPrice()*0.5;
    }
}

4、增加JavaDiscountPrice类的前后区别

public class Main {
    public static void main(String[] args) {
        // 直接在JavaBook上进行修改
        JavaBook javaBook = new JavaBook("java书籍", "无名氏", 12.00);
        // 只可得知折扣后的价格
        System.out.println("折扣" + javaBook.getPrice());
        // 添加JavaDiscountPrice
        JavaDiscountPrice javaDiscountPrice = new JavaDiscountPrice("java书籍", "无名氏", 12.00);
        // 可得知原价以及折扣后的价格
        System.out.println("原价：" + javaBook.getPrice());
        System.out.println("折扣：" + javaDiscountPrice.getPrice());
    }
}

二、Dependence Inversion Principle依赖倒置原则

（一）、依赖倒置原则定义

​ 依赖倒置原则是指设计代码结构时，高层模块不应该依赖底层模块，二者都应该依赖其抽象。抽象不应该依赖细节；细节应该依赖抽象。

​ 通过依赖倒置，可以减少类与类之间的耦合性，提高系统的稳定性，提高代码的可读性和可维护性，并能够降低修改程序所造成的风险。

（二）、依赖倒置原则优点

​ （1）、可以减少类间的耦合性。

​ （2）、提高代码的可读性和可维护性，降低修改代码所带来的风险。

（三）、案例代码

1、不满足依赖倒置原则的情况

​ 随着顾客打算购买的书籍的增多或者变化，我们将不断增加或改变底层代码，同时在高层也需要追加调用，这样导致我们的代码越来越臃肿，同时也难以维护，实际上也是非常不稳定的，在修改代码的同时会带来意想不到的风险。

public class Customer {

    public void getJavaBook() {
        System.out.println("购买了java语言书");
    }

    public void getCBook() {
        System.out.println("购买了C语言书");
    }

    public void getPythonBook() {
        System.out.println("购买了Python语言书");
    }

    public static void main(String[] args) {
        Customer customer = new Customer();
        customer.getCBook();
        customer.getJavaBook();
        customer.getPythonBook();

    }
}

2、接口传递方式进行依赖注入 （1）、书籍抽象接口类

public interface Book {
    void getBook();
}

（2）、Java类书籍实现类

public class JavaBook implements Book{
    @Override
    public void getBook() {
        System.out.println("购买了Java类书籍");
    }
}

（3）、Python类书籍实现类

public class PythonBook implements Book{
    @Override
    public void getBook() {
        System.out.println("购买了Python类书籍");
    }
}

（4）、接口传递方式调用

public class PurchaseBook {
    private Book book;

    public void getBook(Book book){
        book.getBook();
    }

    public static void main(String[] args) {
        PurchaseBook purchaseBook = new PurchaseBook();
        purchaseBook.getBook(new JavaBook());
        purchaseBook.getBook(new PythonBook());
    }
}

3、构造器方式进行依赖注入

public class PurchaseBook {
    private Book book;

    PurchaseBook(Book book) {
        this.book = book;
    }

    public void getBook() {
        book.getBook();
    }

    public static void main(String[] args) {
        PurchaseBook purchaseBook = new PurchaseBook(new JavaBook());
        purchaseBook.getBook();
    }
}

4、set方式进行依赖注入

public class PurchaseBook {
    private Book book;

    public void setBook(Book book){
        this.book = book;
    }

    public void getBook(){
        book.getBook();
    }

    public static void main(String[] args) {
        PurchaseBook purchaseBook = new PurchaseBook();
        purchaseBook.setBook(new JavaBook());
        purchaseBook.getBook();
    }
}

三、 Simple Responsibility Principle单一职责原则

（一）、单一职责原则定义

​ 单一职责原则是指不要存在多一个一个导致类变更的原因。无论是接口、方法、或者类，我们在编写的时候都有可能会涉及到许多的业务逻辑，我们应该尽量将业务逻辑一致的放在一起，其他的进行分开，这样子就不会使一个接口、方法、类去处理多个职责，而在发生代码变更的时候相互影响。

​ 总体来说就是一个Class/Interface/Method只负责一项职责。

（二）、单一职责原则优点

​ （1）、降低类的功能复杂度

（2）、提高系统的可维护性

（3）、变更风险低

（三）、案例代码

​ 书的进货和卖出是两种业务，所以分成两个接口，后续业务扩展由两类接口伸展

进货

public interface EnterBook {
    void enterBook();
}

卖货

public interface SellingBook {
    void sellingBook();
}