java设计模式——单例模式

最新推荐文章于 2024-09-17 17:24:30 发布
最新推荐文章于 2024-09-17 17:24:30 发布
阅读量86 收藏 1
点赞数 1
分类专栏： java设计模式 文章标签： 单例模式 java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/maoheguxiang/article/details/128584819
版权

单例设计模式

文章目录

介绍：

  • 单例模式是 Java 中最简单的设计模式之一。它提供了一种创建对象的最佳方式
  • 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建
  • 这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

结构：

  • 单例类：只能创建一个对象
  • 访问类：使用单例类

实现：

饿汉式：类加载就会导致该单例对象被创建

实现一：静态变量方式

public class Singleton {
    //将构造方法私有化，外部无法通过构造方法创建对象
    private Singleton(){}
    //实例化Singleton类，权限私有化，外部无法直接调用singleton。
    private static Singleton singleton = new Singleton();
    //通过get方法，实例化Singleton类，得到对象singleton并且返回出去。
    //加上静态修饰符是因为构造方法已经私有，在外部无法直接通过构造方法创建对象，通过静态修饰，外部可以通过类名直接调用方法
    public static Singleton getSingleton(){
        return singleton;
    }
}
  • 注意：该方式在成员位置声明Singleton类型的静态变量，并创建Singleton类的对象singleton。singleton对象是随着类的加载而创建的。如果该对象足够大的话，而一直没有使用就会造成内存的浪费。

实现二：静态代码块方式

public class Singleton {
    //构造方法私有化，外界无法通过构造方法创建对象
    private Singleton(){

    }
    private static Singleton singleton;//singleton = null
    //静态代码块，jvm加载该类为字节码文件的时候执行一次，然后再也不执行，实例化Singleton类
    //多个静态代码块，按照顺序执行
    static {
        singleton = new Singleton();
    }
    //返回singleton对象
    public static Singleton getSingleton(){
        return singleton;
    }
}
  • 注意：该方式在成员位置声明Singleton类型的静态变量，而对象的创建是在静态代码块中，也是对着类的加载而创建。所以和饿汉式的方式1基本上一样，当然该方式也存在内存浪费问题。

懒汉式：类加载不会导致该单例对象被创建，而是首次使用该对象才会创建

实现一：线程不安全

public class Singleton {
    //构造方法私有化，防止外部通过构造方法创建对象
    private Singleton(){}
    private static Singleton singleton;//null
    //对外提供访问方式
    public static Singleton getSingleton(){
        //判断singleton是否为null，为null则创建对象
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
  • 注意：从上面代码我们可以看出该方式在成员位置声明Singleton类型的静态变量，并没有进行对象的赋值操作，那么什么时候赋值的呢？当调用getInstance()方法获取Singleton类的对象的时候才创建Singleton类的对象，这样就实现了懒加载的效果。但是，如果是多线程环境，会出现线程安全问题

实现二：线程安全

public class Singleton {
    //构造方法私有化，防止外部通过构造方法创建对象
    private Singleton(){}
    private static Singleton singleton;//null
    //对外提供访问方式
    public static synchronized Singleton getSingleton(){
        //判断singleton是否为null，线程1进入，时间片用完，并没有new对象，进入等待，线程2进行判断，就会创建两个对象
        //加锁，线程运行到这个方法的时候，都会检查其他线程是否运行该方法，等待其运行完毕
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}
  • 注意：该方式也实现了懒加载效果，同时又解决了线程安全问题。但是在getInstance()方法上添加了synchronized关键字，导致该方法的执行效果特别低。从上面代码我们可以看出，其实就是在初始化instance的时候才会出现线程安全问题，一旦初始化完成就不存在了。

实现三：双重检查锁

  • 对于 getInstance()方法来说，绝大部分的操作都是读操作，读操作是线程安全的，所以我们没必让每个线程必须持有锁才能调用该方法，我们需要调整加锁的时机。
public class Singleton {
    //构造方法私有化
    private Singleton(){}
    //创建一个静态的类型Singleton类型的变量
    private static volatile Singleton singleton;//null
    public static Singleton getSingleton(){
        //这里的两次判断，第一判断：效率，第二判断：避免同步。之所以这样是因为避免加锁后，再次加锁。大大增强了执行效率
        //第一次判断，是否为null，不需要抢占锁，提升效率
        if(singleton == null){
            //加锁
            synchronized (Singleton.class){
                //第二次判断
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}
  • 注意：在多线程模式下，可能会出现空指针异常，出现问题的原因时jvm在实例化对象的会进行优化和指令重排的操作
  • 解决：只需要使用volatile关键字，该关键字可以保证可见性和有序性
  • 添加 volatile关键字之后的双重检查锁模式是一种比较好的单例实现模式，能够保证在多线程的情况下线程安全也不会有性能问题

实现四：静态内部类

public class Singleton {
    //构造方法私有化
    private Singleton(){};
    //一个静态的内部类，没有调用其内部方法或属性时，jvm不会加载静态内部类
    private static class SingletonHolder{
        //定义为常量且被static修饰，保证只被初始化一次
        private static final Singleton SINGLETON = new Singleton();
    }
    //对外提供访问方式
    public static Singleton getSingleton(){
        return SingletonHolder.SINGLETON;
    }
}
  • 因为在jvm加载外部类时候，不会加载内部类，而只有调用内部类的方法或者属性时，才会被加载，并且初始化属性，由于被static修饰，保证只被初始化一次
  • 在没有加锁的情况下，保证了多线程的安全，并且没有任何性能影响和浪费

恶汉式：

实现一：枚举方式

public enum Singleton {
    SINGLETON;
}
  • 枚举类型是线程安全的，并且只会被装载一次，写法简单，且是唯一一个不会被破坏的单例模式

破坏单例模式

序列化反序列化

public class Client {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        writeObject2File();
        
        Singleton singleton = readObjectFromFile();
        Singleton singleton1 = readObjectFromFile();
        
        System.out.println(singleton1==singleton);//false
    }
    //从文件读取数据（对象）
    public static Singleton readObjectFromFile() throws IOException, ClassNotFoundException {
        //创建对象输入流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\BlackHorse\\Project\\shejimoshi\\a.txt"));
        //读取对象
        Singleton singleton = (Singleton) ois.readObject();
        //释放资源
        ois.close();
        //返回对象
        return singleton;
    }
    //向文件中写数据（对象）
    public static void  writeObject2File() throws IOException {
        //获取Singleton对象
        Singleton singleton = Singleton.getSingleton();
        //创建对象输出流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\BlackHorse\\Project\\shejimoshi\\a.txt"));
        //写对象
        oos.writeObject(singleton);
        //释放资源
        oos.close();

    }
}
  • 注意：NotSerializableException:无序列化异常，说明没有实现Serializable接口

反射

public class Client {
    public static void main(String[] args) throws Exception {
        //获取Singleton的字节码对象
        Class<Singleton> singletonClass = Singleton.class;
        //获取它的无参构造
        Constructor<Singleton> declaredConstructor = singletonClass.getDeclaredConstructor();
        //取消访问检查
        declaredConstructor.setAccessible(true);
        //创建Singleton对象
        
        Singleton singleton = declaredConstructor.newInstance();
        Singleton singleton1 = declaredConstructor.newInstance();
        
        System.out.println(singleton1 == singleton);//false
    }
}
  • 注意：枚举方式不会出现这两个问题。

解决问题：

解决序列化反序列化破解单例

public class Singleton implements Serializable {
    //构造方法私有化，防止外部通过构造方法创建对象
    private Singleton(){}
    private static Singleton singleton;//null
    //对外提供访问方式
    public static synchronized Singleton getSingleton(){
        //判断singleton是否为null，线程1进入，时间片用完，并没有new对象，进入等待，线程2进行判断，就会创建两个对象
        //加锁，线程运行到这个方法的时候，都会检查其他线程是否运行该方法，等待其运行完毕
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
    //当进行反序列化的时候，会自动调用该方法，将该方法返回值返回
    public Object readResolve(){
        return singleton;
    }
}

解决反射破解单例

public class Singleton {
    public static boolean flag = false;
    private Singleton(){
        //判断flag是否为true，如果为true，则说明非第一次创建对象，抛出异常
        if(flag){
            throw new RuntimeException("不能创建多个对象");
        }
        //没有抛出异常，则允许创建对象，并且将flag赋值为true
        flag = true;
    };
    private static class SingletonHolder{
        private static final Singleton SINGLETON = new Singleton();
    }
    public static Singleton getSingleton(){
        return SingletonHolder.SINGLETON;
    }
}
```# 单例设计模式

## 介绍：

- 单例模式是 Java 中最简单的设计模式之一。它提供了一种创建对象的最佳方式
- 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建
- 这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

## 结构：

- 单例类：只能创建一个对象
- 访问类：使用单例类

## 实现：

## 饿汉式：类加载就会导致该单例对象被创建

### 实现一：静态变量方式

```java
public class Singleton {
    //将构造方法私有化，外部无法通过构造方法创建对象
    private Singleton(){}
    //实例化Singleton类，权限私有化，外部无法直接调用singleton。
    private static Singleton singleton = new Singleton();
    //通过get方法，实例化Singleton类，得到对象singleton并且返回出去。
    //加上静态修饰符是因为构造方法已经私有，在外部无法直接通过构造方法创建对象，通过静态修饰，外部可以通过类名直接调用方法
    public static Singleton getSingleton(){
        return singleton;
    }
}
  • 注意：该方式在成员位置声明Singleton类型的静态变量，并创建Singleton类的对象singleton。singleton对象是随着类的加载而创建的。如果该对象足够大的话，而一直没有使用就会造成内存的浪费。

实现二：静态代码块方式

public class Singleton {
    //构造方法私有化，外界无法通过构造方法创建对象
    private Singleton(){

    }
    private static Singleton singleton;//singleton = null
    //静态代码块，jvm加载该类为字节码文件的时候执行一次，然后再也不执行，实例化Singleton类
    //多个静态代码块，按照顺序执行
    static {
        singleton = new Singleton();
    }
    //返回singleton对象
    public static Singleton getSingleton(){
        return singleton;
    }
}
  • 注意：该方式在成员位置声明Singleton类型的静态变量，而对象的创建是在静态代码块中，也是对着类的加载而创建。所以和饿汉式的方式1基本上一样，当然该方式也存在内存浪费问题。

懒汉式：类加载不会导致该单例对象被创建，而是首次使用该对象才会创建

实现一：线程不安全

public class Singleton {
    //构造方法私有化，防止外部通过构造方法创建对象
    private Singleton(){}
    private static Singleton singleton;//null
    //对外提供访问方式
    public static Singleton getSingleton(){
        //判断singleton是否为null，为null则创建对象
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
  • 注意：从上面代码我们可以看出该方式在成员位置声明Singleton类型的静态变量，并没有进行对象的赋值操作，那么什么时候赋值的呢？当调用getInstance()方法获取Singleton类的对象的时候才创建Singleton类的对象，这样就实现了懒加载的效果。但是，如果是多线程环境，会出现线程安全问题

实现二：线程安全

public class Singleton {
    //构造方法私有化，防止外部通过构造方法创建对象
    private Singleton(){}
    private static Singleton singleton;//null
    //对外提供访问方式
    public static synchronized Singleton getSingleton(){
        //判断singleton是否为null，线程1进入，时间片用完，并没有new对象，进入等待，线程2进行判断，就会创建两个对象
        //加锁，线程运行到这个方法的时候，都会检查其他线程是否运行该方法，等待其运行完毕
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}
  • 注意：该方式也实现了懒加载效果，同时又解决了线程安全问题。但是在getInstance()方法上添加了synchronized关键字，导致该方法的执行效果特别低。从上面代码我们可以看出，其实就是在初始化instance的时候才会出现线程安全问题，一旦初始化完成就不存在了。

实现三：双重检查锁

  • 对于 getInstance()方法来说，绝大部分的操作都是读操作，读操作是线程安全的，所以我们没必让每个线程必须持有锁才能调用该方法，我们需要调整加锁的时机。
public class Singleton {
    //构造方法私有化
    private Singleton(){}
    //创建一个静态的类型Singleton类型的变量
    private static volatile Singleton singleton;//null
    public static Singleton getSingleton(){
        //这里的两次判断，第一判断：效率，第二判断：避免同步。之所以这样是因为避免加锁后，再次加锁。大大增强了执行效率
        //第一次判断，是否为null，不需要抢占锁，提升效率
        if(singleton == null){
            //加锁
            synchronized (Singleton.class){
                //第二次判断
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}
  • 注意：在多线程模式下，可能会出现空指针异常，出现问题的原因时jvm在实例化对象的会进行优化和指令重排的操作
  • 解决：只需要使用volatile关键字，该关键字可以保证可见性和有序性
  • 添加 volatile关键字之后的双重检查锁模式是一种比较好的单例实现模式，能够保证在多线程的情况下线程安全也不会有性能问题

实现四：静态内部类

public class Singleton {
    //构造方法私有化
    private Singleton(){};
    //一个静态的内部类，没有调用其内部方法或属性时，jvm不会加载静态内部类
    private static class SingletonHolder{
        //定义为常量且被static修饰，保证只被初始化一次
        private static final Singleton SINGLETON = new Singleton();
    }
    //对外提供访问方式
    public static Singleton getSingleton(){
        return SingletonHolder.SINGLETON;
    }
}
  • 因为在jvm加载外部类时候，不会加载内部类，而只有调用内部类的方法或者属性时，才会被加载，并且初始化属性，由于被static修饰，保证只被初始化一次
  • 在没有加锁的情况下，保证了多线程的安全，并且没有任何性能影响和浪费

恶汉式：

实现一：枚举方式

public enum Singleton {
    SINGLETON;
}
  • 枚举类型是线程安全的，并且只会被装载一次，写法简单，且是唯一一个不会被破坏的单例模式

破坏单例模式

序列化反序列化

public class Client {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        writeObject2File();
        
        Singleton singleton = readObjectFromFile();
        Singleton singleton1 = readObjectFromFile();
        
        System.out.println(singleton1==singleton);//false
    }
    //从文件读取数据（对象）
    public static Singleton readObjectFromFile() throws IOException, ClassNotFoundException {
        //创建对象输入流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\BlackHorse\\Project\\shejimoshi\\a.txt"));
        //读取对象
        Singleton singleton = (Singleton) ois.readObject();
        //释放资源
        ois.close();
        //返回对象
        return singleton;
    }
    //向文件中写数据（对象）
    public static void  writeObject2File() throws IOException {
        //获取Singleton对象
        Singleton singleton = Singleton.getSingleton();
        //创建对象输出流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\BlackHorse\\Project\\shejimoshi\\a.txt"));
        //写对象
        oos.writeObject(singleton);
        //释放资源
        oos.close();

    }
}
  • 注意：NotSerializableException:无序列化异常，说明没有实现Serializable接口

反射

public class Client {
    public static void main(String[] args) throws Exception {
        //获取Singleton的字节码对象
        Class<Singleton> singletonClass = Singleton.class;
        //获取它的无参构造
        Constructor<Singleton> declaredConstructor = singletonClass.getDeclaredConstructor();
        //取消访问检查
        declaredConstructor.setAccessible(true);
        //创建Singleton对象
        
        Singleton singleton = declaredConstructor.newInstance();
        Singleton singleton1 = declaredConstructor.newInstance();
        
        System.out.println(singleton1 == singleton);//false
    }
}
  • 注意：枚举方式不会出现这两个问题。

解决问题：

解决序列化反序列化破解单例

public class Singleton implements Serializable {
    //构造方法私有化，防止外部通过构造方法创建对象
    private Singleton(){}
    private static Singleton singleton;//null
    //对外提供访问方式
    public static synchronized Singleton getSingleton(){
        //判断singleton是否为null，线程1进入，时间片用完，并没有new对象，进入等待，线程2进行判断，就会创建两个对象
        //加锁，线程运行到这个方法的时候，都会检查其他线程是否运行该方法，等待其运行完毕
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
    //当进行反序列化的时候，会自动调用该方法，将该方法返回值返回
    public Object readResolve(){
        return singleton;
    }
}

解决反射破解单例

public class Singleton {
    public static boolean flag = false;
    private Singleton(){
        //判断flag是否为true，如果为true，则说明非第一次创建对象，抛出异常
        if(flag){
            throw new RuntimeException("不能创建多个对象");
        }
        //没有抛出异常，则允许创建对象，并且将flag赋值为true
        flag = true;
    };
    private static class SingletonHolder{
        private static final Singleton SINGLETON = new Singleton();
    }
    public static Singleton getSingleton(){
        return SingletonHolder.SINGLETON;
    }
}
猫和古巷
关注
专栏目录
Java设计模式——单例模式
流楚丶格念的博客
08-11 1649
第二次判断防止多线程创建多个实例，假如A和B 两个线程同时争抢synchronized锁，A先争抢到锁，B 等待，A线程instance赋值实例化对象，释放锁，B线程获取到到锁，如果没有第二次判断的话，直接又会创建对象，那么就不符合单例要求。，此时2 ，3发生重排序，选执行3，则instance已经不为 null，但是指向的对象还未初始化完成，如果此时B对象判断instance 不为null就会直接返回一个未初始 化完成的对象。第一次判断没有锁，如果install不为null直接返回单实例对象，提高效率。.
JAVA 设计模式——单例模式
斌林诚上的博客
11-08 892
  一、简介 二、作用 三、实现方式 说明 （1）第一种方式 （2）第二种方式 （3）第三种方式 （4）第四种方式 （5）第五种方式 （6）第六种方式 四、测试 五、源码地址 六、参考文档 七、内容推荐 一、简介 属于创建型模式，提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。 这个类提供了一种访问...
《设计模式》之（一）单例模式 - 创建型
li的博客
11-10 201
生活就要奋斗 单例模式，按目的来分属于创建型模式。是指一个类只有一个实例，该实例对象必须由该单例类自行创建。其特点：1.构造器私有化；2.只有一个实例对象；3.由单例类自行创建；4.对外提供一个全局的访问方法。目的为了节省内存资源、保证数据内容的一致性。直接看代码，代码中注释，简便易懂，如下： <一>懒汉式单例模式： /** * 懒汉式单例：类加载时不生成实例对象，第一次去调...
单例模式SingletonPattern
Javaer`s blog
01-20 253
Java实现多种单例模式SingletonPattern 单例设计模式简介 保证某个类的实例只能被创建一次，以后都调用这个实例，保证了某个状态的一致性 常见的用到单例模式的情况有： windows下的任务管理器，只允许创建一个实例，否则同时打开多个任务管理器，这个里结束了某个进程，另外一个管理器中还可以看到，不是很安全； Android中的Application一般情况下都是只有一个，需要...
Java 设计模式——单例模式
代码星辰的博客
07-08 5344
本文介绍了单例模式的相关知识。
JAVA设计模式——单例模式
2301_77760093的博客
03-04 945
单例模式是一种创建型设计模式，其主要目的是确保一个类只有一个实例，并提供一个全局访问点来访问这个实例。单例模式通常用于需要在整个应用程序中共享某个资源或控制某个独占性资源的情况。在单例模式中，通常会将类的构造函数设为私有（private），以防止外部直接实例化该类。同时，类内部会维护一个静态成员变量来保存唯一的实例，并提供一个静态方法来获取或创建这个实例。单例模式有多种实现方式，包括懒汉式、饿汉式、双重检查锁等，需要注意的是，在多线程环境下，需要考虑线程安全性，确保单例模式能够正确地工作。
Java设计模式 —— 单例模式
Designer 小郑的技术博客
05-31 3738
本文主要讲解Java设计模式中，最最基础的单例模式。
Java设计模式——单例模式的简单理解，懒汉式/饿汉式&单例模式使用场景
不会敲代码的笨兔子
11-10 1490
首先，单例（Singleton）设计模式是23中设计模式的一种，应用场景也比较广泛，这里只做一个简单了解 目标：熟悉饿汉式的实现过程，这个地方懒汉式还是有一些线程安全问题，我们学到多线程的时候再做优化 提取一下关键路径： 某个类只能存在一个对象实例-->构造器私有化，这个实例只能在类内部定义-->调用静态方法返回这个对象，这个方法必须是静态的才能被外面调用，不然外面就要声明这个类，又矛盾了-->静态的方法里面只能访问静态成员变量，所以这个类的对象也是静态的。 我们通过..
C++单例模式
小小白的日常分享
09-12 603
在C++中，单例模式是一种确保一个类只有一个实例，并提供一个全局访问点来访问这个实例的设计模式。单例模式中的饿汉式（Eager Initialization）和懒汉式（Lazy Initialization）是两种不同的实例化策略，它们在实例的创建时机、性能和线程安全性方面有所区别。
工厂模式，策略模式，代理模式，单例模式在项目中的应用
最新发布
m0_73966521的博客
09-17 747
这段代码定义了一个名为的 Java 注解（Annotation）。注解是一种元数据，用于为代码元素（如类、方法、变量等）提供额外的信息。@Component/*** 应用类型* @return*//*** 评分策略* @return*/@Target(ElementType.TYPE)：指定这个注解的作用域：类，接口和枚举@Retention(RetentionPolicy.RUNTIME) 指定了注解在运行时可用，
【设计模式】创建型模式（三）：单例模式
书山有路，学海无涯。记录成长，追逐梦想
09-17 651
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时 确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
Qt：实现单例模式
m0_71489826的博客
09-17 737
记录一下。
[JavaEE]单例模式(以懒汉模式和饿汉模式为例)
weixin_75071792的博客
09-16 555
上述代码就是"饿汉模式"的一种简单写法,而所谓的饿表示"非常急迫",实例是在类加载的时候就已经创建了,而创建的时机非常早,相当于程序一启动,实例就创建了,就使用"饿汉"形容"创建实例非常急迫 非常早".举个栗子,有的时候,代码中需要有一个对象来管理,持有大量数据,此时有一个对象就可以了,比如,一个对象管理了 10G 的数据,如果你不小心创建出了多个对象,内存空间机会成倍增长,机器就顶不住了.这样的设定仍然可以保证,该类的实例是唯一一个,与此同时,创建实例的时机就不是程序驱动时了。
【C++ 设计模式】单例模式的两种懒汉式和饿汉式
Hou_lang_LJ的博客
09-14 512
🐧①单例模式：懒汉式和饿汉式；🖊
【iOS】单例模式
2301_80467753的博客
09-11 1143
在进行大项目编写之前，开始对前面比较重要的知识进行回顾和重新学习，单例模式在软件开发设计中是比较重要的，尤其是它的初始化，笔者重新学习了单例模式并作该笔记。
创建型模式-单例模式
wrxfxdd的博客
09-14 1333
单例模式
Java面试：设计模式详解——单例、工厂、抽象工厂与代理模式
"本文主要介绍了Java面试中常见的几种设计模式，包括单例模式、工厂模式、抽象工厂模式、代理模式以及MVC模式，并通过实际例子帮助理解这些模式的原理和应用。" ### 单例模式 单例模式是一种限制类只能拥有一个实例...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值