设计模式（一）

最新推荐文章于 2024-08-24 08:08:52 发布
最新推荐文章于 2024-08-24 08:08:52 发布
阅读量56 收藏
点赞数
文章标签： 设计模式 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53294082/article/details/129683376
版权

设计模式

设计模式的用处

image-20230523173408110

image-20230523174127080

image-20230523174258195

设计模式七大原则

image-20230523175307567

单一职责原则

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

  • 单一职责原则注意事项和细节

    • 1)降低类的复杂度，一个类只负责一项职责。
    • 2)提高类的可读性，可维护性
    • 3)降低变更引起的风险
    • 4)通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职
    • 原则：只有类中方法数量足够少，可以在方法级别保持单一职责原则
package com.lmx.principle;

/**
 * 单一职责原则
 */
public class Singleness {

    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();

        vehicle.run("汽车");
        vehicle.runAir("飞机");
        vehicle.runWarter("轮船");
    }
}

/**
 * 一般情况下一个类负责一件事
 * 当类足够简单时，可在方法层面上进行划分
 */

class Vehicle {
    public void run(String s) {
        System.out.println(s + "在公路上跑");
    }

    public void runAir(String s) {
        System.out.println(s + "在天空上飞");
    }

    public void runWarter(String s) {
        System.out.println(s + "在水中行驶");
    }
}

接口隔离原则

客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上

  • 1)类A通过接口Interface1依赖类B,类C通过接口Interface1依赖类D,如果接口
    Interface1对于类A和类c来说不是最小接口，那么类B和类D必须去实现他们不
    需要的方法
  • 2)将接口Interface1拆分为独立的几个接口，类A和类c分别与他们需要的接口建立
    依赖关系。也就是采用接口隔离原则
  • 3)接口Interface1中出现的方法，根据实际情况拆分为三个接口
  • 4)代码实现

image-20230523195205989

package com.lmx.principle.Interfaceisolation;

public class InterfaceIsolation {
    public static void main(String[] args) {

    }


}

interface interfance1 {
    void operation1();

    void operation2();

    void operation3();

    void operation4();

    void operation5();
}

class B implements interfance1 {

    @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 interfance1 {

    @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 {
    public void dependcy1(interfance1 interfance1) {
        interfance1.operation1();
    }

    public void dependcy2(interfance1 interfance1) {
        interfance1.operation2();
    }

    public void dependcy3(interfance1 interfance1) {
        interfance1.operation3();
    }
}




class C {
    public void dependcy1(interfance1 interfance1) {
        interfance1.operation1();
    }

    public void dependcy4(interfance1 interfance1) {
        interfance1.operation4();
    }

    public void dependcy5(interfance1 interfance1) {
        interfance1.operation5();
    }
}

  • 按照接口隔离之后的实现方法‘

    package com.lmx.principle.Interfaceisolation;

public class InterfaceIsolationnew {
    public static void main(String[] args) {
        A a = new A();
        a.dependcy1(new B());
        a.dependcy2(new B());

        C c = new C();
        c.dependcy1(new D());
    }


}

interface interfance21 {
    void operation1();




}


interface interfance22 {
    void operation2();

    void operation3();


}

interface interfance23 {
    void operation4();

    void operation5();


}


class B1 implements interfance21, interfance22 {

    @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 D1 implements interfance21, interfance23 {

    @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 A1 {
    public void dependcy1(interfance21 interfance1) {
        interfance1.operation1();
    }

    public void dependcy2(interfance22 interfance1) {
        interfance1.operation2();
    }

    public void dependcy3(interfance22 interfance1) {
        interfance1.operation3();
    }
}


class C1 {
    public void dependcy1(interfance21 interfance1) {
        interfance1.operation1();
    }

    public void dependcy4(interfance23 interfance1) {
        interfance1.operation4();
    }

    public void dependcy5(interfance23 interfance1) {
        interfance1.operation5();
    }
}

image-20230523200448044

  • 按照接口隔离原则，将一个interfance拆分为3个接口，A、C实现对应的接口

依赖倒转原则

image-20230524194527981

image-20230524194717325

  • 依赖倒转原则的注意事项和细节
    • 1)低层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好」
    • 2)变量的声明类型尽量是抽象类或接口，这样我们的变量引用和实际对象间，就存在
      一个缓冲层，利于程序扩展和优化
    • 3)继承时遵循里氏替换原则
public class DependencyInversion {
    public static void main(String[] args) {
        Email email = new Email();

        Person person = new Person();

        person.recieve(email);
    }
}


class Email {
    public String message() {
        return "邮件消息";
    }
}

class Person {

    public void recieve(Email email) {
        System.out.println(email.message());
    }
}
  • 存在问题：
    • person对于Email的依赖过强，当preson后续需要接受微信消息、短信消息等时，需要重写recieve方法
package com.lmx.principle.dependencyInversion;

/**
 * 依赖倒置原则的相关依赖
 * 案例：preson接收消息的数据
 */
public class DependencyInversion {
    public static void main(String[] args) {
        Email email = new Email();

        Person person = new Person();
        person.recieve(email);
        Wx wx = new Wx();
        person.recieve(wx);
    }
}


interface Message {
    public String message();
}

class Email implements Message {
    public String message() {
        return "邮件消息";
    }
}

class Wx implements Message {
    public String message() {
        return "微信消息";
    }
}

class Person {

    public void recieve(Message message) {
        System.out.println(message.message());
    }
}
  • 未解决上述问题，将recieve的方法参数，修改为接口，不同的消息类型实现接口

依赖替换原则三种实现：

image-20230524194926218

//  接口传递
//class Person {
//
//    public void recieve(Message message) {
//        System.out.println(message.message());
//    }
//}

  构造方法调用
//class Person {
//    
//    private Message message;
//
//    public Person(Message message) {
//        this.message = message;
//    }
//
//    public void recieve() {
//        System.out.println(this.message.message());
//
//    }
//}


//  set方法调用
//class Person {
//
//    private Message message;
//
//    public void setMessage(Message message) {
//        this.message = message;
//    }
//
//    public void recieve() {
//        System.out.println(this.message.message());
//
//    }
//}

里氏替换原则

  • 在使用父类的地方，将父类换成子类，程序仍然运行无误

image-20230524201555069

image-20230524200943421

package com.lmx.principle.leeb;

/**
 * 里氏替换原则
 */
public class Leeb {
    public static void main(String[] args) {
        A a = new A();

        System.out.println("11-3" + a.func1(11, 3));


        B b = new B();
        System.out.println("11-3" + b.func1(11, 3));
        System.out.println("11+3-9" + b.func2(11, 3, 9));
    }
}

class A {
    public Integer func1(int a, int b) {
        return a - b;
    }
}

class B extends A {
    public Integer func1(int a, int b) {
        return a + b;
    }

    public Integer func2(int a, int b, int c) {
        return func1(a, b) - c;
    }
}
  • 问题：
    • B类继承了A类，并且重写了A类的方法，造成了在调用B类方法时造成了错误

image-20230524201318009·

image-20230524201742817

package com.lmx.principle.leeb;

/**
 * 里氏替换原则
 */
public class Leeb {
    public static void main(String[] args) {
        A a = new A();

        System.out.println("11-3" + a.func1(11, 3));


        B b = new B();
        System.out.println("11-3" + b.func3(11, 3));
        System.out.println("11+3-9" + b.func2(11, 3, 9));
    }
}


class Base {

}

class A extends Base {
    public Integer func1(int a, int b) {
        return a - b;
    }
}

class B extends Base {
    private A a = new A();

    public Integer func1(int a, int b) {
        return a + b;
    }

    public Integer func2(int a, int b, int c) {
        return func1(a, b) - c;
    }

    public Integer func3(int c, int b) {
        return a.func1(c, b);
    }
}

开闭原则

image-20230524202502614

package com.lmx.principle.openandclose;

/**
 * 开闭原则
 */
public class OpenClose {
    public static void main(String[] args) {
        Cicle cicle = new Cicle();

        Draw draw = new Draw();
        draw.draw(cicle);

        Sanjiao sanjiao = new Sanjiao();
        draw.draw(sanjiao);
    }


}

class Draw {

    public void draw(Shape shape) {
        shape.draw();


    }
}


abstract class Shape {
    private Integer type;

    public Shape(Integer type) {
        this.type = type;
    }

    abstract public void draw();
}


class Cicle extends Shape {
    public Cicle() {
        super(1);
    }

    @Override
    public void draw() {
        System.out.println("画圆");
    }
}

class Sanjiao extends Shape {
    public Sanjiao() {
        super(2);
    }

    @Override
    public void draw() {
        System.out.println("画三角");
    }
}
飘零书剑
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MVC设计模式
heishuiloveyou的博客
11-21 3992
需要注意的是：MVC三层结构与软件的三层结构是有区别的。用户首先在界面中进行人机交互，然后请求发送到控制器，控制器根据请求类型和请求的指令发送到相应的模型，模型可以与数据库进行交互，进行增删改查操作，完成之后，根据业务的逻辑选择相应的视图进行显示，此时用户获得此次交互的反馈信息，用户可以进行下一步交互，如此循环。Serlvet作为控制器，用来接收用户提交的请求，然后获取请求中的数据，将之转换为业务模型需要的数据模型，然后调用业务模型相应的业务方法进行更新，同时根据业务执行结果来选择要返回的视图。
一种设计模式一种设计模式
09-12
一种设计模式一种设计模式实现，单体
设计模式之代理模式分析使用
张彦峰的博客
05-21 164万+
代理模式原理和使用分析总结
快速理解设计模式：单例模式深入
热门推荐
张彦峰的博客
04-21 169万+
单例模式是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。实现方式介绍分析：饿汉式单例模式+懒汉式单例模式（双重检查锁）+静态内部类实现单例模式+注册式单例模式
大话设计模式
PowerMan_Frank
04-25 3259
大话设计模式
嵌入式设计模式
qq_36969440的博客
06-24 3902
嵌入式 嵌入式的标签多为：低配，偏硬件，底层，资源紧张，代码多以C语言，汇编为主，代码应用逻辑简单。但随着AIOT时代的到来，局面组件改变。芯片的性能资源逐渐提升，业务逻辑也逐渐变得复杂，相对于代码的效率而言，代码的复用可移植性要求越来越高，以获得更短的项目周期 和更高的可维护性。下面是AIOT时代嵌入式设备的常见的软件框架。 设计模式 设计模式的标签：高级语言 ，高端，架构等。在AIOT时代，设计模式与嵌入式能擦出怎样的火花？设计模式可描述为： 对于某类相似的问题，经过前人的不断尝试，总结出了处
设计模式简介
qq_25409421的博客
06-09 3万+
本文介绍Java设计模式的种类划分，以及介绍了设计模式的原则
Go语言常用设计模式
kuokay的博客
05-05 2545
前言 在软件开发中，经常会遇到各种各样的编码场景，这些场景往往重复发生，因此具有典型性。针对这些典型场景，我们可以自己编码解决，也可以采取更为省时省力的方式：直接采用设计模式。 设计模式是啥呢？简单来说，就是将软件开发中需要重复性解决的编码场景，按最佳实践的方式抽象成一个模型，模型描述的解决方法就是设计模式。使用设计模式，可以使代码更易于理解，保证代码的重用性和可靠性。 在软件领域，GoF（四人帮，全拼 Gang of Four）首次系统化提出了 3 大类、共 25 种可复用的经典设计方案，来解决常见的软件
PHP 23种设计模式
amateur12的博客
07-21 1828
PHP设计模式
设计模式之委派模式
泡^泡
06-27 2266
什么是委派模式
PO设计模式
qq_43911915的博客
07-30 2810
一、什么是PO设计模式？ PO（PageObject）设计模式将某个页面的所有元素对象定位和对元素对象的操作封装成一个 Page 类，即一个py文件，并以页面为单位来写测试用例，实现页面对象和测试用例的分离，若元素发生变化，只需要进入对应的Page类，更新元素定位即可，不用修改用例。 二、在什么样的场景下使用PO设计模式？(where) 随着时间的推移，需要维护的页面越来越多时，如果使用传统的设计模式把测不同页面上的所有步骤写在同一个模块里面，会显得笨重。如果页面发生了改变，对应的脚本也要发生改变，难以维护
设计模式解析
11-28
本资料"设计模式解析（第二版）"正是这样一本专注于此主题的资源。 设计模式通常分为三类：创建型模式、结构型模式和行为型模式。创建型模式关注对象的创建过程，如单例模式、工厂模式和建造者模式等，它们帮助我们...
23种设计模式整理pdf
07-14
设计模式是软件开发中的一种解决方案，旨在提高代码的可重用性、可维护性和可扩展性。在这篇文章中，我们将对23种常见的设计模式进行整理和解释。 1. Singleton 模式 Singleton 模式是一种创建型模式，用于限制类的...
设计模式之蝉
11-29
《设计模式之蝉》这本书可能是对设计模式的一种形象化描述，或是以蝉为比喻来讲解设计模式的概念。蝉在地下蛰伏多年，最终破土而出，仅生活在地面上的几周时间。这一生命周期与设计模式的持久价值有异曲同工之妙，即...
C++设计模式
02-21
火龙果软件工程技术中心C++设计模式之Adapter一、功能　将一个类的接口转换成客户希望的另外一个接口，解决两个已有接口之间不匹配的问题。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。...
设计模式（三）
最新发布
dingyahui的博客
08-24 913
Circle 是具体的实现类，它实现了抽象类的方法，并使用实现类接口来完成绘制工作，测试函数中创建了两个具体的实现类对象和两个使用这些实现类的圆形对象，并调用它们的绘制方法。优点：使用代理模式创建代表对象，让代表对象来控制某对象的访问，被代理的对象可以是远程的对象，创建开销大的对象或需要安全控制的对象。：真实的角色实现实际的业务逻辑，不用关心其它非本职的事务，通过后期的代理完成附加的事务，附带的结果就是编程简洁清晰。：享元模式的优点在于大幅减少内存中对象的数量，降低程序内存的占用，提高性能。
游戏开发设计模式之单例模式
Ctrl+CV九段手
08-22 1136
单例模式（Singleton Pattern）是一种常见的设计模式，其主要目的是确保一个类在整个程序的生命周期中只有一个实例，并提供一个全局访问点来获取这个实例。在游戏开发中，单例模式具有广泛的应用和重要的作用。单例模式的核心思想是通过对类的实例化进行控制，确保只能创建一个实例。通常情况下，单例模式通过静态变量或方法来实现。例如，在C#中，可以通过静态类属性、静态类方法和重新定义类建造者存取层级来实现单例模式。具体来说，可以使用如下代码实现： 单例模式的优点 单例模式在游戏开发中的应用 在游戏开
设计模式六大原则：迪米特法则详细说明和案例示范
weixin_39996520的博客
08-20 583
只与直接的朋友通信：一个对象应当只与那些与它关系密切的对象直接通信，而不应该依赖于太多的其他对象。避免过度依赖：对象之间的依赖关系应该尽量减少，避免形成复杂的依赖链。在实际开发中，这意味着我们应该设计简洁的接口，避免对象过度依赖于其他对象的内部细节，从而减少对象之间的耦合度。迪米特法则强调对象之间的交互应尽可能少，避免产生复杂的依赖关系。通过引入中介类或封装层，可以将依赖关系控制在合理的范围内，减少类之间的耦合度，提高系统的可维护性和可扩展性。
设计模式六大原则之一的接口隔离原则
jun778895的博客
08-20 1268
接口隔离原则的定义是：客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。换句话说，接口的设计应当尽量细化，每个接口只包含客户端需要的方法，而不是将所有可能的方法都放在一个接口中。接口隔离原则是面向对象设计中的一个重要原则，它强调了接口的设计应当尽量保持简洁和专一。通过细化接口、减少依赖和提高复用性等方式，接口隔离原则有助于降低系统的复杂性、提高系统的灵活性和可维护性。然而，在应用接口隔离原则时，也需要注意避免过度细化接口和增加系统的复杂性。
设计模式考试精选题库
"设计模式是软件工程中的一种重要思想，用于解决常见的设计问题，提高代码的可重用性、可维护性和灵活性。本资源是一份精心整理的设计模式试题集，涵盖了设计模式的基本概念、原则以及常见模式的应用。" 1、设计...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值