【设计模式】叩心自问：什么是设计模式？设计模式的目的是什么？设计模式依据哪些（七种）原则设计的？设计模式有哪些？分类？

最新推荐文章于 2023-01-06 10:09:34 发布

slow is fast.

最新推荐文章于 2023-01-06 10:09:34 发布

阅读量1.5k

点赞数 1

分类专栏：设计模式文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/wwj17647590781/article/details/122367178

版权

设计模式专栏收录该内容

10 篇文章 1 订阅

订阅专栏

aas

叩心自问 1 ：设计模式的目的是什么？

sadasd编写软件过程中，程序员面临着来自耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性等多方面的挑战，设计模式是为了让程序(软件)，具有更好的：

sadasd①：代码重用性 (即：相同功能的代码，不用多次编写)
sadasd②：可读性 (即：编程规范性, 便于其他程序员的阅读和理解)
sadasd③：可扩展性 (即：当需要增加新的功能时，非常的方便，称为可维护)
sadasd④：可靠性 (即：当我们增加新的功能后，对原来的功能没有影响)

使程序呈现 高内聚，低耦合 的特性。

叩心自问 2 ：什么是设计模式？

sadasd设计模式（design pattern）是对软件设计中 普遍存在（反复出现）的各种问题，所提出的解决方案。这个术语是由埃里希·伽玛（Erich Gamma）等人在1990年代从建筑设计领域引入到计算机科学的。设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。

叩心自问 3：设计模式依据哪些（七种）原则设计的？

sadasd① ：单一职责原则 sadasd② ：接口隔离原则sadasd③ ：依赖倒转(倒置)原则sadasd④ ：里氏替换原则

sadasd⑤ ：开闭原则sadasd⑥ ：迪米特法则sadasd⑦ ：合成复用原则

3.1、单一职责原则

sadasd对类来说的，即一个类应该只负责一项职责。如类A负责两个不同职责：职责1，职责2。当职责1需求变更而改变A时，可能造成职责2执行错误，所以需要将类A的粒度分解为 A1，A2。

sadasd【注】：通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则。

sadasd以交通工具对其进行代码分析：

public class singleresponsibility {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.run("摩托车");
        vehicle.run("自行车");
        vehicle.run("飞机");
    }
}

class Vehicle{  
    public void run(String vehicle){
        System.out.println(vehicle+"在陆地上运行...");
    }
}
-------------------------------------------------------------------------------------------
摩托车在陆地上运行...
自行车在陆地上运行...
飞机在陆地上运行...

sadasd通过上述结果我们就发现违反了单一职责，对代码改进：

public class singleresponsibility {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.run("摩托车");
        vehicle.runAir("飞机");
        vehicle.runWater("潜艇");
    }
}

class Vehicle{
    public void run(String vehicle){
        System.out.println("在陆地上运行...");
    }
    public void runAir(String vehicle){
        System.out.println(vehicle+"在天空上运行...");
    }

    public void runWater(String vehicle){
        System.out.println(vehicle+"在水中运行...");
    }
}
-------------------------------------------------------------------------------------------
在陆地上运行...
飞机在天空上运行...
潜艇在水中运行...

sad通过对原来的类进行修改，这里虽然没有在类这个级别上遵守单一职责原则，但是在方法级别上，仍然是遵守单一职责。

3.2、接口隔离原则

sadasd这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。 还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。
sadasdeg：类A通过接口1依赖类B，类C通过接口1依赖类D，如果接口1对于类A和类C来说不是最小接口，那么类B和D必须去实现他们不需要的方法，这样就违反了接口隔离原则。
在这里插入图片描述

package www.wwj.com;

public class Sergregation {
    public static void main(String[] args) {
        A a = new A();
        a.depend1(new B());
        a.depend2(new B());
        a.depend3(new B());
        C c = new C();
        c.depend1(new D());
        c.depend4(new D());
        c.depend5(new D());
    }
}
interface Interface1{
    void operation1();
    void operation2();
    void operation3();
    void operation4();
    void operation5();
}
class B implements  Interface1{
    @Override
    public void operation1() { System.out.println("B实现了operation1"); }
    @Override
    public void operation2() { System.out.println("B实现了operation2"); }
    @Override
    public void operation3() { System.out.println("B实现了operation3");}
    @Override
    public void operation4() { System.out.println("B实现了operation4");}
    @Override
    public void operation5() {System.out.println("B实现了operation5"); }
}
class D implements  Interface1{

    @Override
    public void operation1() { System.out.println("D实现了operation1"); }
    @Override
    public void operation2() { System.out.println("D实现了operation2");}

    @Override
    public void operation3() {System.out.println("D实现了operation3"); }

    @Override
    public void operation4() { System.out.println("D实现了operation4");}

    @Override
    public void operation5() { System.out.println("D实现了operation5");}
}

class A {   //A类通过接口Interface1依赖使用B类，但是只用到1、2、3方法
    public void depend1(Interface1 i){
        i.operation1();
    }
    public void depend2(Interface1 i){
        i.operation2();
    }
    public void depend3(Interface1 i){
        i.operation3();
    }
}

class C {   //A类通过接口Interface1依赖使用B类，但是只用到1、4、5方法
    public void depend1(Interface1 i){
        i.operation1();
    }
    public void depend4(Interface1 i){
        i.operation4();
    }
    public void depend5(Interface1 i){
        i.operation5();
    }
}
------------------------------------------------------------------------------------------------
B实现了operation1
B实现了operation2
B实现了operation3
D实现了operation1
D实现了operation4
D实现了operation5

sad改进：我们接口1分成几个独立的接口：

interface Interface1{
    void operation1();
}
interface Interface2{
    void operation2();
    void operation3();
}
interface Interface3{
    void operation4();
    void operation5();
}
class B implements  Interface1,Interface2{
    @Override
    public void operation1() { System.out.println("B实现了operation1"); }
    @Override
    public void operation2() { System.out.println("B实现了operation2"); }
    @Override
    public void operation3() { System.out.println("B实现了operation3");}
}
class D implements  Interface1,Interface3{

    @Override
    public void operation1() { System.out.println("D实现了operation1"); }

    @Override
    public void operation4() { System.out.println("D实现了operation4");}

    @Override
    public void operation5() { System.out.println("D实现了operation5");}
}

class A {   //A类通过接口Interface1依赖使用B类，但是只用到1、2、3方法
    public void depend1(Interface1 i){
        i.operation1();
    }
    public void depend2(Interface2 i){
        i.operation2();
    }
    public void depend3(Interface2 i){
        i.operation3();
    }
}

class C {   //A类通过接口Interface1依赖使用B类，但是只用到1、4、5方法
    public void depend1(Interface1 i){
        i.operation1();
    }
    public void depend4(Interface3 i){
        i.operation4();
    }
    public void depend5(Interface3 i){
        i.operation5();
    }
}

3.3、依赖倒转原则

sadasd这个是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。

sadasd依赖倒转原则(Dependence Inversion Principle)是指：

sadasd①：高层模块不应该依赖低层模块，二者都应该依赖其抽象
sadasd②：抽象不应该依赖细节，细节应该依赖抽象
sadasd③：依赖倒转(倒置)的中心思想是面向接口编程
sadasd④：依赖倒转原则是基于这样的设计理念：**相对于细节的多变性，抽象的东西要稳定的多。**以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在java中，抽象指的是接口或抽象类，细节就是具体的实现类。
sadasd⑤：使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成。

sadasd依赖关系传递的三种方式：①、接口传递 ②、构造方法传递 ③、setter方式传递。

sadasd【注】：低层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好。变量的声明类型尽量是抽象类或接口, 这样我们的变量引用和实际对象间，就存在一个缓冲层，利于程序扩展和优化。 继承时遵循里氏替换原则。

sadasd代码示例：

package www.wwj.com;

public class DependecyInversion {
    public static void main(String[] args){
        Person person = new Person();
        person.receive(new Email());
    }
}

class Email{
    public String getInfo(){
        return "电子邮件信息";
    }
}

class Person{
    public void receive (Email email){
        System.out.println(email.getInfo());
    }
}

sadasd改进：如果我们获取的信息不是邮件，而是微信短信等，则还要改Person中对应的方法，所以我们应该引入一个抽象的接口，表示接收者，让Person类与该接口发生依赖，代码如下：

package www.wwj.com;

public class DependecyInversion {
    public static void main(String[] args){
        Person person = new Person();
        person.receive(new Email());
        person.receive(new WeiXin());
    }
}
interface  IReceive{
    public String getInfo();
}
class Person{
    public void receive (IReceive iReceive){
        System.out.println(iReceive.getInfo());
    }
}
class Email implements IReceive {
    public String getInfo(){
        return "电子邮件信息";
    }
}
class WeiXin implements IReceive {
    public String getInfo(){
        return "微信信息";
    }
}
------------------------------------------------------------------------------------------------------
电子邮件信息
微信信息

sadasd实现依赖方式 1 : 通过接口传递

package www.wwj.com;

public class DependencyPass {
    public static void main(String[] args) {
        OpenAndClose openAndClose = new OpenAndClose();
        openAndClose.open(new ChangHong());
    }
}

interface IopenAndClose{
    public void open(ITV itv); //抽象方法，接收接口
}
interface ITV{
    public void play();
}

class ChangHong implements ITV{

    @Override
    public void play() {
        System.out.println("长虹电视机打开");
    }
}
class OpenAndClose implements IopenAndClose{

    @Override
    public void open(ITV itv) {
        itv.play();
    }
}
------------------------------------------------------------------------------------------------------
长虹电视机打开

sadasd通过上面代码我们可以发现：对于谁能打开电视，还是打开的什么电视，我们都是用接口来表示，然后分别由具体类来实现。

sadasd实现依赖方式 2 : 通过构造方法：

package www.wwj.com;

public class DependencyPass {
    public static void main(String[] args) {
        OpenAndClose openAndClose = new OpenAndClose(new ChangHong());
        openAndClose.open();
    }
}

interface IopenAndClose{
    public void open(); //抽象方法，接收接口
}
interface ITV{
    public void play();
}

class ChangHong implements ITV{

    @Override
    public void play() {
        System.out.println("长虹电视机打开");
    }
}
class OpenAndClose implements IopenAndClose{

    private ITV itv;

    public OpenAndClose(ITV itv) {
        this.itv = itv;
    }

    @Override
    public void open() {
        this.itv.play();
    }
}

sadasd实现依赖方式 3 : 通过setter方法传递：

package www.wwj.com;

public class DependencyPass {
    public static void main(String[] args) {
        OpenAndClose openAndClose = new OpenAndClose();
        openAndClose.setTv(new ChangHong());
        openAndClose.open();
    }
}

interface IopenAndClose{
    public void open(); //抽象方法，接收接口

    public void setTv(ITV itv);
}
interface ITV{
    public void play();
}

class ChangHong implements ITV{

    @Override
    public void play() {
        System.out.println("长虹电视机打开");
    }
}
class OpenAndClose implements IopenAndClose{

    private ITV itv;
    @Override
    public void open() {
        this.itv.play();
    }

    @Override
    public void setTv(ITV itv) {
        this.itv=itv;
    }
}
------------------------------------------------------------------------------------------
长虹电视机打开

3.4、里氏替换原则

sadasd里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。
saddsdsdssdsdsdsddddsdddddddddddddddddddddddddddddddddddddddddddddddddddddddddasd—— From Baidu 百科
sd原则：

sa①：所有引用基类的地方必须能透明地使用其子类的对象。
sa②：在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法
sd③：里氏替换原则告诉我们，继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖来解决问题。

sd【注】：继承在给程序设计带来便利的同时，也带来了弊端。比如使用继承会给程序带来侵入性，程序的可移植性降低，增加对象间的耦合性，如果-一个类被其他的类所继承，则当这个类需要修改时，必须考虑到所有的子类，并且父类修改后，所有涉及到子类的功能都有可能产生故障.

sadasd代码示例：

package www.wwj.com;

public class Liskov {
    public static void main(String[] args) {
        A1 a1 = new A1();
        System.out.println("3+8=" + a1.func(3,8));
        B1 b1 = new B1();
        System.out.println("8-3="+b1.func(8,3));
    }
}
class A1{
    public int func(int i , int j){
        return i+j;
    }
}
class  B1 extends  A1{
    public int func(int i , int j){
        return i-j;
    }
}
------------------------------------------------------------------------------------------
3+8=11                  8-3=5

sadasd修改：这时我们应让原来的父类和子类都集成一个更通俗的基类，原有的继承关系去掉，采用依赖，聚合，组合等关系替代：

package www.wwj.com;

public class Liskov {
    public static void main(String[] args) {
        B1 b1 = new B1();
        System.out.println("3+8=" + b1.func1(3,8));
    }
}

class Base{
	//把更加基础的方法和成员加到Base类
}

class A1 extends Base{
    public int func(int i , int j){
        return i+j;
    }
}
class  B1 extends  Base{
    private A1 a1 = new A1();

    public int func(int i , int j){
        return i-j;
    }

    //若想重新使用A的方法
    public int func1(int i , int j){
        return this.a1.func(i , j);
    }
}
------------------------------------------------------------------------------------------
3+8=11

3.5、开闭原则

sadasd开闭原则（Open Closed Principle）是编程中最基础、最重要的设计原则。

sadasd一个软件实体如类，模块和函数应该对扩展（提供方）开放，对修改(使用方)关闭。用抽象构建框架，用实现扩展细节。

sadasd当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。

sadasd编程中遵循其它原则，以及使用设计模式的目的就是遵循开闭原则。

sadasd代码示例：在这里插入图片描述

package www.wwj.com;

public class Ocp {
    public static void main(String[] args) {
        Circle circle = new Circle();
        Rectangle rectangle = new Rectangle();
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShap(circle);
        graphicEditor.drawShap(rectangle);
    }
}

class GraphicEditor{
    public void drawShap(Shape s){
        if(s.m_type == 1){
            drawRectangle(s);
        }else if(s.m_type == 2){
            drawCircle(s);
        }
    }
    public void drawCircle(Shape s){
        System.out.println("绘制圆形");
    }
    public  void drawRectangle(Shape s){
        System.out.println("绘制三角形");
    }
}

class Shape{
    int m_type;
}
class Circle extends Shape {
    Circle(){
        super.m_type = 2;
    }
}
class Rectangle extends Shape{
    Rectangle(){
        super.m_type = 1;
    }
}
------------------------------------------------------------------------------------------------------
绘制圆形
绘制三角形

sadasd改进：上述代码虽然好理解，但是违反了开闭原则，因为如果我们想绘制矩形等都需要修改已有的代码，而这时我们应该把Shape形改成抽象类，并提供一个抽象的draw方法，让子类去实现即可。

package www.wwj.com;

public class Ocp {
    public static void main(String[] args) {
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new Circle());
        graphicEditor.drawShape(new Rectangle());
        graphicEditor.drawShape(new OtherGraphic());
    }
}

class GraphicEditor{
    public void drawShape(Shape s){
        s.draw();
    }
}

abstract class Shape{
    public abstract void draw();
}
class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}
class Rectangle extends Shape{
    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}
//新增
class OtherGraphic extends Shape{
    @Override
    public void draw() {
        System.out.println("绘制其他图形");
    }
}

3.6、迪米特法则

sadasd①：一个对象应该对其他对象保持最少的了解
sadasd②：类与类关系越密切，耦合度越大
sadasd③：迪米特法则(Demeter Principle)又叫最少知道原则，即一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部。对外除了提供的public 方法，不对外泄露任何信息。
sadasd④：迪米特法则还有个更简单的定义：只与直接的朋友通信
sadasd⑤：直接的朋友： 每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖，关联，组合，聚合等。其中，我们称出现成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接的朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部。

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

sadasd原则是尽量使用合成/聚合的方式，而不是使用继承。

叩心自问 4：什么是UML?

sadasdUML——Unified modeling language UML (统一建模语言)，是一种用于软件系统分析和设计的语言工具，它用于帮助软件开发人员进行思考和记录思路的结果。

sadasdUML本身是一套符号的规定，就像数学符号和化学符号一样，这些符号用于描
述软件模型中的各个元素和他们之间的关系，比如类、接口、实现、泛化、依赖、组合、聚合等。
sadadsdsdsdsdsdsdsd 在这里插入图片描述

4.1 UML图分类

sadasd①：用例图
sadasd②：静态结构图：类图，对象图，包图，组件图，部署图
sadasd③：动态行为图：交互图（时序图与协作图）、状态图、活动图

sadasd【注】：类图是描述类与类之间的关系的，是UML图中最核心的。类之间的关系有：依赖、泛化（继承）、实现、关联、聚合与组合。

sadasd1、依赖：只要是在类中用到了对方，那么他们之间就存在依赖关系。

sadasd2、泛化（继承）：泛化关系实际上就是继承关系，他是依赖关系的特例。

sadasd3、实现：实现关系实际上就是A类实现B接口，他是依赖关系的特例

sadasd4、关联：关联关系实际上就是类与类之间的联系，他是依赖关系的特例

sadasd5、聚合：聚合关系（Aggregation）表示的是整体和部分的关系，整体与部分可以分开。
sadsdsd 在这里插入图片描述
sadasd6、组合：也是整体与部分的关系，但是整体与部分不可以分开。
sadsddsdsdssd

叩心自问 5：设计模式分类？

sadasd总体来说分成三大类：
在这里插入图片描述
sadasd根据作用范围来分：

slow is fast.

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
3
评论
【设计模式】叩心自问：什么是设计模式？设计模式的目的是什么？设计模式依据哪些（七种）原则设计的？设计模式有哪些？分类？

aas 叩心自问 1 ：设计模式的目的是什么？叩心自问 2 ：什么是设计模式？叩心自问 3：设计模式依据哪些（七种）原则设计的？ 3.1、单一职责原则 3.2、接口隔离原则 3.3、依赖倒转原则 3.4、单一职责原则 3.5、单一职责原则 3.6、单一职责原则 3.7、单一职责原则叩心自问 1 ：设计模式的目的是什么？sadasd编写软件过程中，程序员面临着来自耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性等多方面的挑战，设计模式是为了让程序(软件)，具有更好的：sadasd①.
复制链接

扫一扫