8种常用的设计模式(3-2) —— 单例模式

最新推荐文章于 2022-06-02 17:28:57 发布
最新推荐文章于 2022-06-02 17:28:57 发布
阅读量380 收藏
点赞数
分类专栏： 8种常用的设计模式 文章标签： 设计模式 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jzandth/article/details/108954044
版权

目录

1.单例模式

1.饿汉式单例

  • 饿汉式，顾名思义，饥不择食，上来就要
    public class Hungry {
    private Hungry(){}  //单例模式标志，私有构造
    private static final Hungry HUNGRY = new Hungry();  //饿汉式，上来直接new一个对象放在这供使用
    public static Hungry getInstance(){ //返回实例的方法
        return HUNGRY;
    }
}
    • 饿汉式的缺点：浪费资源
    • 原因：因为饿汉式上来就new了一个静态对象，所以不管我们用不用，它都已经存在在内存中了，那么如果这个对象中有很多占用内存的成员方法，比如：
    public class Hungry {
    private byte[] data1 = new byte[1024*1024];
    private byte[] data2 = new byte[1024*1024];
    private byte[] data3 = new byte[1024*1024];
    private byte[] data4 = new byte[1024*1024];
    private Hungry(){}  //单例模式标志，私有构造
    private static final Hungry HUNGRY = new Hungry();  //饿汉式，上来直接new一个对象放在这供使用
    public static Hungry getInstance(){ //返回实例的方法
        return HUNGRY;
    }
}

在这里插入图片描述

  • 在饿汉式的这种上来就new，在不使用它的时候就会比较占用资源的情况下，提出了懒汉式单例模式解决该问题

2.懒汉式单例

1.普通的懒汉式单例
  • 懒汉式，顾名思义，就是这个玩意儿它不勤快，很懒惰；该它造的东西，它非要推拖到你正要使用的时候它才去给你造
    public class Lazy {
    private Lazy(){}    //私有化构造，单例模式标志，不能变
    private static Lazy LAZY;   
    //单例对象的引用先定义出来，注意不能使用final关键字，final是用来定义常量的，所以定义常量的时候就要求你赋值，并且不可改变，所以饿汉式需要使用final
    
    public static Lazy getInstance(){
        if (LAZY==null){    //判断LAZY是否已经实例化了,没有就将它实例化
            LAZY = new Lazy();
        }
        return LAZY;    //如果lazy已经实例化了就直接将它返回
    }
}
    在这里插入图片描述
  • 虽然懒汉式单例解决了饿汉式单例的资源浪费问题，但是在实际的使用过程中，我们发现：懒汉式对于多线程支持并不好，甚至是不支持
2.DCL懒汉式单例
  • DCL就是双重锁🔒的意思，就是在线程获取对象的锁的前后都加上对于单例实例是否为null的判断，使用双重锁的意义在于节约系统开销提供运行性能/效率
    • 第一层🔒的意义：在单例对象实例化之后不再需要其他线程进加🔒再来判断单例对象是否为null
    • 第二层🔒的意义：在第一次new单例对象之前，可能出现多个线程同时通过第一层🔒的情况，但是由于通过第一层🔒之后就要排队+获取对象🔒，所以加上第二层判断可以在单例对象new完之后，保障其他线程不再new新的线程
    • 通过两层加🔒/if判断，就实现了整个流程只会new一个单例对象的效果
  • 多线程中的单例
    public class Lazy {
    private Lazy(){
        System.out.println(Thread.currentThread().getName()+"使用单例，并成功new 了一个LAZY对象");
    }    //私有化构造，单例模式标志，不能变
    private static Lazy LAZY;
    //单例对象的引用先定义出来，注意不能使用final关键字，final是用来定义常量的，所以定义常量的时候就要求你赋值，并且不可改变，所以饿汉式需要使用final

    public static Lazy getInstance(){
        if (LAZY==null){    //判断LAZY是否已经实例化了,没有就将它实例化
            LAZY = new Lazy();
        }
        return LAZY;    //如果lazy已经实例化了就直接将它返回
    }

    public static void main(String[] args) {
        for (int i=0;i<10;i++){
            new Thread(()->{
                LAZY.getInstance();
            }).start();
        }
    }
}
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
  • 从上面的运行结果我们就可以看出多线程中的单例模式不可靠，或者说不再是单例模式
  • 回顾多线程
  • 解决上面懒汉式单例多线程不靠谱的办法就是使用线程同步，或者说加🔒，加上锁之后多个线程对于对象资源的访问就会排队，这就可以保证懒汉式单例中的对象只会被实例化一次
  • 正常的情况下，我们直接使用关键字synchronized将它加在方法getInstance()上面即可解决问题，但是加锁的操作是很影响程序性能的，由于同步一个方法会降低100倍或更高的性能，而每个线程在调用getInstance()都会获取类的🔒，所以这是很消耗内存资源的；并且单例对象一旦初始化完成，获取和释放锁就显得很不必要，即一旦一个线程new 了单例对象，后面的程序再来获取🔒并进行对象是否为空的判断很没有必要，所以出现了"双重检查锁定模式"
  • 解决办法就是：我们不使用同步方法，而使用同步块，将多个线程访问的对象LAZY锁起来，然后进入正常的判断单例对象引用是否为null；前面的操作只是将同步方法变成了同步块，而双重检查锁定模式还要在同步块外面加上一个判断单例对象引用是否为null的判断，即在线程获取对象🔒之前，先判断单例对象是不是已经实例化了，如果已经实例化了，就不用再获取🔒和释放🔒，而直接返回单例对象实例
    public static Lazy getInstance(){
    if (LAZY==null){    //线程进来首先判断单例对象是否已经实例化，实例化了就不用再加锁进行判断了
        synchronized(Lazy.class){
            if (LAZY==null){    
                LAZY = new Lazy();
            }
        }
    }
    return LAZY;    //如果lazy已经实例化了就直接将它返回
}
  • 注意：第一次if判断是在避免不必要的加🔒和解🔒带来的内存占用，第二层if判断的作用在于：在单例对象被实例化之前，有1个以上的多线程通过了第一次检查，由于使用了同步块，所以它们需要排队进入同步块执行，那么第二个if判断的作用就体现在这里，即只要有一个线程通过了第二层的if判断，它就会实例化单例对象，这就让后面再进入同步块的线程不能再去实例化新的单例对象了
  • 所以，第一次if判断是在过滤不必要的加锁和解锁对于程序性能的影响；第二层if判断是在过滤刚开始一起通过了第一层if判断的线程不能多次new单例对象
  • 除了上面的使用两层if之外，我们还需要使用关键字volatile去关闭我们的单例对象的指令重排，原因就是：new一个对象的正常步骤为
    • ①为引用分配内存空间，此时对象的引用就不为空了，而是为这个内存地址
    • ②执行构造，初始化对象
    • ③将对象的地址传给对象的引用，就是将对象的地址存入引用执行的那片内存空间
  • 但是在实例执行的时候，线程可能不是按照这样的顺序在执行，它可能的另一种顺序就是①③②，这就叫"指令重排"；这样的顺序对于new对象的这个线程没有什么影响，在单线程中也没什么影响，但是在多线程的懒汉式单例模式下就会出现问题
  • 因为懒汉式单例只要判断单例对象的引用不为null，就认为这个对象已经创建好了，它就会直接返回对象的引用并在线程中调用对象的方法；如果线程A实例化单例对象采用的是①③②的顺序进行实例化，那么在进行了③但是还没进行②之前，线程B看到的单例对象的引用不为空，就会直接调用，但是实际上这片内存空间中什么都没有，就会出现空指针异常，所以我们需要关闭new单例对象的时候的指令重排，方式就是在对象的引用处使用关键字volatile即可，即使得这个引用的赋值过程变成一个原子性操作，不能变更
    public class Lazy {
    private Lazy(){
        System.out.println(Thread.currentThread().getName()+"使用单例，并成功new 了一个LAZY对象");
    }    //私有化构造，单例模式标志，不能变
    private volatile static Lazy LAZY;
    //单例对象的引用先定义出来，注意不能使用final关键字，final是用来定义常量的，所以定义常量的时候就要求你赋值，并且不可改变，所以饿汉式需要使用final

    public static Lazy getInstance(){
        if (LAZY==null){    //线程进来首先判断单例对象是否已经实例化，实例化了就不用再加锁进行判断了
            synchronized(Lazy.class){
                if (LAZY==null){
                    LAZY = new Lazy();
                }
            }
        }
        return LAZY;    //如果lazy已经实例化了就直接将它返回
    }

    public static void main(String[] args) {
        for (int i=0;i<10;i++){
            new Thread(()->{
                LAZY.getInstance();
            }).start();
        }
    }
}

在这里插入图片描述

  • 只有双重检测🔒+volatile关键字，才是真正解决懒汉式单例的完整且正确的方法
  • 参考博客

3.静态内部类实现单例模式

public class StaticInnerClass {
    private StaticInnerClass(){}//私有构造
    public static class  InnerClass{
        private static final StaticInnerClass STATIC_INNER_CLASS = new StaticInnerClass();
    }
    public static StaticInnerClass getInstance(){
        return InnerClass.STATIC_INNER_CLASS;
    }
}
  • 从实现上来看，静态内部类实现其实就和直接使用饿汉式单例模式实现单例是一样的，由于都是静态的，所以上来就会先把对象new出来占用内存

2.枚举

  • 由于霸道的反射技术的存在，所以即使我们的单例模式中使用了构造私有，但是反射一样可以破除该访问权限，获得到类的构造器，并且随意的new对象，这显然违反了单例模式的初衷
  • 即单例模式并不安全

1.使用反射破坏单例模式

  • 除了使用上面的3种方法实现单例模式以外，我们还可以使用反射
  • 这个技术就很霸道了，不管你类里面的东西是不是私有的，它都能拿出来使用；所以反射可以破坏我们设计好的懒汉式单例模式
    public static void main(String[] args) throws Exception {
    Lazy instance1 = Lazy.getInstance();
    System.out.println(instance1);

    Class<Lazy> lazyClass = Lazy.class;
    Constructor<Lazy> constructor = lazyClass.getDeclaredConstructor(null);
    constructor.setAccessible(true);//设置构造器可以获取使用，这就破坏了单例模式的构造器私有
    Lazy instance2 = constructor.newInstance();
    System.out.println(instance2);
}
  • 注意：上面的main()中我完全没有修改原来的代码，只是在main()中调用了反射，获取了单例类的构造，并调用了它获取了一个对象，最后输出两个对象就可以通过对比内存地址，查看两个对象是是否一致
    在这里插入图片描述
  • 所以，反射破坏了单例
  • 怎么解决？在构造中加入非空判断
    private Lazy(){
    synchronized (Lazy.class){
        if (LAZY!=null){
            throw new RuntimeException("小火鸡，不要使用反射搞破坏");
        }
    }
    System.out.println(Thread.currentThread().getName()+"使用单例，并成功new 了一个LAZY对象");
}
  • 当LAZY!=null的情况下再来调用构造，直接手动抛出异常
    在这里插入图片描述
  • 此时我们做的操作就是将双重检查锁升级为了3重检查锁
    在这里插入图片描述
  • 再来使用反射搞一些破坏，前面我们通过单例的Lazy.getInstance()导致单例中对象非null，此时我们根本就不去调用Lazy.getInstance()，所有的对象都通过反射获取，这样就不会使得单例中对象的引用变为非null
    public static void main(String[] args) throws Exception {
   /* Lazy instance1 = Lazy.getInstance();
    System.out.println(instance1);*/

    Class<Lazy> lazyClass = Lazy.class;
    Constructor<Lazy> constructor = lazyClass.getDeclaredConstructor(null);
    constructor.setAccessible(true);//设置这个类禁用访问安全检查，即无效化访问控制符
    
    Lazy instance1 = constructor.newInstance();
    System.out.println(instance1);

    Lazy instance2 = constructor.newInstance();
    System.out.println(instance2);
}

在这里插入图片描述
在这里插入图片描述

  • 【问题解决】定义一个标志位/红绿灯，只要构造被调用一次，就变为false
public class Lazy {
    private static boolean flag = false;
    private Lazy(){
        synchronized (Lazy.class){
            if (!this.flag){
                this.flag = true;
            }else {
                throw new RuntimeException("小火鸡，不要使用反射搞破坏");
            }
        }
        System.out.println(Thread.currentThread().getName()+"使用单例，并成功new 了一个LAZY对象");
    }
   }

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  • 但是标志位始终还是一个成员属性，我们可以通过反射获取它，在获取一个对象之后又将它修改为false，这样不就又可以破坏单例模式了吗？
    在这里插入图片描述
    在这里插入图片描述
  • 可见此时单例模式又被破坏了
  • 所以只要有反射，单例模式就存在被破坏的风险，那么怎么解决反射破化单例呢？

2.使用枚举防止单例被破坏

  • 怎么才能防止万恶的反射破坏单例模式呢？Java官方给出了解决办法，反射之所以可以获取多个对象，是因为它可以调用方法constructor.newInstance()，我们可以去查看newInstance()的源码
    @CallerSensitive
public T newInstance(Object ... initargs)
    throws InstantiationException, IllegalAccessException,
           IllegalArgumentException, InvocationTargetException
{
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, null, modifiers);
        }
    }
    if ((clazz.getModifiers() & Modifier.ENUM) != 0)
        throw new IllegalArgumentException("Cannot reflectively create enum objects");
    ConstructorAccessor ca = constructorAccessor;   // read volatile
    if (ca == null) {
        ca = acquireConstructorAccessor();
    }
    @SuppressWarnings("unchecked")
    T inst = (T) ca.newInstance(initargs);
    return inst;
}

在这里插入图片描述

  • 所以，Java官方的办法就是直接对反射获取对象的过程下手，只要我们将代理模式设为枚举类型，那么就可以防止反射破坏我们的单例模式
1.枚举怎么防止反射搞破坏
  • Java中的枚举类型
  • 枚举是Java中的一种数据结构，用于定义有限个数的对象的一种数据结构
  • 语法：enum 枚举类名称{ 枚举类实例名称列表 }
    定义枚举类的语法：
枚举类，使用关键字enum
enum color{	
	枚举类中规定的有限个数的实例
	RED,GREEN,BLUE;	
}

获取枚举类中实例的语法:
枚举类名.实例名称
enum.RED;
enum.GREEN;
enum.BLUE;
  • 测试反射是否能够破坏枚举类
    import java.lang.reflect.Constructor;

public enum EnumSingle {    //定义一个枚举类
    INSTANCE;   //枚举类提供的一个实例
    public static EnumSingle getInstance(){ //获取实例的方法，当然也可以使用枚举类名.实例名称获取
        return INSTANCE;
    }
}

class Test{
    public static void main(String[] args) throws Exception {
        EnumSingle instance1 = EnumSingle.INSTANCE; //从枚举类中获取实例1

        //使用反射获取实例2
        Constructor<EnumSingle> constructor = EnumSingle.class.getDeclaredConstructor(null);    //获取无参构造
        constructor.setAccessible(true);
        EnumSingle instance2 = constructor.newInstance();   //通过反射获取实例2

        System.out.println(instance1==instance2);   //判断两个对象引用是否相等，从而判断枚举类是否被反射破坏
    }
}

在这里插入图片描述

  • 【分析】对于枚举类EnumSingle我们并没有定义一个有参构造来覆盖无参构造，那么我们的无参构造去哪里了？我们可以反编译一下该java文件生成的.class文件(使用专业的反编译软件jad)
    在这里插入图片描述
    在这里插入图片描述
  • 所以上面报错没有无参构造的原因就是使用枚举之后，获取的对象不是通过无参构造创建的，而是通过上图的有参构造创建的
  • 那么我们可以通过反射获取上面的有参构造来破坏枚举类吗？
    import java.lang.reflect.Constructor;

public enum EnumSingle {    //定义一个枚举类
    INSTANCE;   //枚举类提供的一个实例
    public static EnumSingle getInstance(){ //获取实例的方法，当然也可以使用枚举类名.实例名称获取
        return INSTANCE;
    }
}

class Test{
    public static void main(String[] args) throws Exception {
        EnumSingle instance1 = EnumSingle.INSTANCE; //从枚举类中获取实例1
        EnumSingle.INSTANCE.name();

        //使用反射获取实例2
        Constructor<EnumSingle> constructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);    //获取无参构造
        constructor.setAccessible(true);
        EnumSingle instance2 = constructor.newInstance();   //通过反射获取实例2

        System.out.println(instance1==instance2);   //判断两个对象引用是否相等，从而判断枚举类是否被反射破坏
    }
}

在这里插入图片描述

  • 通过上面的验证我们可以得出以下两个结论
    • 使用枚举类可以防止反射获取类的构造并创建对象
    • 枚举类中的对象都是通过一个有参构造创建出来的，而不是一个无参构造
2.使用枚举改造单例模式
  • 所以我们要实现真正意义上安全不会被反射搞破坏的单例模式，就直接使用枚举定义要使用单例的类即可
    public enum EnumSingle {    //定义一个枚举类
    INSTANCE;   //枚举类提供的一个实例
    public static EnumSingle getInstance(){ //获取实例的方法，当然也可以使用枚举类名.实例名称获取
        return INSTANCE;
    }
}
原来是小别扇
关注
专栏目录
几种简单的设计模式：单例模式、代理模式、观察者模式、工厂模式
m0_51553630的博客
01-25 1738
常见的设计模式
设计模式（一）——单例模式
01-20
我们经常遇到这样的场景，线程A和线程B对同一个对象执行操作，但是在A里面new了后，B里面不便取，使的A，B对象是同一个对象，我们就会使用单例模式了。在Android中我们常用于数据库操作，蓝牙命令控制，以及一些工具...
单例模式（23种设计模式）
逆流而上Mr李
06-19 258
单例模式代码 /* 饿汉模式 */ class SingletonDemo { private final static SingletonDemo s = new SingletonDemo(); private SingletonDemo(){} public static SingletonDemo getS(){ return s...
常见的设计模式（单例模式）
Ineedmoney2333的博客
10-01 235
设计模式是什么？ 设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。 ...
六大常用设计模式：一、单例模式
weixin_60808029的博客
01-20 642
1.1、介绍 单例模式（Singleton）的目的是为了保证在一个进程中，某个类有且仅有一个实例。它解决了一个全局使用的类频繁地创建和销毁这一问题。 这个全局使用的类 在单例模式中需要创建自己的对象，同时确保只有单个对象被创建。并且这个类需要提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 单例模式特点有三：单例类只能有一个示例；单例类必须自己常见自己的唯一实例；单例类必须给所有其他对象提供这一实例。 这种类型的设计模式属于创建型模式。 下面介绍两种单例模式的实现：饿汉式、懒汉式。
单例模式-23种设计模式系列
dh的博客
04-26 426
一、单例设计模式介绍 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。 二、单例设计模式八种方式 单例模式有 8 种方式： 1）饿汉式（静态常量） 2）饿汉式（静态代码块） 3）懒汉式（线程不安全） 4）懒汉式（线程安全，同步方法） 5）懒汉式（线程安全，同步代码块） 6）双重检查 7）静态内部类 8...
java设计模式——单例模式
12-22
【Java设计模式——单例模式】 单例模式是一种常见的软件设计模式，它的核心思想是确保在应用程序的整个生命周期中，某个类只有一个实例存在。这种模式主要用于控制类的实例化过程，减少系统资源的消耗，提高系统...
C#设计模式(1)——单例模式.pdf
06-13
本次将聚焦于一种较为简单的模式——单例模式。 #### 单例模式概述 单例模式是一种创建型模式，它的核心在于确保某个类只有一个实例，并提供一个全局可访问的访问点。这种模式非常实用，尤其是在需要频繁地创建和...
android开发设计模式之——单例模式详解
01-04
单例模式是设计模式中最常见也最简单的一种设计模式，保证了在程序中只有一个实例存在并且能全局的访问到。比如在Android实际APP 开发中用到的 账号信息对象管理， 数据库对象（SQLiteOpenHelper）等都会用到单例...
C++设计模式——单例模式-附件资源
03-05
C++设计模式——单例模式-附件资源
常用设计模式——深入理解单例模式
zhan_lang的博客
03-11 258
单例模式： 前言：一听说单例模式是不是觉得很简单 什么饿汉模式 懒汉模式 分分钟信手拈来 其实它远远不止这些 那么今天我们就来详细的介绍一下单例模式 让你再和别人谈及单例模式的时候 分分钟秒杀别人 。 定义（什么叫单例）：单例模式（Singleton Pattern）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式。 场景：在 J2EE 标准中，Servle...
java设计模式浅谈（单例模式，模板模式，工厂模式，代理模式）
叶清逸的博客
07-05 3981
这篇文章讲述的是java设计模式，包括单例模式、工厂模式、代理模式，如有错误或不当之处，希望各位大神批评指正。 什么是设计模式？ 设计模式：是指在大量的理论和实践中总结和理论化之后，优选的代码结构、编程风格、以及解决问题的思考模式。正如数学中的公式的使用一样。 包括： 单例模式 模板模式 工厂模式 代理模式 等等… 单例模式 什么是单例模式？ 单例模式是指，采用某种手段或者方法，保...
Java中的五种单例模式
weixin_34315665的博客
11-25 74
Java模式之单例模式： 单例模式确保一个类只有一个实例，自行提供这个实例并向整个系统提供这个实例。 特点： 1，一个类只能有一个实例 2 自己创建这个实例 3 整个系统都要使用这个实例 例: 在下面的对象图中，有一个"单例对象"，而"客户甲"、"客户乙" 和"客户丙"是单例对象的三...
常用的几种设计模式（单例，工厂，模板等）
qq_43567709的博客
10-29 460
1. 单例设计模式 单例设计模式主要分为：饿汉式 和 懒汉式，懒汉式需要对多线程进行同步处理。 public class Singleton { // 2.声明本类类型的引用指向本类类型的对象并使用private static关键字修饰 private static Singleton sin = null; // 1.私有化构造方法，使用private关键字修饰 private Singleton() {} // 3.提供公有的get方法负责将上述对象返回出去
什么是单例模式？常见的单例模式写法有哪些？
LeBronJJJ的博客
07-10 735
什么是单例模式？？？ 保证一个类仅有一个实例，并提供一个访问它的全局访问点。 单例模式是一种常用的软件设计模式之一，其目的是保证整个应用中只存在类的唯一一个实例。 几种常见的单例模式代码实现： 饿汉式： /** * 单例模式 * 饿汉式 */ public class Simple01 { //类初始化时，立即创建对象 private static Simple01 s=ne...
java设计模式的一些面试题整理
shen_shi_wei的博客
06-08 3225
Java设计模式相关面试这里面试一些简单的面试题Java高级面试设计模式 这里面试一些简单的面试题 1．接口是什么？为什么要使用接口而不是直接使用具体类？ 接口用于定义 API。它定义了类必须得遵循的规则。同时，它提供了一种抽象，因为客户端只使用接口，这样可以有多重实现，如 List 接口，你可以使用可随机访问的 ArrayList，也可以使用方便插入和删除的 LinkedList。接口中不允许写代码，以此来保证抽象，但是 Java 8 中你可以在接口声明静态的默认方法，这种方法是具体的。 2.java中，
单例模式【Singleton Pattern】
暴风一簇的专栏 (roseone)
08-03 113
[code="java"] 这个模式是很有意思，而且比较简单，但是我还是要说因为它使用的是如此的广泛，如此的有人缘， 单例就是单一、独苗的意思，那什么是独一份呢？你的思维是独一份，除此之外还有什么不能山寨的呢？ 我们举个比较难复制的对象：皇帝 中国的历史上很少出现两个皇帝并存的时期，是有，但不多，那我们就认为皇帝是个单例模式，在这 个场景中，有皇帝，有大臣，大臣是天天要上朝参见皇帝的，今...
Java 六种常见的设计模式：单例，工厂，策略，模板方法，适配器，代理
sulia1234567890的博客
02-11 1938
目录 1. 单例模式 SingletonPattern 1.1 什么是单例模式 1.2 简单示例代码 2. 工厂模式 FactoryMethod 2.1 什么是工厂模式 2.2 简单示例代码 3. 策略模式 3.1 什么是策略模式 3.2 示例代码 4. 模板方法模式 4.1 什么是模板方法模式 4.2 示例代码 5. 适配器模式 5.1 什么是适配器模式 5.2 示例代码 6. 代理模式 6.1 什么是代理模式 6.2 示例代码 【写在前面】 此文是学习笔记。今天复
23 种设计模式详解（全23种）
雨中深巷的油纸伞
06-02 11万+
设计模式
C#版23种设计模式详解-单例模式
本文主要关注的是C#语言中的23种设计模式之一——单例模式（Singleton Pattern）。单例模式是一种创建型设计模式，它的核心目标是确保一个类只有一个实例，并提供一个全局访问点，以便在系统中其他地方使用这个唯一...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值