Java学习之单例设计模式

已于 2023-04-08 01:37:48 修改
阅读量624 收藏
点赞数
分类专栏： java 文章标签： java 学习 设计模式
于 2023-01-12 19:59:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wjkqq0921/article/details/128616158
版权
本文介绍了Java中的单例设计模式，包括饿汉式和懒汉式的实现方式及其区别。饿汉式在类加载时创建对象，不存在线程安全问题但可能浪费资源；懒汉式在使用时创建对象，可能存在线程安全问题。Java.lang.Runtime是单例模式的经典应用。

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

目录

设计模式

单例模式

一、饿汉式

二、懒汉式

三、饿汉式VS懒汉式

总结

设计模式

1.静态方法和属性的经典使用

2.设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格以及解决问题的思考方式。就像是经典的棋谱，不同的棋局，我们用不同的棋谱，免去我们自己再思考和摸索

单例模式

类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法

一、饿汉式

一般情况下创建对象的代码

package com.hspedu.single_;

public class SingleTon01 {
    public static void main(String[] args) {
        GirlFriend gf1 = new GirlFriend("小红");
        GirlFriend gf2 = new GirlFriend("小黄");
    }
}
class GirlFriend {
    private String name;

    public GirlFriend(String name) {
        this.name = name;
    }
}

构造器私有化，构造器私有化之后无法在main方法内创建新对象 

private GirlFriend(String name) {
        this.name = name;
    }

 解决方法

1.构造器私有化

2.在类中创建新对象

3.创建public static 方法，在方法中return创建的新对象

4.在main方法中通过类名.方法名调用上述方法

package com.hspedu.single_;

public class SingleTon01 {
    public static void main(String[] args) {
//        GirlFriend gf1 = new GirlFriend("小红");
//        GirlFriend gf2 = new GirlFriend("小黄");

        //调用静态方法，获取对象，接收返回的对象
        //调用静态方法，导致类加载，类加载只会进行一次
        GirlFriend gf1 = GirlFriend.getInstance();
        //再次接收
        GirlFriend gf2 = GirlFriend.getInstance();//返回的是同一个对象
        //输出对象，重写toString方法
        System.out.println(gf1);
        System.out.println(gf2);
        System.out.println(gf1 == gf2);//true

     

    }
}
//有一个类，GirlFriend
//只能有一个女朋友
class GirlFriend {
    private String name;
   

    //如何保障我们只能创建一个GirlFriend对象
    //单例模式-饿汉式
    //1.构造器私有化（防止new对象）
    //2.类的内部创建对象(static对象)
    //3.提供一个public static 方法，返回上述创建的对象

    //因为要在static方法中return，所以必须是static修饰
    private static GirlFriend gf = new GirlFriend("小红");

    private GirlFriend(String name) {
        this.name = name;
    }

    //必须是static方法，因为构造器私有化，无法通过对象名.类名调用，只能通过类名.方法名调用
    public static GirlFriend getInstance(){
        return gf;
    }

    @Override
    public String toString() {
        return "GirlFriend{" +
                "name='" + name + '\'' +
                '}';
    }
}

饿汉式的名称由来：在类加载的时候就已经创建好了对象，不论调用不调用，都已经创建好了

eg：

package com.hspedu.single_;

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


        System.out.println(GirlFriend.n1);
    }

}
//有一个类，GirlFriend
//只能有一个女朋友
class GirlFriend {
    private String name;
    public static int n1 = 100;

    //如何保障我们只能创建一个GirlFriend对象
    //单例模式-饿汉式
    //1.构造器私有化（防止new对象）
    //2.类的内部创建对象(static对象)
    //3.提供一个public static 方法，返回上述创建的对象

    //因为要在static方法中return，所以必须是static修饰
    private static GirlFriend gf = new GirlFriend("小红");

    private GirlFriend(String name) {
        System.out.println("GrilFriend构造器被调用...");
        this.name = name;
    }

    //必须是static方法，因为构造器私有化，无法通过对象名.类名调用，只能通过类名.方法名调用
    public static GirlFriend getInstance(){
        return gf;
    }

    @Override
    public String toString() {
        return "GirlFriend{" +
                "name='" + name + '\'' +
                '}';
    }
}

  

上述代码在调用静态变量n1时,就会完成类加载(类加载的第三种情况)，即会完成对象gf的创建，即使上述代码中用不到这个对象 

二、懒汉式

等用到的时候再创建对象

package com.hspedu.single_;

public class SingleTon02 {
    public static void main(String[] args) {
        //调用静态方法，cat的默认值为null
        //执行 cat = new Cat("圆圆");
        Cat instance = Cat.getInstance();
        System.out.println(instance);

        //再次调用静态方法getInstance()
        //经过上述操作，对象cat 已经 ≠ null
        //不会再创建新对象，还是输出“圆圆”，
        // 输出的是同一个对象本体，即两个对象引用指向同一对象
        Cat instance1 = Cat.getInstance();
        System.out.println(instance1);
        System.out.println(instance == instance1);//结果为true
    }
}
class Cat{
    private String name;
    private static Cat cat;//对象为引用
    //构造器私有化
    //定义一个静态属性：对象
    //提供一个public static 方法，返回对象
    private Cat(String name) {
        System.out.println("构造器被调用");
        this.name = name;
    }

    public static Cat getInstance(){
        if(cat == null){
            cat = new Cat("圆圆");
        }
        return cat;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                '}';
    }
}

只有一个对象实例，第二次调用的时候输出的还是第一次创建的对象实例，因此，构造器也只会调用一次

 懒汉式：等到需要用的时候再创建对象，其他时候即使类加载也不会创建对象

package com.hspedu.single_;

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

        //只有用户在调用getInstance()方法时，才会创建对象
        //如果是调用其它的静态成员，则不会创建对象
        //也就是说在需要用到的时候才会创建对象，即懒汉式

        System.out.println(Cat.n1);//只会输出100

    }
}
class Cat{
    private String name;
    public static int n1 = 100;

    private static Cat cat;//对象为引用
    //构造器私有化
    //定义一个静态属性：对象
    //提供一个public static 方法，返回对象
    private Cat(String name) {
        System.out.println("构造器被调用");
        this.name = name;
    }

    public static Cat getInstance(){
        if(cat == null){
            cat = new Cat("圆圆");
        }
        return cat;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                '}';
    }
}

 

 

三、饿汉式VS懒汉式

二者最主要的区别在于

1.创建对象的时机不同: 饿汉式是在类加载就创建了对象实例，而懒汉式是在使用时才创建。

2.饿汉式不存在线程安全问题，懒汉式存在线程安全问题。(线程还没学到)

3.饿汉式存在浪费资源的可能。因为如果程序员一个对象实例都没有使用，那么饿汉式创建的对象就浪费了，懒汉式是使用时才创建，就不存在这个问题。


4.在我们javaSE标准类中，java.lang.Runtime就是经典的单例模式

代码

public class Runtime {
    //私有的static属性：Runtime类的对象实例，在类加载的时候就会创建，饿汉式
    private static Runtime currentRuntime = new Runtime();

    private static Version version;
    
    //public static 方法 返回currentRuntime
    public static Runtime getRuntime() {
        return currentRuntime;
    }
    //构造器私有化
    private Runtime() {}
}

总结

1.单例模式的两种实现方式(1) 饿汉式(2) 懒汉式

2.饿汉式的问题:在类加载时候就创建，可能存在资源浪费问题

3.懒汉式的问题: 线程安全问题，后面学了线程后，再进行完善

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值