Java 设计模式_单例模式

最新推荐文章于 2024-08-31 07:00:00 发布

LZ_Luzhuo

最新推荐文章于 2024-08-31 07:00:00 发布

阅读量391

点赞数 1

分类专栏： java 文章标签：设计模式 java

本文链接：https://blog.youkuaiyun.com/Rozol/article/details/76037457

版权

java 专栏收录该内容

19 篇文章

订阅专栏

本文详细介绍了Java中的单例模式，包括饿汉式、懒汉式、静态内部类实现和枚举方式。重点阐述了各种实现方式的优缺点，如饿汉式的线程安全与内存浪费，懒汉式的内存效率与非线程安全，以及静态内部类和枚举的优雅解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Java 设计模式_单例模式

本文由 Luzhuo 编写,转发请保留该信息.
原文: http://blog.youkuaiyun.com/Rozol/article/details/76037457

类在内存中的对象只有一个
单例模式分为: 饿汉式 / 懒汉式 / 静态内部类 / 枚举

饿汉式

public class 饿汉式 {
    private static final 饿汉式 instance = new 饿汉式();

    private 饿汉式(){}

    public static 饿汉式 getInstance(){
        return instance;
    }
    public void show(){
        System.out.println("饿汉式");
    }
}

在一开始直接创建对象, 而不管你是否用的上该对象, 比较浪费内存;
优点是, 线程安全.

懒汉式

public class 懒汉式 {
    private static 懒汉式 instance;

    private 懒汉式(){}

    public static 懒汉式 getInstance(){
        if (instance == null){
            synchronized (懒汉式.class){
                if (instance == null){
                    instance = new 懒汉式();
                }
            }
        }
        return instance;
    }

    public void show(){
        System.out.println("懒汉式");
    }
}

在你真正用时才创建对象, 比饿汉式节省内存.

静态内部类

public class 静态内部类 {
    private 静态内部类(){}

    public static 静态内部类 getInstance(){
        return Instance.instance;
    }

    /**
     * 静态内部类
     * @author Luzhuo
     */
    private static class Instance{
        private static final 静态内部类 instance = new 静态内部类();
    }

    public void show(){
        System.out.println("静态内部类");
    }

}

static final 只允许被赋值一次, 该对象被赋值后, 直接调用而不会再次创建对象. 且该对象不能再被赋值修改.

枚举

public enum 枚举 {
    Instance;

    public void show(){
        System.out.println("枚举");
    }
}

枚举类型是静态常量, 隐式地用static final修饰过;
源码中使用static{}创建枚举类对象, 所以也属于饿汉式的一种.

使用

public class Test {
    public static void main(String[] args) {
        // 饿汉式
        饿汉式();

        // 懒汉式
        懒汉式();

        // 静态内部类
        静态内部类();

        // 枚举
        枚举();
    }

    public static void 饿汉式(){
        饿汉式 obj1 = 饿汉式.getInstance();
        饿汉式 obj2 = 饿汉式.getInstance();
        obj1.show();
        obj2.show();
        System.out.println(obj1 == obj2); //true
    }

    public static void 懒汉式(){
        懒汉式 obj1 = 懒汉式.getInstance();
        懒汉式 obj2 = 懒汉式.getInstance();
        obj1.show();
        obj2.show();
        System.out.println(obj1 == obj2); //true
    }

    public static void 静态内部类(){
        静态内部类 obj1 = 静态内部类.getInstance();
        静态内部类 obj2 = 静态内部类.getInstance();
        obj1.show();
        obj2.show();
        System.out.println(obj1 == obj2); //true
    }

    private static void 枚举() {
        枚举 obj1 = 枚举.Instance;
        枚举 obj2 = 枚举.Instance;
        obj1.show();
        obj2.show();
        System.out.println(obj1 == obj2); // true
    }
}