Java中的单例设计模式(含模式演示)

一、单例设计模式

1、设计模式:

是很多程序员根据经验编写的代码模板。

2、单例设计模式:

某个类的对象在整个应用程序中只有唯一的一个。

3、设计模式的分类:

(1)饿汉式:

在类的初始化时,就创建了类的对象

(2)懒汉式:

当需要某个类的对象时,再进行创建


二、设计模式类型演示

(一)饿汉式类型一

1、类的创建

/*
2022.7.30
饿汉式一
*/
class One {
    //构造器私有化
    private One() {
    }
    //创建一个One类的对象
    public static final One INSTNCE = new One();
}

2、类的测试

使用到了一个单元测试工具junit@Test:表示使用该测试工具的注解。

import org.junit.Test;
public class TestSingle {
    @Test
    public void test1() {
        One o1 = One.INSTNCE;
        One o2 = One.INSTNCE;
        System.out.println(o1 == o2);
    }

}

3、测试结果

结论:“==”测试的对象的内存地址是相同的 ,所以该类只创建了一个对象。


(二)饿汉式类型二

1、类的创建:

//饿汉式二(采用枚举类型)
enum Two {
    INSTNCE;
}

2、类的测试:

import org.junit.Test;
public class TestSingle {
    @Test
    public void test2() {
        Two o1 = Two.INSTNCE;
        Two o2 = Two.INSTNCE;
        System.out.println(o1 == o2);
    }

}

3、测试结果:

测试结果同上 


(三)饿汉式类型三

1、类的创建:

//饿汉式三
class Three {
    //构造器私有化
    private Three() {
    }
    //创建该类的一个私有的对象(静态的)
    private static Three instance = new Three();
    //返回创建的对象(声明为静态)
    public static Three getInstance() {
        return instance;
    }
}

2、类的测试:

import org.junit.Test;
public class TestSingle {
    @Test
    public void test3() {
        Three o1 = Three.getInstance();
        Three o2 = Three.getInstance();
        System.out.println(o1 == o2);
    }

}

3、测试结果:

 测试结果同上 


(四)懒汉式类型一

1、类的创建:

//懒汉式一
class Four {
    //构造器私有化
    private Four() {
    }

    //声明一个该类的对象(声明为静态的),但此时还不创建
    private static Four instance;

    //创建对象并返回该类对象
    public static synchronized Four getInstance() {
        //判断一下主程序是否为instance已创建了对象
        //判断对象是否为空、创建对象。有多条指令,存在线程不安全问题,需要加锁(可对方法进行加锁)
        if (instance == null) {
            //创建对象
            instance = new Four();
        }
        return instance;
    }
}

2、类的测试:

import org.junit.Test;
public class TestSingle {
    //声明Four类的对象
    Four o1;
    Four o2;

    @Test
    public void test4() {

        //使用匿名内部类创建线程对象
        Thread t = new Thread("o1") {
            //重写方法
            @Override
            public void run() {
                o1 = Four.getInstance();
            }
        };
        //启动线程
        t.start();
        Thread t1 = new Thread("o1") {
            //重写方法
            @Override
            public void run() {
                o2 = Four.getInstance();
            }
        };
        t1.start();
        //线程加塞,使上面两个线程获取到Four类的对象
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("o1=" + o1);
        System.out.println("o2=" + o2);
        System.out.println(o1 == o2);
    }
}

3、测试结果:

  测试结果同上 


(五)懒汉式类型二

1、类的创建:

//懒汉式二
class Five {
    //构造器私有化
    private Five() {
    }

    //创建一个静态内部类
    private static class Inner {
        //在内部类中创建外部类的对象(声明为静态的)
        static Five instance = new Five();
    }

    //返回外部类的对象(声明为静态的,调用时可直接使用“类名.静态方法名”)
    public static Five getInstance() {
        return Inner.instance;
    }
}

2、类的测试:

import org.junit.Test;

public class TestSingle {
    @Test
    public void test5() {
        Five o1 = Five.getInstance();
        Five o2 = Five.getInstance();
        System.out.println(o1 == o2);
    }

}

3、测试结果:

测试结果同上 


三、总结

实现单例的方式:

(1)构造器私有化。

(2)在类的内部创建好该类的唯一对象。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

华不在意

你的鼓励是我最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值