设计模式学习笔记——单例(Singleton)模式

雨点打透心脏的1/2处 2022-06-17 01:49 169阅读 0赞

# 设计模式学习笔记——单例(Singleton)模式 #

@(设计模式)\[设计模式, 单例模式, Singleton, 懒汉式, 饿汉式\]

*  设计模式学习笔记单例Singleton模式
    
     *  基本介绍
     *  单例案例
        
         *  类图
         *  实现代码
            
             *  饿汉式
                
                 *  Singleton类
                 *  测试类
                 *  运行结果
             *  懒汉式静态内部类
                
                 *  SingleTonLazy类
                 *  测试方法
                 *  运行结果
             *  懒汉式枚举
                
                 *  SingletonEnum类
                 *  测试方法
                 *  运行结果
     *  单例模式中的角色
        
         *  Singleton
         *  类图

## 基本介绍 ##

单例模式，顾名思义，就是一个类只能创建一个实例。

单例模式的定义：

*  想确保任何情况下都绝对只有1个实例
 *  想在程序上表现出“只存在一个实例”

## 单例案例 ##

### 类图 ###

![单例案例类图][SouthEast]

### 实现代码 ###

#### 饿汉式 ####

##### Singleton类 #####

package com.pc.singleton.example;
    
    /** * 单例模式（饿汉式） * Created by Switch on 2017-02-10. */
    public class Singleton { 
        // 实例对象，静态，饿汉式
        private static Singleton instance = new Singleton();
    
        /** * 获取实例对象 * * @return 实例对象 */
        public static Singleton getInstance() {
            return instance;
        }
    
        /** * 私有化构造方法，无法new出来 */
        private Singleton() {
            System.out.println("生成了一个实例");
        }
    }

##### 测试类 #####

package com.pc.singleton.example.test;
    
    import com.pc.singleton.example.SingleTonLazy;
    import com.pc.singleton.example.Singleton;
    import com.pc.singleton.example.SingletonEnum;
    import org.junit.Test;
    
    import java.util.List;
    
    /** * 单例模式测试类 * Created by Switch on 2017-02-10. */
    public class SingletonTest { 
        @Test
        public void testSingleton() {
            System.out.println("饿汉式...");
            Singleton s1 = Singleton.getInstance();
            Singleton s2 = Singleton.getInstance();
            if (s1 == s2) {
                System.out.println("s1与s2是一个对象");
            } else {
                System.out.println("s1与s2不是一个对象");
            }
        }
    }

##### 运行结果 #####

饿汉式...
    生成了一个实例
    s1与s2是一个对象

#### 懒汉式(静态内部类) ####

##### SingleTonLazy类 #####

package com.pc.singleton.example;
    
    /** * 单例模式（懒汉式）——静态内部类 * Created by Switch on 2017-02-10. */
    public class SingleTonLazy { 
        /** * 获取实例对象 * * @return 实例对象 */
        public static SingleTonLazy getInstance() {
            return SingleTon.singleTon;
        }
    
        /** * 静态内部类，只有被调用到才会装载，从而实现了延迟加载 */
        private static class SingleTon { 
            private static SingleTonLazy singleTon = new SingleTonLazy();
    
            static {
                System.out.println("类级别的静态内部类被加载");
            }
    
            private SingleTon() {
                System.out.println("类级别的静态内部类构造方法被调用");
            }
        }
    
        /** * 私有化构造方法，无法new出来 */
        private SingleTonLazy() {
            System.out.println("生成了一个实例");
        }
    }

##### 测试方法 #####

@Test
        public void testSingletonLazy() {
            System.out.println("懒汉式...");
            SingleTonLazy s1 = SingleTonLazy.getInstance();
            SingleTonLazy s2 = SingleTonLazy.getInstance();
            if (s1 == s2) {
                System.out.println("s1与s2是一个对象");
            } else {
                System.out.println("s1与s2不是一个对象");
            }
        }

##### 运行结果 #####

懒汉式...
    生成了一个实例
    类级别的静态内部类被加载
    s1与s2是一个对象

#### 懒汉式(枚举) ####

##### SingletonEnum类 #####

package com.pc.singleton.example;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /** * 单例模式(懒汉式)——枚举 * Created by Switch on 2017-02-10. */
    public enum SingletonEnum {
        /** * 1.从Java1.5开始支持; * 2.无偿提供序列化机制; * 3.绝对防止多次实例化，即使在面对复杂的序列化或者反射攻击的时候; */
        instance;
    
        private String others;
    
        public List<String> buildlList() {
            final List<String> list = new ArrayList<>();
            list.add("Switch");
            list.add("Kity");
            list.add("Tom");
    
            return list;
        }
    
        private SingletonEnum() {
    
        }
    }

##### 测试方法 #####

@Test
        public void testSingletonEnum() {
            System.out.println("懒汉式...");
            SingletonEnum s1 = SingletonEnum.instance;
            SingletonEnum s2 = SingletonEnum.instance;
    
            if (s1 == s2) {
                System.out.println("s1与s2是一个对象");
            } else {
                System.out.println("s1与s2不是一个对象");
            }
    
            List<String> list = SingletonEnum.instance.buildlList();
            for (String s : list) {
                System.out.println(s);
            }
        }

##### 运行结果 #####

懒汉式...
    s1与s2是一个对象
    Switch
    Kity
    Tom

## 单例模式中的角色 ##

### Singleton ###

在`Singleton`模式中，只有`Singleton`这一个角色。`Singleton`角色中有一个返回唯一实例的`static`方法。该方法总是会返回同一个实例。

### 类图 ###

![单例模式类图][SouthEast 1]

GitHub：[DesignPatternStudy][]

——————参考《图解设计模式》

[SouthEast]: /images/20220617/55276e7c50d8475fbd6682b3f308cc3e.png
[SouthEast 1]: /images/20220617/62626235e4444d59a541c919654f418b.png
[DesignPatternStudy]: https://github.com/Switch-vov/DesignPatternStudy