还记得设计模式中称霸武林的的六大设计原则吗？

🍁 作者：知识浅谈，CSDN签约讲师，CSDN博客专家，华为云云享专家，阿里云星级博主
📌 擅长领域：全栈工程师、爬虫、ACM算法
💒 公众号：知识浅谈
🔥 联系方式vx：zsqtcc

🤞设计模式的六大设计原则总结🤞

学习设计模式之前需要先了解软件设计的六大原则，毕竟这是软件设计的底层规律，对之后设计模式的学习有很大的帮助。

正菜来了⛳⛳⛳

🎈开闭原则(OCP)

一般认为最早提出的开闭原则(OCP)是《面向对象软件构造》中给出的。

在面向对象编程领域中，开闭原则规定软件中的对象、类、模块和函数对扩展应该是开放的，但对于修改是封闭的。

开闭原则的思想可以理解为面向抽象编程。

public interface UserDao{
	void insert();
}
public class UserDaoImpl1 implments UserDao{
	public void insert(){
		System.out.println("test1");
	};
}

如果有其他需求，需要输出另一个 “test2”
正确的做法:不去修改UserDaoImpl1 而是创建一个UserDaoImpl2

public class UserDaoImpl2 implments UserDao{
	public void insert(){
		System.out.println("test2");
	};
}

🎈单一职责原则

单一职责原则(Single Responsibility Principle,SRP)又称单一功能原则。
如果需要开发的一个功能需求不是一次性的，且随着业务发展的不断变化而变化，那么当一个Class类负责超过两个及以上的职责时，就在需求的不断迭代、实现类持续扩张的情况下，就会出现难以维护、不好扩展、测试难度大和上线风险高等问题。

interface A{
    void watchTv();
}
class A1 implements A{
    @Override
    public void watchTv() {
        System.out.println("A1");
    }
}

class A2 implements A{
    @Override
    public void watchTv() {
        System.out.println("A2");
    }
}

//而不是在一个类里使用多个判断解决多个问题

class AA implements A {
    @Override
    public void watchTv() {
        if("aa".equals("aa")){
            System.out.println("A1");
        }else {
            System.out.println("A2");
        }
    }
}

🎈里氏替换原则

继承必须确保超类所拥有的性质在子类中仍然成立
简单来说，子类可以扩展父类的功能，但不能改变父类原有的功能。也就是说：当子类继承父类时，除添加新的方法且完成新增功能外，尽量不要重写父类的方法。这句话包括了四点含义：

• 子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法，保证了稳定性。
• 子类可以增加自己特有的方法。
• 当子类的方法重载父类的方法时，方法的前置条件（即方法的输入参数）要比父类的方法更宽松。
• 当子类的方法实现父类的方法(重写、重载或实现抽象方法)时，方法的后置条件（即方法的输出或返回值）要比父类的方法更严格或与父类的方法相等。

总结一下：就是父类和子类相同的方法，保证行为严格一致性，能够互相替换。

🎈迪米特法则

迪米特法则(Law of Demeter,LoD)又称为最少知道原则(Least Knowledge Principle,LKP),是指一个对象类对于其他对象类来说，知道得越少越好。也就是说，两个类之间不要有过多的耦合关系，保持最少关联性。
举个🌰：
校长类，教师类，学生类
校长需要知道一个班级所有学生的平均成绩。
校长对象需要调用教师对象去计算，只需要教师对象返回一个平均成绩即可，而不是需要教师返回所有的学生成绩让小张自己去计算平均成绩，就是为了让校长知道最少教师对象知道的属性。

🎈接口分离原则

一个类对另一个类的依赖应该建立在最小的接口上
接口隔离原则(Interface Segregation Principle,ISP)要求程序员尽量将臃肿庞大的接口拆分成更小的和更具体的接口，让接口中只包含客户感兴趣的方法。
举个🌰：

interface A{
    void printA();
}
尽量不用上
interface A1 {
    void printA1();
}
interface A2 {
    void printA2();
}
interface A3 {
    void printA3();
}
interface A4 {
    void printA4();
}

🎈依赖倒置原则

• 依赖倒置原则(Dependence Inversion Principle,DIP)是指在设计代码架构哒高层模块不应该依赖于底层模块，二者都应该依赖于抽象。抽象不应该依赖于细节，细节应该依赖于抽象。
• DIP就是我们常说的“面向接口编程”。
• 依赖倒置原则是实现开闭原则的重要途径之一，它降低了类之间的耦合，提高了系统的稳定性和可维护性，同时这样的代码一般更易读，且便于传承。

举个🌰：

interface A {
    void printA();
}
class A1 implements A{
    @Override
    public void printA() {
        System.out.println("A1");
    }
}

class A2 implements A{
    @Override
    public void printA() {
        System.out.println("A2");
    }
}

class Result{
    public static void main(String[] args) {
        A1 a1 = new A1();
        A2 a2 = new A2();
        print(a1);
        print(a2);
        
    }
    public static void print(A a) {  
        a.printA();
    }
}

最主要的在Result中的print方法中，使用A接受的而不是用A1，A2这两个类接收的，依赖倒置依赖的是抽象的接口。

🍚总结

以上就是六大设计原则，希望对你有所帮助，不求赞，一切随缘。