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）在类的内部创建好该类的唯一对象。