目前3年以上工作经验企业不仅仅需要实现业务的CRUD程序员，更希望的是可以优雅实现CRUD的程序员，那么设计模式就是实现优雅的入门，可以参考前人总结出来的经验套路，根据不同的场景采用不同的设计模式来实现，从而实现代码的稳定性、扩展性、可维护性等。
本系列文章旨在介绍23种设计模式，但是 设计原则 又是设计模式的基础，所以本系列文章从7种设计原则开始。本系列文章希望可以帮助到正在学习 设计模式 的同学，同时也是自己的一个总结提升，有想说的欢迎大家评论区留言。
开闭原则（Open Closed Principle，OCP）由勃兰特·梅耶（Bertrand Meyer）于1988年提出：软件实体应当对扩展开放，对修改关闭，这就是开闭原则的经典定义，开闭原则是我们编写程序时非常重要的一个原则，可以极大地提高我们程序的扩展性和维护性。开闭原则是面向对象编程中希望最终实现的一种效果。
软件实体包括
开闭原则的含义是：当应用的需求改变时，在不修改软件实体的源代码或者二进制代码的前提下，可以扩展模块的功能，使其满足新的需求。也就是 不修改原有功能的代码，不影响原有功能的使用前提下新增功能。
开闭原则是面向对象程序设计的终极目标，它使软件实体拥有一定的适应性和灵活性的同时具备稳定性和扩展性
可以通过“抽象约束、封装变化”来实现开闭原则，即通过接口或者抽象类为软件实体定义一个相对稳定的抽象层，而将相同的可变因素封装在相同的具体实现类中。
因为抽象灵活性好，适应性广，只要抽象的合理，可以基本保持软件架构的稳定。而软件中易变的细节可以从抽象派生来的实现类来进行扩展，当软件需要发生变化时，只需要根据需求重新派生一个实现类来扩展就可以了。
通过程序绘制不同种类的图形
public class Ocp {
public static void main(String[] args) {
GraphicEditor graphicEditor = new GraphicEditor();
graphicEditor.drawShape(new Circle());
graphicEditor.drawShape(new Rectangle());
}
}
// 绘制图形类
class GraphicEditor {
public void drawShape(Shape shape) {
if(shape.m_type == 1) {
System.out.println("绘制矩形");
}else if (shape.m_type == 2) {
System.out.println("绘制圆形");
}
}
}
// 图形基类
class Shape {
int m_type;
}
// 矩形类
class Rectangle extends Shape {
Rectangle() {
super.m_type = 1;
}
}
// 圆形类
class Circle extends Shape {
Circle() {
super.m_type = 2;
}
}
如果我们要新增一个三角形，需要修改的地方就比较多
public class Ocp {
public static void main(String[] args) {
GraphicEditor graphicEditor = new GraphicEditor();
graphicEditor.drawShape(new Circle());
graphicEditor.drawShape(new Rectangle());
}
}
// 绘制图形类
class GraphicEditor {
public void drawShape(Shape shape) {
shape.draw();
}
}
// 图形基类
abstract class Shape {
public abstract void draw();
}
// 矩形类
class Rectangle extends Shape {
@Override
public void draw() {
System.out.println("绘制矩形");
}
}
// 圆形类
class Circle extends Shape {
@Override
public void draw() {
System.out.println("绘制圆形");
}
}
迪米特法则（Law of Demeter，LoD）又叫作最少知道原则（Least Knowledge Principle，LKP)，产生于 1987 年美国东北大学（Northeastern University）的一个名为迪米特（Demeter）的研究项目，由伊恩·荷兰（Ian Holland）提出，被 UML 创始者之一的布奇（Booch）普及，后来又因为在经典著作《程序员修炼之道》（The Pragmatic Programmer）提及而广为人知。
迪米特法则的含义是：只与你的 直接朋友 交谈，不跟“陌生人”说话，通俗来讲就是如果两个软件实体无需直接通信，那么就不应当发生直接的调用。其目的在于降低耦合性，提高模块的独立性。
迪米特法则中的“朋友”是指：当前对象本身、当前对象的成员对象、当前对象所创建的对象、当前对象的方法参数等，这些对象同当前对象存在关联、聚合或组合关系，可以直接访问这些对象的方法。
迪米特法则要求限制软件实体之间通信的宽度和深度，正确使用迪米特法则将有以下两个优点。
但是，过度使用迪米特法则会使系统产生大量的中介类，从而增加系统的复杂性，使模块之间的通信效率降低。所以，在釆用迪米特法则时需要反复权衡，确保高内聚和低耦合的同时，保证系统的结构清晰。
从迪米特法则的定义和特点可知，它强调以下两点：
所以，在运用迪米特法则时要注意以下 6 点。
// 测试类
public class Demeter1 {
public static void main(String[] args) {
SchoolManager schoolManager = new SchoolManager();
schoolManager.printAllEmplyee(new CollegeManager());
}
}
// 学校总部员工
class Emplyee {
private String id;
public void setId(String id) {
this.id = id;
}
public String getId() {
return id;
}
}
// 学院的员工类
class CollegeEmplyee {
private String id;
public void setId(String id) {
this.id = id;
}
public String getId() {
return id;
}
}
// 学院员工类
class CollegeManager{
// 创建学院员工，并存储进List集合中
public List<CollegeEmplyee> getAllEmplyee() {
ArrayList<CollegeEmplyee> collegeEmplyees = new ArrayList<>();
for (int i = 0; i < 10; i++) {
CollegeEmplyee collegeEmplyee = new CollegeEmplyee();
collegeEmplyee.setId("学院员工的ID：" + i);
collegeEmplyees.add(collegeEmplyee);
}
return collegeEmplyees;
}
}
// 学校总部类
class SchoolManager {
// 创建学校总部员工，存储进List中
public List<Emplyee> getAllEmplyee() {
ArrayList<Emplyee> emplyees = new ArrayList<>();
for (int i = 0; i < 5; i++) {
Emplyee emplyee = new Emplyee();
emplyee.setId("学校总部员工ID：" + i);
emplyees.add(emplyee);
}
return emplyees;
}
// 打印信息，无论是学校上课的员工，还是总部的员工都是员工
void printAllEmplyee(CollegeManager sub) {
// 打印外派学校的员工信息
List<CollegeEmplyee> allEmplyee = sub.getAllEmplyee();
System.out.println("--------外派学校员工--------");
for (CollegeEmplyee collegeEmplyee : allEmplyee) {
System.out.println(collegeEmplyee.getId());
}
// 打印总部的员工信息
List<Emplyee> allEmplyee1 = this.getAllEmplyee();
System.out.println("--------学校总部员工--------");
for (Emplyee emplyee : allEmplyee1) {
System.out.println(emplyee.getId());
}
}
}
// 测试类
public class Demeter1 {
public static void main(String[] args) {
SchoolManager schoolManager = new SchoolManager();
schoolManager.printAllEmplyee(new CollegeManager());
}
}
// 学校总部员工
class Emplyee {
private String id;
public void setId(String id) {
this.id = id;
}
public String getId() {
return id;
}
}
// 外派学校的员工类
class CollegeEmplyee {
private String id;
public void setId(String id) {
this.id = id;
}
public String getId() {
return id;
}
}
// 外派学校的员工管理类
class CollegeManager{
public List<CollegeEmplyee> getAllEmplyee() {
ArrayList<CollegeEmplyee> collegeEmplyees = new ArrayList<>();
for (int i = 0; i < 10; i++) {
CollegeEmplyee collegeEmplyee = new CollegeEmplyee();
collegeEmplyee.setId("学院员工的ID：" + i);
collegeEmplyees.add(collegeEmplyee);
}
return collegeEmplyees;
}
// 自己的打印方法
public void printEmplyee() {
List<CollegeEmplyee> allEmplyee = this.getAllEmplyee();
System.out.println("--------分公司员工--------");
for (CollegeEmplyee collegeEmplyee : allEmplyee) {
System.out.println(collegeEmplyee.getId());
}
}
}
// 学校总部的员工管理类
class SchoolManager {
// 获取学校总部员工
public List<Emplyee> getAllEmplyee() {
ArrayList<Emplyee> emplyees = new ArrayList<>();
for (int i = 0; i < 5; i++) {
Emplyee emplyee = new Emplyee();
emplyee.setId("学校总部员工ID：" + i);
emplyees.add(emplyee);
}
return emplyees;
}
// 打印信息
void printAllEmplyee(CollegeManager sub) {
// 调用学院员工打印方法，因为CollegeManager 是方法的参数，所以是直接朋友
sub.printEmplyee();
List<Emplyee> allEmplyee1 = this.getAllEmplyee();
System.out.println("--------学校总部员工--------");
for (Emplyee emplyee : allEmplyee1) {
System.out.println(emplyee.getId());
}
}
}
合成复用原则（Composite Reuse Principle，CRP）又叫 组合/聚合复用原则（Composition/Aggregate Reuse Principle，CARP）。它要求在软件复用时，要尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。
如果要使用继承关系，则必须严格遵循里氏替换原则。合成复用原则同里氏替换原则相辅相成的，两者都是开闭原则的具体实现规范。
通常类的复用分为继承复用和合成复用两种，继承复用虽然有简单和易实现的优点，但它也存在以下缺点。
采用组合或聚合复用时，可以将已有对象纳入新对象中，使之成为新对象的一部分，新对象可以调用已有对象的功能，它有以下优点。
合成复用原则是通过将已有的对象纳入新对象中，作为新对象的成员对象来实现的，新对象可以调用已有对象的功能，从而达到复用
继承关系实现会产生很多子类，而且增加新的“动力源”或者增加新的“颜色”都要修改源代码，这违背了开闭原则，显然不可取。但如果改用组合关系实现就能很好地解决以上问题
这 7 种设计原则是软件设计模式必须尽量遵循的原则，是设计模式的基础。在实际开发过程中，并不是一定要求所有代码都遵循设计原则，而是要综合考虑人力、时间、成本、质量，不刻意追求完美，要在适当的场景遵循设计原则。这体现的是一种平衡取舍，可以帮助我们设计出更加优雅的代码结构。
实际上，这些原则的目的只有一个：降低对象之间的耦合，增加程序的可复用性、可扩展性和可维护性。
本章主要介绍了开闭原则、迪米特法则、合成复用原则，7种设计原则都已经介绍完毕，并通过原始方式和遵循设计原则方式实现。你一定要自己写一遍，多思考区别，再从宏观上，大的轮廓上【也就是我的项目中有很多很多类，并且后期还可能新增或者修改各种业务，从实际项目出发】去体会设计原则提出的意义。
设计原则第一讲
关注微信
