设计模式的五大原则

开闭原则

开闭原则是面向对象设计中最基础的设计原则，它指导我们如何建立稳定灵活的系统。开闭原则可能是设计模式五项原则中定义最模糊的一个了，它只告诉我们对扩展开放，对修改关闭，可是到底如何才能做到对扩展开放，对修改关闭，并没有明确的告诉我们。以前，如果有人告诉我“你进行设计的时候一定要遵守开闭原则”，我会觉的他什么都没说，但貌似又什么都说了。因为开闭原则抽象。

生活中的开闭原则

例如说：
公司规定每天工作8小时，这是闭规则
但是弹性工作制，只需要遵守每天工作八小时即可，这么说虽然有些抽象

代码演示开闭原则

我拿课程举例子：
创建一个课程的接口ICourse

public interface ICourse {
    Integer getCourseId();//课程id
    String getName();//课程的名字
    Double getPrice();//课程的价格
    }

进行创建实现类，通过构造器进行赋值操作

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;
    }

    public Integer getCourseId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public Double getPrice() {
        return price;
    }

    @Override
    public String toString() {
        return "JavaCourse{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

虽然 System.out.println(javaCourse) 这个会阻塞，不建议使用，为了方便演示

public class TestCourse {
    public static void main(String[] args) {
        ICourse javaCourse = new JavaCourse(99, "设计模式", 38.5);
        System.out.println(javaCourse);
       // 结果  JavaCourse{id=99, name='设计模式', price=38.5}
    }
}

现在产品说我要新增一个价格打折，我也要原价，况且不能再原来的代码上改动，而且这个项目已经再跑了，如何去扩展那？为了不动原来的代码，容易出现错误不说，代码的可读性也不好
接下来见证奇迹：

public class JavaDisCountPrice extends JavaCourse {
    public JavaDisCountPrice(Integer id, String name, Double price) {
        super(id, name, price);
    }
    //获取原价
    public  Double getOriginPrice(){
        return super.getPrice();
    }
    //进行打折后的价格
    @Override
    public Double getPrice() {
        return super.getPrice()*0.8;
    }
}

public class TestCourse {
    public static void main(String[] args) {
        ICourse javaCourse = new JavaDisCountPrice(99, "设计模式", 38.5);
        JavaDisCountPrice javaDisCountPrice=(JavaDisCountPrice)javaCourse;
 System.out.println(javaDisCountPrice.getPrice()+":"+javaDisCountPrice.getOriginPrice());
    }
}

这样的话，又可以解耦，又能在原来的代码上进行扩展，而不动原来的业务逻辑！！

第二章节：依赖倒置原则

本文地址：https://blog.csdn.net/qq_42731358/article/details/111029720