常见的设计模式(超详细)

这篇具有很好参考价值的文章主要介绍了常见的设计模式(超详细)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

单例模式

确保一个类只有一个实例,并且自行实例化并向整个系统提供这个实例。

饿汉式单例模式

饿汉式单例模式在类加载的时候完成了实例化,因为我们将构造函数设为了私有,所有其他的对象不能通过new类创建这个类的实例,然后提供了一个公共的静态方法返回这个类的唯一实例。因为只有一个实例化对象,所以不存在线程安全问题,在平时不能通过new进行对象的创建,只能通过给定的那个全局访问点通过类名进行调用

常见的设计模式(超详细),设计模式,开发语言,java

/**
 * 饿汉式单例模式
 */
public class SingletonPattern {

    // 在类加载时完成了实例化
    private static SingletonPattern singletonPattern = new SingletonPattern();

    // 私有化构造函数,防止其他对象使用new创建该类的对象
    private SingletonPattern() {
    }

    // 提供一个公共的静态方法,返回该类的唯一实例
    public static SingletonPattern getSingletonPattern() {
        return singletonPattern;
    }
}



懒汉式单例模式

懒汉式单例在类加载的时候不创建对象,在第一次使用的时候进行创建,这样创建的优点是如果该单例对象在系统中没有被使用,那么就不会造成资源的浪费。但是懒汉式单例会出现线程安全问题,当多线程访问时,有可能出现多个线程同时if,就会创建出多个对象。

常见的设计模式(超详细),设计模式,开发语言,java

/**
 * 懒汉式单例模式
 */
public class SingletonPattern1 {

    // 初始化一个null对象
    private static volatile SingletonPattern1 singletonPattern = null;

    // 私有化构造函数,防止别的对象使用new创建该类的对象
    private SingletonPattern1() {
    }

    // 提供一个公共的静态方法,返回该类的唯一实例
    public static SingletonPattern1 getSingletonPattern() {
        if (singletonPattern == null) {
            singletonPattern = new SingletonPattern1();
        }
        return singletonPattern;
    }
}

要解决这个线程安全的问题可以有两种方式,第一种是给方法加锁,但是给方法加锁之后一次只能获取到一个线程,效率较低。第二种是给代码块加锁,需要使用双重检索
常见的设计模式(超详细),设计模式,开发语言,java

双重检索单例模式

既提高了效率,又提高了安全性,使用双重if的原因是,当只有一个if时,如果锁加载if代码块的外面,这时候和加载方法上是一样的,效率低;如果加在if内,这是后如果并发量大,几个线程同时进行if然后进入if,虽然内部代码被锁包裹,但是已经进入的线程一个接一个执行,仍然会创建出多个对象,此时需要给内部代码块再加一层if,这时候即提高了效率,又提高了安全性。

/**
 * 双重检索单例模式
 */
public class SingletonPattern2 {

    // 初始化一个null对象
    private static SingletonPattern2 singletonPattern = null;

    // 私有化构造函数,防止别的对象使用new创建该类的对象
    private SingletonPattern2() {
    }

    // 提供一个公共的静态方法,返回该类的唯一实例
    public static SingletonPattern2 getSingletonPattern() {
        if (singletonPattern == null) {
            synchronized (SingletonPattern2.class) {
                if (singletonPattern == null) {
                    singletonPattern = new SingletonPattern2();
                }
            }
        }
        return singletonPattern;
    }
}


此时问题并没有完全解决,我们知道一个对象创建的过程主要分为三步,分配内存,初始化对象,指向刚分配的地址,但是第二步和第三步由于CPU的优化,可能会产生排序,我们一般认为执行顺序为123,但是可能会先执行3再执行2,这时候的对象是一个半成品对象,但是也不是null所以此时的情况并没有完全解决,需要添加volatile,只有当所有步骤都执行完之后才会将对象的地址传给引用参数。

常见的设计模式(超详细),设计模式,开发语言,java

工厂模式

简单工厂模式

简单工厂模式又称为静态工厂方法模式,它属于类创建型模式。在简单工厂模式中,可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责其他类的实例,被创建的实例通常都具有共同的父类。优点是实现对象的创建和使用分离,创建完全交给专门的工厂类去负责,程序员不关心怎么创建,只关心怎么使用。缺点是工厂类不够灵活,如果新增一个产品就要修改工厂类,就要修改它的判断逻辑,如果产品很多的话,这个逻辑就会非常复杂。比如就是一台咖啡机可以理解为一个工厂模式,你只需要按下想喝的咖啡品类的按钮,他就会给你生产一杯相应的咖啡,你不需要管他的内部具体实现,只需要告诉它你的需求。

常见的设计模式(超详细),设计模式,开发语言,java

工厂(方法)模式

简单工厂模式当有新产品加入时必须要修改工厂类,需要在其中加入必要的业务逻辑,这违反了开闭原则,没有办法做到灵活扩展。工厂方法模式:定义一个用于创建对象的接口,让子类决定实例化那个类。工厂方法使一个类的实例化延迟到其子类。

常见的设计模式(超详细),设计模式,开发语言,java

常见的设计模式(超详细),设计模式,开发语言,java

在工厂模式中,之前的核心工厂变成了一个抽象接口,负责给出工厂应该实现的方法,它不在负责所有产品的创建,将具体产品的创建交给子类去做,这样就诞生了具体的子工厂,子工厂即子类,负责生成具体的产品对象,这样做可以将产品类的实例化操作延迟到工厂子类中完成,即通过工厂子类来确定究竟应该实例化哪一个具体产品类,在现在的工厂模式中,如果需要新增一个产品,不需要修改原有的工厂类逻辑,但是需要新增一个工厂,这样看起来比较复杂,但是在面向对象语言中,需要遵循开闭原则,就是程序对于扩展是开放的,对于修改时封闭的

常见的设计模式(超详细),设计模式,开发语言,java

Collection就是一个常见的工厂方法模式,其中Collection就是抽象工厂,具体工厂时LinkedList和ArrayList,抽象产品就是Iterator,具体产品就是ListItr和Itr。

抽象工厂模式

常见的设计模式(超详细),设计模式,开发语言,java

抽象工厂模式可以使具体工厂类,可以创建多个大类对象,但是还需要修改抽象工厂和具体工厂的代码,违反开闭原则。

原型模式

原型模式属于创建型模式,用来创建一个已有的对象的完全相同的复制品。这个时候如果直接复制的话,需要创建一个相同类的对象,然后遍历原始对象的所有成员变量以及所有属性,然后将这些变量的值复制到新的对象中,但是这个对象的某些成员变量是私有的,不对外公开,或没有提供访问器,那么外部是没有办法去复制的,并且对象实现的某个接口传给我们时,我么你只知道它的某个接口的实现类,他具体的类是哪一个,这是不知道的。那么原型模式就是去解决复制对象的问题的,原型模式将这个复制过程称之为克隆,原型模式就是将这个克隆的过程委派给被克隆的实际对象,由这个被克隆的对象自己去负责克隆,原型模式为所有被克隆的对象提供了一个通用接口,原型对象需要克隆的话就去实现这个接口(clone),就在克隆方法中去实现自己的克隆逻辑。

代理模式

代理模式就是为其他对象提供一种代以控制这个对象的访问。例:黄牛买票,婚介

代理模式分为静态代理和动态代理,动态代理又分为JDK代理和CGLIB动态代理

优点是代理模式能够协调调用者和被调者,在一定程度上降低系统的耦合度,并且可以灵活的隐藏被代理对象的部分功能和服务,也增加了额外的功能和服务,缺点就是使用代理模式程序没有直接调用性能高,并且使用代理模式提高了代码的复杂度。文章来源地址https://www.toymoban.com/news/detail-627402.html

到了这里,关于常见的设计模式(超详细)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Java开发】设计模式 17:中介者模式

    中介者模式是一种行为设计模式,指用一个中介对象来封装一系列的对象交互。 中介者使各对象不需要显示地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。在这个模式中,中介者负责协调各个对象间的通信,使其流程更加清晰简单。 📌  场景 中介者

    2023年04月22日
    浏览(46)
  • 【代理设计模式详解】C/Java/JS/Go/Python/TS不同语言实现

    代理模式(Proxy Pattern)是一种结构型设计模式,用一个类来代理另一个类或几个类的功能。 在代理模式中,我们创建具有现有对象的对象,以便向外界提供功能接口。 延迟初始化(虚拟代理)。如果你有一个偶尔使用的重量级服务对象,一直保持该对象运行会消耗系统资源

    2023年04月25日
    浏览(80)
  • 【单例设计模式原理详解】Java/JS/Go/Python/TS不同语言实现

    单例模式(Singleton Pattern)属于创建型设计模式,这种模式只创建一个单一的类,保证一个类只有一个实例,并提供一个访问该实例的全局节点。 当您想控制实例数目,节省系统资源,并不想混用的时候,可以使用单例模式。单例有很多种实现方式,主要分为懒汉和饿汉模式

    2023年04月27日
    浏览(88)
  • 【原型设计模式详解】C/Java/JS/Go/Python/TS不同语言实现

    原型模式(Prototype Pattern)是一种创建型设计模式,使你能够复制已有对象,而无需使代码依赖它们所属的类,同时又能保证性能。 这种模式是实现了一个原型接口,该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时,则采用这种模式。 如果你需要复制一些对

    2023年04月24日
    浏览(79)
  • 【策略设计模式详解】C/Java/JS/Go/Python/TS不同语言实现

    策略模式(Strategy Pattern)属于行为型设计模式。将每一个算法封装到具有共同接口的独立类中,根据需要来绑定策略,使得具体实现和策略解耦。 当你想使用对象中各种不同的算法变体,使用if...else 所带来的复杂和难以维护,可使用策略模式。或者当有许多相同类,它们仅

    2024年02月01日
    浏览(42)
  • 【迭代器设计模式详解】C/Java/JS/Go/Python/TS不同语言实现

    迭代器模式(Iterator Pattern),是一种结构型设计模式。给数据对象构建一套按顺序访问集合对象元素的方式,而不需要知道数据对象的底层表示。 迭代器模式是与集合共存的,我们只要实现一个集合,就需要同时提供这个集合的迭代器,就像Java中的Collection,List、Set、Map等

    2023年04月17日
    浏览(45)
  • 【享元设计模式详解】C/Java/JS/Go/Python/TS不同语言实现

    享元模式(Flyweight Pattern),是一种结构型设计模式。主要用于减少创建对象的数量,以减少内存占用和提高性能。它摒弃了在每个对象中保存所有数据的方式,通过共享多个对象所共有的相同状态,让你能在有限的内存容量中载入更多对象。 当程序需要生成数量巨大的相似

    2023年04月10日
    浏览(36)
  • 【模板方法设计模式详解】C/Java/JS/Go/Python/TS不同语言实现

    模板方法模式(Template Method Pattern)也叫模板模式,是一种行为型模式。它定义了一个抽象公开类,包含基本的算法骨架,而将一些步骤延迟到子类中,模板方法使得子类可以不改变算法的结构,只是重定义该算法的某些特定步骤。不同的子类以不同的方式实现这些抽象方法

    2024年02月01日
    浏览(80)
  • 【访问者设计模式详解】C/Java/JS/Go/Python/TS不同语言实现

    访问者模式(Visitor Pattern)是一种行为型模式。它封装一个访问者类,把各元素类的操作集合起来,目的是将数据结构与数据操作分离。在不改变原有元素类数据结构的前提下,改变了元素类的执行算法。 当某些较为稳定的东西(数据结构或算法),不想直接被改变但又想扩

    2024年02月02日
    浏览(76)
  • 【观察者设计模式详解】C/Java/JS/Go/Python/TS不同语言实现

    观察者模式(Observer Pattern)是一种行为型模式。它定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。 观察者模式使用三个类Subject、Observer和Client。Subject对象带有绑定观察者到Client对象和从Client对象解绑观察

    2023年04月21日
    浏览(78)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包