Java进阶知识体系_单列模式设计

Java进阶知识体系_单列模式设计
适合场景：一个类对外只能提供一个对象
设计步骤：
1，私有化 无参构造方法
2，静态私有化 成员变量 并调用私有化后的无参构造方法初始化
3，定义一个公共静态的方法，对外提供使用的获取对象的接口

1，饿汉式设计
饿汉式类设计

public class HungrySingLeton {
    //饿汉式 单列模式编程，只能创建一个对象
    //1，私有化 无参构造方法
    private HungrySingLeton(){
    };
    //2，静态私有化 成员变量 并调用私有化后的无参构造方法初始化
    private static HungrySingLeton instance = new HungrySingLeton();
    //3，定义一个公共静态的方法，对外提供使用的接口
    public static HungrySingLeton getInstance(){
        return instance; //返回静态私有化的类成员对象
    }
    //4，定义需要具体实现的类行为
    public void doSomething1(){
        System.out.println("您好！");
    }
}

饿汉式类测试

public class HungrySingLetonTest {
    public static void main(String[] agrs) {
        System.out.println("你好，main!");
        //测试饿汉式编程，只能创建一个对象
        HungrySingLeton hungrySingLeton1 = HungrySingLeton.getInstance();
        System.out.println(hungrySingLeton1);
        hungrySingLeton1.doSomething1();
        //再次获取到一个对象，实质上hungrySingLeton2和hungrySingLeton1是同一个对象，指向的内存地址一致
        HungrySingLeton hungrySingLeton2 = HungrySingLeton.getInstance();
        System.out.println(hungrySingLeton2);
        hungrySingLeton2.doSomething1();
    }
}

饿汉式测试结果，获取到的两个对象实际上为同一个对象，指向同一个地址

2，懒汉式设计
懒汉式类设计

public class SluggardSingLeton {
        //懒汉式 单列模式编程，只能创建一个对象
        //1，私有化 无参构造方法
        private SluggardSingLeton(){
        };
        //2，静态私有化 成员变量 ，先不要初始化
        private static SluggardSingLeton instance;
        //3，定义一个公共静态的方法，对外提供使用的接口
        public static SluggardSingLeton getInstance(){
            if(instance == null){
                instance = new SluggardSingLeton();
            }
            return instance; //返回静态私有化的类成员对象
        }
        //4，定义需要具体实现的类行为
        public void doSomething1(){
            System.out.println("懒汉式，您好！");
        }
}

懒汉式测试类设计

public class SluggardSingLetonTest {
    public static void main(String[] agrs) {
        System.out.println("你好，main!");
        //测试饿汉式编程，只能创建一个对象
        SluggardSingLeton sluggardSingLeton1 = SluggardSingLeton.getInstance();
        System.out.println(sluggardSingLeton1);
        sluggardSingLeton1.doSomething1();
        //再次获取到一个对象，实质上sluggardSingLeton2和sluggardSingLeton1是同一个对象，指向的内存地址一致
        SluggardSingLeton sluggardSingLeton2 = SluggardSingLeton.getInstance();
        System.out.println(sluggardSingLeton2);
        sluggardSingLeton2.doSomething1();
    }
}

懒汉式测试结果，获取到的两个对象实际上为同一个对象，指向同一个地址