软件工程中设计模式的七大原则及其目的：提高代码重用性与可扩展性

一、介绍

在软件工程领域，设计模式指的是针对软件设计中经常出现且普遍存在的各类问题所提出的解决办法。我们期望我们的软件能够具备复用性、高稳定性、扩展性、维护性以及代码重用性等特点，正因如此，便产生了设计模式这一概念。

设计模式常用的七大原则：

1）单一职责原则

2）接口隔离原则

3）依赖倒转原则

4）里氏替换原则

5）开闭原则ocp

6）迪米特法则

7）合成复用原则

设计模式的目的：

1）代码重用性（即：相同功能的代码，不用多次编写）

2）可读性（即：编程规范性，便于其他程序员的阅读和理解）

3）可扩展性（即：需要增加新的功能时，非常方便）

4）可靠性（即：增加新的功能后，对原来的功能没有影响）

5）使程序呈现高内聚、低耦合的特性

二、单一职责原则

对一个类来说，一个类应该只负责一项职责。

1）降低类的复杂度，一个类只负责一项职责；

2）提高类的可读性，可维护性；

3）降低变更引起的风险；

通常我们要遵守单一职责原则。只有逻辑很简单的时候，才可以在代码级违反这一原则；只有类中的方法数量很少，才能够在方法级别保持单一职责原则。

三、接口隔离原则

客户端不应该依赖那些它不需要的接口。这意味着一个类对于另一个类的依赖，应当建立在最为最小的接口之上。

改进前：

改进后：

四、依赖倒转原则

1）高层模块不应该依赖低层模块，二者都应该依赖其抽象；

2）抽象不应该依赖细节，细节应该依赖抽象；

3）依赖倒转（倒置）的中心思想是面相接口编程；

依赖倒转原则的设计理念在于，相较于细节的多变性，抽象的事物要稳定得多。以抽象为基础构建的架构，比以细节为基础的架构更为稳定。在 java 中，抽象表现为接口或抽象类，而细节则是具体的实现类。

使用接口或抽象类的目的在于制定规范，此规范不涉及具体操作，将展示细节的任务交给它们的实现类去完成。

改进前：

//方式1：实现Person接收消息的功能
class Person {
它会对传入的 Email 进行相关操作。
System 输出打印 email 获取到的信息。
    }
}

如果对方的状态发生了改变，那么 Person 就需要增加与之对应的接受方法。

解决思路：引入一个名为 IReceiver 的抽象接口，该接口用于表示接受者。通过这种方式，Person 类与 IReceiver 接口产生依赖关系。而其他的实现都属于接收的范畴，它们只需各自去实现 IReceiver 接口即可。如此一来，就能够符合依赖倒转原则。

改进后：对接口进行依赖，稳定性提高

//方式2
//定义接口
interface IReceiver {
    public String getInfo();
}
Email 实现了 IReceiver 接口。
    public String getInfo() {
    return "电子邮件信息：hello, world";
    }
}
class Person {
将接收操作传递给指定的接收者。接收者可以通过该方法接收到相关的信息或数据。具体的接收过程在该方法内部进行处理。
System 将接收器获取的信息予以打印。
    }
}
公共类 DependencyReceiver 。
主要方法是 public static void main，参数是 String[] args 。
        //客户端无需改变
        Person person = new Person();
        person.receive(new Email());
    }
}

依赖传递的三种方式

依赖传递有三种方式，这里只写调用方法
ChangHong 被创建了一个实例，即 ChangHong = new ChangHong();
1）通过接口传递实现依赖
创建了一个名为 openAndClose 的 OpenAndClose 对象。
openAndClose.open(changHong);
2）通过构造器进行依赖传递
openAndClose.open();
3）通过setter方法传递
OpenAndClose openAndClose = new OpenAndClose();
openAndClose 对长虹电视进行了设置操作。
openAndClose.open();

五、里氏替换原则

继承性说明：

父类中已实现好的方法，属于一种规范和契约。它虽然没有强制要求所有子类必须遵守，但如果子类随意对这些已实现的方法进行修改，就会对整个继承体系产生破坏。

5. 父类修改后，所有涉及到子类的功能都可能发生故障。

3）为了解决这一问题，我们提出里氏替换原则

里氏替换原则

如果一个类型为 T1 的对象 O1，存在类型为 T2 的对象 O2，并且当 T1 定义的所有程序 P 中，所有的对象 O1 都被替换为 O2 时，程序 P 没有任何变化。那么就可以说 T2 是 T1 的子类型。这意味着在所有引用基类的地方，都能够以透明的方式使用其子类的对象。

2）在使用继承时，子类尽量不要重写父类的方法。

比如说，A 类包含 m1 这个方法、m2 这个方法以及 m3 这个方法。B 类继承了 A 类，并且对 A 类的所有方法都进行了重写。如此一来，就无法实现透明化。

对此，我们能够让 B 类与 A 类一同继承一个更为基础的 base 类。这样做可以降低 AB 类的耦合性，并且把 AB 类的公共方法提升到 base 类当中。

六、开闭原则

介绍：

1）开闭原则是编程中最基础、最重要的设计原则。

一个软件实体，像是类、模块或者函数，应当对扩展保持开放的状态（针对提供方而言），而对修改则要处于关闭的状态（针对使用方而言）。以抽象来构建框架，凭借实现来扩展细节。

当软件需要发生变化的时候，要尽量凭借扩展软件实体的行为去达成变化，而不是依靠修改已经存在的代码来达成变化。

编程时遵循其他的一些原则，而使用设计模式的目的就是要遵循开闭原则。编程遵循其他原则，同时使用设计模式的目的是遵循开闭原则。遵循其他原则进行编程，以及使用设计模式，其目的都是遵循开闭原则。

改进前：

//用于绘图的类
class GraphicEditor {
    //接受Shape对象，根据type绘制不同的图形
公共的 void 方法用于绘制形状（Shape s）。
如果 s 的 m_type 等于 1 ，那么就绘制矩形 s 。
如果 s 的 m_type 等于 2 ，那么就绘制圆形 s 。
    }
公共的方法用于绘制矩形（Shape s）。
        System.out.println("绘制矩形");
    }
公共的 void 方法 drawCircle，其参数为 Shape 类型的 s。
        System.out.println("绘制圆形");
    }
}
//Shape类，基类
class Shape {
    int m_type;
}
Rectangle 类继承自 Shape 类。
    Rectangle(){
        super.m_type=1;
    }
}
class Circle extends Shape {
    Circle(){
        super.m_type=2;
    }
}
public classOcp {
    public static void main(String[] args) {
        //存在的问题
创建了一个 GraphicEditor 类的实例，名为 graphicEditor。
图形编辑器绘制形状，这个形状是一个矩形。图形编辑器绘制了一个新的矩形。新的矩形被图形编辑器绘制出来。
图形编辑器绘制形状（一个圆形）。
    }
}

存在的问题：

违反了设计模式的 OCP 原则，此原则是对扩展开放且对修改关闭。也就是说，当我们要给类增添新功能时，应尽量避免修改代码，或者尽可能减少对代码的修改。

思路：将 shape 类构建为抽象类，同时提供一个抽象的 draw 方法，由子类来进行具体实现。如此一来，当我们拥有新的图形时，只需让新的图形类继承 shape 类，并实现 draw 方法即可。而使用方的代码无需进行修改。

改进后：

//用于绘图的类
class GraphicEditor {
    //接受Shape对象，根据type绘制不同的图形
    public void drawShape(Shape s) {
        s.draw();
    }
}
//Shape类，基类
abstract class Shape {
    int m_type;
    
    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("绘制圆形");
    }
}
public classOcp {
    public static void main(String[] args) {
        //存在的问题
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new Rectangle());
        graphicEditor.drawShape(new Circle());
    }
}

七、迪米特法则

基本介绍：

1）一个对象应该对其他对象保持最少的了解

2）类与类的关系越密切，耦合度越大

迪米特法则亦称最少知道原则，意思是一个类对自身所依赖的类知晓的程度应尽可能低。对于被依赖的类，无论其多么复杂，都应尽量将其逻辑封装在类的内部。在类的外部，除了提供的 public 方法外，不应泄露任何信息。正因如此，陌生的类最好不要以局部变量的形式出现在类的内部。

注意事项：

1）迪米特法则的核心是降低类之间的耦合。

每个类减少了不必要的依赖，所以迪米特法则只是要求降低类间（对象间）的耦合关系，而非要求完全没有依赖关系。

八、合成复用原则

尽量使用合成、聚合的方式，而不是使用继承。

从 is a 变成 has a

九、总结