七大设计模式原则

1、开闭原则（Open-closed Principle）

开闭原则，是面向设计中最基础的设计原则。
一个软件实体类、模块、函数应该对扩展开放、对修改关闭。
强调的是用抽象构建框架，用实现扩展细节。可以提高软件系统的可复用性和可维护性。

实例：

public interface ICourse {

    Integer getId();

    String getName();

    Double getPrice();

}

public class JavaCourse implements ICourse{

    private Integer id;

    private String name;

    private Double price;

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

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

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

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

public class JavaDiscountCourse extends JavaCourse {

    public JavaDiscountCourse(Integer id, String name, Double price) {
        super(id, name, price);
    }

    public Double getOriginPrice() {
        return super.getPrice();
    }

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

}

2、本末倒置原则（Dependence Inversion Principle）

高层模块不应该依赖底层模块，二者都应该依赖其抽象。
抽象不应该依赖细节，细节应该依赖抽象。
本末倒置可以减少类与类之间的耦合性，提高系统的稳定性，提高代码的可读性和可维护性，降低修改程序造成的风险。

实例：

public interface ICourse {

    void study();

}

public class JavaCourse implements ICourse{

    @Override
    public void study() {
        System.out.println("学习Java");
    }

}

public class PythonCourse implements ICourse{

    @Override
    public void study() {
        System.out.println("学习Python");
    }

}

/**
 * 方式一：依赖注入，每次学习一个新课程就多创建一个类
 */
public class PersonOne {

    public void study(ICourse iCourse){
        iCourse.study();
    }

    public static void main(String[] args) {
        PersonOne personOne = new PersonOne();
        personOne.study(new JavaCourse());
        personOne.study(new PythonCourse());
    }
}

/**
 * 方式二：构造器注入，调用时每次都要创建实例
 */
public class PersonTwo {

    private ICourse iCourse;

    public PersonTwo(ICourse iCourse) {
        this.iCourse = iCourse;
    }

    public void study() {
        iCourse.study();
    }

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

/**
 * 方式三：Setter方式注入
 */
public class PersonThree {

    private ICourse iCourse;

    public void setCourse(ICourse iCourse) {
        this.iCourse = iCourse;
    }

    public void study() {
        iCourse.study();
    }

    public static void main(String[] args) {
        PersonThree personTwo = new PersonThree();
        personTwo.setCourse(new JavaCourse());
        personTwo.study();
    }
}

3、单一职责（Simple Responsibility Principle）

不要存在多于一个导致类变更的原因
一个对象应该只包含单一的职责，并且该职责被完整地封装在一个类中。

/**
 * course存在两种处理逻辑，这个地方修改代码
 */
public class Course {
    public void study(String name){
        if("直播".equals(name)){
            System.out.println("不能快进");
        }else {
            System.out.println("2xx倍速");
        }
    }

    public static void main(String[] args) {
        Course course = new Course();
        course.study("直播");
    }

}

修改下的代码，这样把两个课程给分开控制。

public class LiveCourse {
    public void study(String name){
        System.out.println("不能快进");
    }
}

public class ReplayCourse {
    public void study(String name){
        System.out.println("2xx倍速");
    }
}

public class Test {

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

        ReplayCourse replayCourse = new ReplayCourse();
        replayCourse.study("测试");
    }

}`在这里插入代码片`

4、接口隔离原则（Interface Segregation Principle）

用多个专门的接口，而不使用单一的接口，客户端不应该依赖它不需要的接口

• 一个类对一类的依赖应该建立在最小的接口上
• 建立单一接口，不要建立庞大的接口
• 尽量细化接口，接口中的方法尽量少

实例:

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

public class Bird implements Animal{
    @Override
    public void eat() {

    }

    @Override
    public void fly() {

    }

    @Override
    public void swimming() {

    }
}

public class Dag implements Animal{
    @Override
    public void eat() {

    }

    @Override
    public void fly() {

    }

    @Override
    public void swimming() {

    }
}

当dog不能飞，鸟儿不能游泳的时候，这个方法就会空，这时候需要根据动物行为设计不同的接口

public interface EatAnimal {

    void eat();

}

public interface FlyAnimal {

    void fly();

}

public interface SwimmingAnimal {

    void swimming();

}

public class Dog implements SwimmingAnimal, EatAnimal{
    @Override
    public void eat() {

    }

    @Override
    public void swimming() {

    }
}

5、迪米特法则（Law of demeter LoD）

一个对象应该对其他对象保持最少的了解。只和朋友交流，不喝陌生人说话。
出现在成员变量、方法的输入、输出参数中的类都可以称为成员朋友类，出现在方法体内内部的类不属于朋友类。

实例：

public class Course {
}

public class Employee {
    public void checkNumOfCourse(List<Course> courseList) {
        System.out.println("课程数量" + courseList.size());
    }
}

public class Leader {

    public void CommandCheckNumber(Employee employee){
        List<Course> courseList = new ArrayList<Course>();
        for (int i = 0; i < 20; i++) {
            courseList.add(new Course());
        }
        employee.checkNumOfCourse(courseList);
    }

    public static void main(String[] args) {
        Leader leader = new Leader();
        Employee employee = new Employee();
        leader.CommandCheckNumber(employee);
    }
}

根据迪米特法则，Leader只想要结果，不需要和Course有直接的接触，所以这个地方修改

public class EmployeeCp {
    public void checkNumOfCourse() {
        List<Course> courseList = new ArrayList<Course>();
        for (int i = 0; i < 20; i++) {
            courseList.add(new Course());
        }
        System.out.println("课程数量" + courseList.size());
    }
}

public class LeaderCp {

    public void CommandCheckNumber(EmployeeCp employee){
        employee.checkNumOfCourse();
    }

    public static void main(String[] args) {
        LeaderCp leader = new LeaderCp();
        EmployeeCp employee = new EmployeeCp();
        leader.CommandCheckNumber(employee);
    }
}

6、里氏替换原则（Liskov Substitution Priciple）

如果针对一个类型为T1的对象O1，都有类型T2的对象O2，使得以T1定义的所有程序P在所有的对象O1都替换成O2时，程序P的行为没有发生变化，那么类型T2还是类型T1的子类型。
1）子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法
2）子类仲可以增加自己特有的方法
3）当子类的方法重载父类的方法时，方法的前置条件（入参）要比父类方法的输入参数更宽松
4）当子类的方法实现
父类的方法时，方法的后置条件（输出/返回值）要比父类更严格或相等

优点：
1）约束继承泛滥，开闭原则的一种体现
2）加签程序的健壮性，同时变更也可以做到好的兼容，提高程序的维护性、扩展性，降低需求变更时的风险

实例：

public class Rectangle {

    private Long height;
    private Long width;

    public Long getHeight() {
        return height;
    }

    public Long getWidth() {
        return width;
    }

    public void setHeight(Long height) {
        this.height = height;
    }

    public void setWidth(Long width) {
        this.width = width;
    }
}

public class Square extends Rectangle {

    private Long length;

    public Long getLength() {
        return length;
    }

    public void setLength(Long length) {
        this.length = length;
    }

    @Override
    public Long getHeight() {
        return getLength();
    }

    @Override
    public void setHeight(Long height) {
        setLength(height);
    }

    @Override
    public Long getWidth() {
        return getLength();
    }

    @Override
    public void setWidth(Long width) {
        setLength(width);
    }

}

public class Test {
    public static void resize(Rectangle rectangle){
        while (rectangle.getWidth() >= rectangle.getHeight()){
            rectangle.setHeight(rectangle.getHeight()+1);
            System.out.printf("width: %s, height:%s", rectangle.getWidth(), rectangle.getHeight());
        }
        System.out.printf("width: %s, height:%s", rectangle.getWidth(), rectangle.getHeight());
    }

    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle();
        rectangle.setWidth(20L);
        rectangle.setHeight(10L);
        resize(rectangle);

		//死循环
        Square square = new Square();
        square.setLength(10L);
        resize(square);
    }
}

当是正方形的时候，陷入死循环，违背里氏替换原则，父类替换成子类后结果不是预期。
修改代码，创建一个抽象四边形

public interface QuadRectangle {
    Long getWidth();

    Long getHeight();
}

public class RectangleCp implements QuadRectangle{

    private Long height;
    private Long width;

    public Long getHeight() {
        return height;
    }

    public Long getWidth() {
        return width;
    }

    public void setHeight(Long height) {
        this.height = height;
    }

    public void setWidth(Long width) {
        this.width = width;
    }
}

public class SquareCp implements QuadRectangle {

    private Long length;

    public Long getLength() {
        return length;
    }

    public void setLength(Long length) {
        this.length = length;
    }

    @Override
    public Long getHeight() {
        return getLength();
    }

    @Override
    public Long getWidth() {
        return getLength();
    }

}

7、合成复用原则（Composite Reuse Principle）

尽量使用对象组合（has-a）/聚合（contain-a），而不是继承达到软件复用的目的。
继承叫做“白箱复用”，把所有的实现细节暴露给子类
组合/聚合称为“黑箱复用”，对类以外的对象是无法获取到实现细节的

实例：

public class DBConnection {
    public String getConnection() {
        return "MySql连接";
    }
}

public class ProductDao {

    private DBConnection dbConnection;

    public void setDbConnection(DBConnection dbConnection){
        this.dbConnection = dbConnection;
    }

    public void addProduct(){
        String conn = dbConnection.getConnection();
        System.out.println("创建商品");
    }

}

如果这时候不只是mysql还有其他类型的数据库，违反开闭原则
修改代码：文章来源地址https://www.toymoban.com/news/detail-606819.html

public abstract class DBConnectionCp {
    public abstract String getConnection();
}

public class MysqlConnection extends DBConnection{
    @Override
    public String getConnection() {
        return "mysql";
    }
}

public class OracleConnection extends DBConnection{
    @Override
    public String getConnection() {
        return "Oracle";
    }
}

到了这里，关于七大设计模式原则的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！