常用设计原则和设计模式

最新推荐文章于 2023-06-10 18:46:24 发布
最新推荐文章于 2023-06-10 18:46:24 发布
阅读量108 收藏
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42068838/article/details/118305255
版权

一、常用设计原则

        1、开闭原则：对扩展开放对修改关闭，为了使程序的扩展性好，易于维护和升级。
        2、里氏代换原则：任何基类可以出现的地方，子类一定可以出现，多使用多态的方式。
        3、依赖倒转原则：尽量多依赖于抽象类或接口而不是具体实现类，对子类具有强制性和规范性
        4、接口隔离原则：尽量多使用小接口而不是大接口，避免接口的污染，降低类之间耦合度。
        5、迪米特法则（最少知道原则）：一个实体应当尽量少与其他实体之间发生相互作用，使系统功能模块相对独立。高内聚，低耦合。
        6、合成复用原则：尽量多使用合成/聚合的方式，而不是继承的方式。

二、常用设计模式

        基本概念：设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。

        基本分类：

                创建型模式 - 单例设计模式、工厂方法模式、抽象工厂模式、...
                结构型模式 - 装饰器模式、代理模式、...
                行为型模式 - 模板设计模式、...

        1、单列设计模式

                ①、饿汉式

package com.designpattern;

public class Singleton {
        // 1、声明本类类型的引用指向本类类型的对象并使用private static关键字修饰
        private static final Singleton instance = new Singleton();
        // 2、私有化构造方法，使用private关键字修饰
        private Singleton() {}
        // 3、静态方法返回该实例
        public static Singleton getInstance() {
            return instance;
        }

}

                

                优点：实现起来简单，没有多线程同步问题。

                缺点：当类SingletonTest被加载的时候，会初始化static的instance，静态变量被创建并分配内存空间，从这以后，这个static的instance对象便一直占着这段内存（即便你还没有用到这个实例），当类被卸载时，静态变量被摧毁，并释放所占有的内存，因此在某些特定条件下会耗费内存。

                ②、懒汉式

package com.designpattern;

/**
 * 懒汉式
 */
public class Singleton1 {


        // 1、声明本类类型的引用指向本类类型的对象并使用private static关键字修饰
        private static Singleton1 sin=null;

        // 2、构造方法私有化
        private Singleton1() {}

        // 3、静态方法返回该实例
        public static Singleton1 getSin() {
            if(sin == null) {
                sin = new Singleton1();
            }
            return sin;
        }

}

                优点：实现起来比较简单，当类SingletonTest被加载的时候，静态变量static的sin未被创建并分配内存空间，当getSin方法第一次被调用时，初始化sin变量，并分配内存，因此在某些特定条件下会节约了内存。

                缺点：在多线程环境中，这种实现方法是完全错误的，根本不能保证单例的状态，线程不安全。如：当两个线程同时加载getSin方法，前面一个还没有创建完对象的时候，后一个线程进来sin为null，第二个线程会再创建一个对象。

                ③、线程安全的懒汉式

package com.designpattern;

/**
 * 线程安全的懒汉式
 */
public class Singleton2 {
        // 1、声明本类类型的引用指向本类类型的对象并使用private static关键字修饰
        private static Singleton2 sin = null;

        // 2、私有化构造方法，使用private关键字修饰
        private Singleton2() {}

        // 3、提供公有的get方法负责将上述对象返回出去，使用public static关键字修饰
        public static  Singleton2 getInstance() {
        //4、第一次检查instance是否被实例化出来，如果没有进入if块
            if (null == sin) {
        //5、获取类锁，实例化对象前第二次检查sin是否已经被实例化出来，如果没有，实例出对象
                synchronized (Singleton2.class) {
                    if (null == sin) {
                        sin = new Singleton2();
                    }
                }
            }
            return sin;
        }
    

}

                方式③为单例模式的最佳实现方式。内存占用率高，效率高，线程安全

        2、工厂设计模式

                ①、普通工厂模式

                        类图结构：

                发送接口：

package com.designpattern.factorydesign;

public interface Sender {
        // 自定义抽象方法来描述发送的行为
        void send();
}

                 具体类 邮件

package com.designpattern.factorydesign;


public class MailSender implements Sender {
    @Override
    public void send() {
        System.out.println("正在发送邮件...");
    }
}

                具体类 短信

package com.designpattern.factorydesign;

public class SmsSender implements Sender {
    @Override
    public void send() {
        System.out.println("正在发送短信...");
    }
}

                    具体工厂 发送工厂

package com.designpattern.factorydesign;

public class SendFactory {
    public Sender produce(String type) {
        if ("mail".equals(type)) {
            return new MailSender();
        }
        if ("sms".equals(type)) {
            return new SmsSender();
        }
        return null;
    }
}

                测试类

package com.designpattern.factorydesign;

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

        SendFactory sf = new SendFactory();
        Sender sender = sf.produce("mail");
        Sender sender1 = sf.produce("sms");
        //发送邮件
        sender.send();
        //发送短信
        sender1.send();
    }
}

        就这样，一个非常简单的工厂设计模式就完成了，但是有没有发现什么问题呢？
如果我们要发送QQ消息或者微信呢，就必然要修改工厂类，这显然违反了开闭原则，亦不可取；所以简单工厂只适合于产品对象较少，且产品固定的需求，对于产品变化无常的需求来说显然不合适。

②、多个工厂模式

        类图

                具体类 发送邮件工厂

package com.designpattern.factorydesign;

public class MailSendFactory {
    /**
     * 发送邮件
     * @return
     */
    public  Sender produceMail() {
        return new MailSender();
    }
}

                具体类 发送短信工厂

package com.designpattern.factorydesign;

public class SmsSendFactory  {
    /**
     * 发送短信
     * @return
     */
    public  Sender produceSms() {
        return new SmsSender();
    }
}

        测试类

package com.designpattern.factorydesign;

public class SendFactoryTest {
    public static void main(String[] args) {
        
            MailSendFactory ms=new MailSendFactory();
            SmsSendFactory sf=new SmsSendFactory();
            Sender sender=ms.produceMail();
            Sender sender1=sf.produceSms();
            sender.send();
            sender1.send();
    }
}

以上这种方式，虽然解耦了，也遵循了开闭原则，但是问题根本还是没有解决啊，换汤没换药，如果我需要的产品很多的话，需要创建非常多的工厂，所以这种方式的缺点也很明显。

                ③、抽象工厂模式

                 类图

               生产接口

package com.designpattern.factorydesign;

public interface Provider {
    // 自定义抽象方法描述产品的生产行为
    Sender produce();
}

                具体实现类 邮件工厂

package com.designpattern.factorydesign;

/**
 * 发送邮件
 */
public class MailSendFactory implements Provider {
    @Override
    public Sender produce() {
        return new MailSender();
    }
}

                具体实现类 短信工厂

package com.designpattern.factorydesign;

public class SmsSendFactory  implements Provider{
    /**
     * 发送短信
     * @return
     */
    @Override
    public Sender produce() {
        return new SmsSender();
    }
}

                测试类

package com.designpattern.factorydesign;

public class SendFactoryTest {
    public static void main(String[] args) {
        Provider provider1 = new MailSendFactory();
        Provider provider2 = new SmsSendFactory();

        Sender sender1 = provider1.produce();
        Sender sender2 = provider2.produce();
        sender1.send();
        sender2.send();

    }
}

        以上例子可以看出，抽象工厂可以解决一系列的产品生产的需求，对于大批量，多系列的品，用抽象工厂可以更好的管理和扩展。

        3、装饰器设计模式

                类图

                被装饰的抽象类：

package com.designpattern.decorator;


public interface Sourceable {
    void method();
}

                被装饰的具体类：

package com.designpattern.decorator;

public class Source implements Sourceable {
    @Override
    public void method() {
        System.out.println("穿西装！");
    }
}

                装饰类：

package com.designpattern.decorator;

public class Decorator implements Sourceable {
    private Sourceable source;

    public Decorator(Sourceable source) {
        this.source = source;
    }

    @Override
    public void method() {
        source.method(); //保证原有功能不变
        System.out.println("打领带！");
    }
}

        总结：装饰模式在不改变原先核心功能的情况下，可以实现增强，并且不会产生很多继承类。
        4、代理设计模式

                类图

                被代理的接口：

package com.designpattern.decorator;


public interface Sourceable {
    void method();
}

                被代理的具体类：

package com.designpattern.decorator;

public class Source implements Sourceable {
    @Override
    public void method() {
        System.out.println("穿西装！");
    }
}

                代理类：

package com.designpattern.decorator;

public class Proxy implements Sourceable {
    private Source source;

    public Proxy() {
        source = new Source();
    }

    @Override
    public void method() {
        source.method();
        System.out.println("穿短袖！");
    }
}

        总结：使用代理模式，可以将功能划分的更加清晰，有助于后期维护。
        5、模板设计模式

                类图：

                模板抽象类：

package com.designpattern.template;

public abstract class AbstractCalculator {
    // 自定义成员方法实现将参数指定的表达式按照参数指定的规则进行切割并返回计算结果 
    public int splitExpression(String exp, String op) {
        String[] sArr = exp.split(op);
        return calculate(Integer.parseInt(sArr[0]), Integer.parseInt(sArr[1]));
    }
    // 自定义抽象方法实现运算
    public abstract int calculate(int ia, int ib);
}

                模板实现类1：

package com.designpattern.template;

public class Plus extends AbstractCalculator {
    @Override
    public int calculate(int ia, int ib) {
        return ia + ib;
    }
}

                模板实现类2：

package com.designpattern.template;

public class Minus extends AbstractCalculator {
    @Override
    public int calculate(int ia, int ib) {
        return ia - ib;
    }
}

                测试类：

package com.designpattern.template;

public class AbstractCalculatorTest {

    public static void main(String[] args) {

        AbstractCalculator abstractCalculator = new Plus();
        AbstractCalculator abstractCalculator1 = new Minus();

        int res = abstractCalculator.splitExpression("1+1", "\\+");
        System.out.println("最终的运算结果是：" + res);
        int res1 = abstractCalculator1.splitExpression("10-4", "-");
        System.out.println("最终的运算结果是：" + res1);

    }
}

总结：通过模板设计模式可以让不同的子类实现不同的效果形成多态，有助于后期维护。

下一篇：https://blog.csdn.net/qq_42068838/article/details/118311919

城东赵铁柱
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式6大设计原则
geekun的博客
05-05 2124
1. 单一职责原则定义单一职责原则（SRP：Single responsibility principle）又称单一功能原则。它规定一个类应该只有一个发生变化的原因。阐述单一职责适用于接口、类、方法。顾名思义，就是要求一个接口或类只有一个职责，它就负责一件事情。好处 类的复杂性降低，有清晰明确的定义 提高了可读性和可维护性 使得变更引起的风险降低 注意职责没有一个量化的标准，并且受非常多因素的制约，
Java设计模式常用原则解析
08-19
Java设计模式常用原则解析 Java设计模式常用原则解析是软件设计中非常重要的一部分，它能够帮助开发者编写出更加灵活、可维护、可扩展的代码。本文将详细介绍Java设计模式常用原则解析，包括单一职责原则、里氏替换...
七种常用的设计模式
a154555的博客
07-05 7万+
常用的七种设计模式：单例模式、工厂方法模式、抽象工厂模式、代理模式、装饰器模式、观察者模式和责任链模式。设计模式分类设计模式根据工作的目的，分为创建型模式、结构型模式和行为型模式三类。创建型模式：单例模式、工厂方法模式、抽象工厂模式、创建者模式、原型模式。结构型模式：适配器模式、代理模式、装饰器模式、外观模式、桥接模式、组合模式、享元模式。行为型模式：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。软件设计七大原则(OOP原则)
Java中23种设计模式
呜呜老司机的博客家园
10-10 8万+
Java中23种设计模式，包括简单介绍，适用场景以及优缺点等
Java常见设计模式总结
热门推荐
张维鹏的博客
09-18 19万+
设计模式是一套经过反复使用的代码设计经验，目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式于己于人于系统都是多赢的，它使得代码编写真正工程化，它是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。总体来说，设计模式分为三大类：5种创建型模式、7种结构型模式、11种行为型模式
软件设计模式——软件设计原则
庄小焱
05-31 5357
设计模式（Design Pattern）是一套被反复使用、多数人知晓的、无数工程师实践的代码设计经验的总结，它是面向对象思想的高度提炼和模板化，使用设计模式是为了让代码具有更高的可重用性，更好的灵活性和可拓展性，更易被人阅读和理解。比如使用继承会给程序带来侵入性，程序的可移植性降低，增加对象间的耦合性，如果一个类被其他的类所继承，则当这个类需要修改时，必须考虑到所有的子类，并且父类修改后，所有涉及到子类的功能都有可能产生故障。依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。
C++几种常用设计模式
qq_46423987的博客
09-05 1万+
设计模式
Java常用的设计模式
小L的博客
08-26 1501
每增加新产品，只需增加该产品以及对应的具体实现工厂类，由具体工厂类决定要实例化的产品是哪个，将对象的创建与实例化延迟到子类，这样工厂的设计就符合“开闭原则”了，扩展时不必去修改原来的代码。但是装饰器模式也存在缺点，首先会产生很多的小对象，增加了系统的复杂性，第二是排错比较困难，对于多次装饰的对象，调试时寻找错误可能需要逐级排查，较为烦琐。LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。描述了应该在合适使用模式。..
设计模式七大原则
java123456111的博客
05-18 4542
1、设计模式的目的 ​ 编写软件过程中，程序员面临着来自耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性 等多方面的挑战，设计模式是为了让程序(软件)，具有更好 ​ 1) 代码重用性 (即：相同功能的代码，不用多次编写) ​ 2) 可读性 (即：编程规范性, 便于其他程序员的阅读和理解) ​ 3) 可扩展性 (即：当需要增加新的功能时，非常的方便，称为可维护) ​ 4) 可靠性 (即：当我们增加新的功能后，对原来的功能没有影响) ​ 5) 使程序呈现高内聚，低耦合的特性 2、设计模式七大原则 ​ 设计模
常用的JAVA设计模式
weixin_69774975的博客
07-23 2756
无论您是新手，还是老手，本教程都值得一读。对于那些具有丰富的开发经验的开发人员，学习设计模式有助于了解在软件开发过程中所面临的问题的最佳解决方案；对于那些经验不足的开发人员，学习设计模式有助于通过一种简单快捷的方式来学习软件设计。...
一文讲完Java常用设计模式（全23种）
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
06-10 2万+
设计模式是软件开发中非常有用的工具，可以提高代码的可重用性和可维护性，同时也可以提高开发人员的工作效率。 设计模式有几种类型，包括创建型、结构型和行为型模式。 创建型模式用于以灵活和高效的方式创建对象。包括Singleton模式、工厂模式和抽象工厂模式等。 结构型模式用于组合类和对象以形成更大的结构。包括适配器模式、桥接模式和装饰器模式等。 行为型模式用于处理类或对象之间的通信和控制流。包括观察者模式、策略模式和模板方法模式。
java常用设计模式 设计原则 应用场景介绍 极速版
04-25
### Java常用设计模式、设计原则及其应用场景介绍 #### 一、设计模式概述 设计模式是一种在软件...通过了解这些设计模式和设计原则，开发者可以在面对具体问题时做出更合理的选择，提高代码质量和系统的可维护性。
常用设计模式与算法的使用
10-07
在软件开发中，设计模式和算法是至关重要的概念，它们能帮助我们编写可维护、可扩展的高效代码。本文将详细探讨三个常见的设计模式：工厂方法模式、简单工厂模式和抽象工厂模式，以及它们在实际应用中的作用。 首先...
Java的常用设计模式
12-22
说起设计模式，很多编程语言的设计模式大同小异，而且设计模式很多，这里介绍一下java的几种常见的设计模式，其实设计模式是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便，所以要降低依赖，降低耦合...
几种常用的设计模式介绍总结
05-03
单例模式是一种常用的创建型设计模式，它保证一个类仅有一个实例，并提供一个全局访问点。单例模式通常用于控制资源的共享访问，例如数据库连接池、日志管理器等。 #### 实现方式 - **构造函数私有化**：防止外部...
微信小程序设计淘宝客导购小程序 pangolin_tbk 2.0.8安装更新一体包源代码+部署教程完美运行版.7z
最新发布
08-11
经导师精心指导并认可、获 98 分的毕业设计项目！【项目资源】：微信小程序。【项目说明】：聚焦计算机相关专业毕设及实战操练，可作课程设计与期末大作业，含全部源码，能直用于毕设，经严格调试，运行有保障！【项目服务】：有任何使用上的问题，欢迎随时与博主沟通，博主会及时解答。 经导师精心指导并认可、获 98 分的毕业设计项目！【项目资源】：微信小程序。【项目说明】：聚焦计算机相关专业毕设及实战操练，可作课程设计与期末大作业，含全部源码，能直用于毕设，经严格调试，运行有保障！【项目服务】：有任何使用上的问题，欢迎随时与博主沟通，博主会及时解答。 经导师精心指导并认可、获 98 分的毕业设计项目！【项目资源】：微信小程序。【项目说明】：聚焦计算机相关专业毕设及实战操练，可作课程设计与期末大作业，含全部源码，能直用于毕设，经严格调试，运行有保障！【项目服务】：有任何使用上的问题，欢迎随时与博主沟通，博主会及时解答。 经导师精心指导并认可、获 98 分的毕业设计项目！【项目资源】：微信小程序。【项目说明】：聚焦计算机相关专业毕设及实战操练，可作课程设计与期末大作业，含全部源码，能直用于毕设，经严格调试，运行有保障！【项目服务】：有任何使用上的问题，欢迎随时与博主沟通，博主会及时解答。
光伏风电出力预测（Prediction of PV power and wind power oiutputs）+源代码+说明
08-11
<项目介绍> - python、Sk-learn、概率预测、光伏出力、风电出力 - 不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的毕设，代码都测试ok，都是运行成功后才上传资源，答辩评审平均分达到96分，放心下载使用！ 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 下载后请首先打开README.md文件（如有），仅供学习参考, 切勿用于商业用途。 --------
智慧景区综合解决方案.docx
08-11
智慧景区综合解决方案.docx
mediapipe-0.8.8.1-cp37-cp37m-win_amd64.whl
08-11
mediapipe-0.8.8.1-cp37-cp37m-win_amd64.whl
C#设计模式解析：Builder模式与常用设计原则
设计模式是面向对象编程中的重要概念，能够提高代码的可读性、可维护性和可扩展性。 在描述中提到的Builder模式，它允许我们分步骤构建复杂对象，而无需暴露构造过程。比如，C#中的StringBuilder类就是一个Builder...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值