java设计模式-单例模式Singleton

1. 单例设计模式
      采取一定的方法，保证在整个系统运行中，某个类只有一个对象实例
2. 如何实现
      1. 私有化类的构造器   显示写出构造方法，避免new 出系统自带的默认构造方法
      2. 内部创建类的对象
      3. 提供公有的方法，返回累的对象
3. 饿汉和懒汉的区别
      饿汉式： 缺点：创建类的时候就加载，加载时间过长
              优点：线程是安全的
      懒汉式： 延迟对象加载。

package singleton;

// 饿汉单例模式
public class Singletontest {

    //1. 私有化类的构造器
    private Singletontest() {
    }

    //2. 内部创建类的对象
    private static Singletontest Singleton_instance = new Singletontest();

    //3. 提供公有的方法，返回累的对象
    public static Singletontest getSingletoninstance() {
        return Singleton_instance;
    }

}

package singleton;

// 懒汉单例模式  在类加载的时候，么有创建静态的对象，而是在调用的时候，在创建
public class Singletontestlazy {

    //1. 私有化类的构造器
    private Singletontestlazy() {
    }
    //2. 声明当前对象么有初始化
    private static Singletontestlazy Singleton_instance = null;

    //3. 声明public、static的返回当前类对象的方法
    public static Singletontestlazy getSingletoninstance() {
        // 如果为空，则还未创建对象，为其创建，如果不为空，则认为已经创建过，则直接返回。单例的本质就是只创建一个全局静态对象，创建共有方法调用
        if (Singleton_instance == null){
            Singleton_instance = new Singletontestlazy();
        }
        return Singleton_instance;

    }

}

package singleton;

//测试
public class TestDemo {

    public static void main(String[] args) {
        //饿汉单例模式测试
        Singletontest s1 =  Singletontest.getSingletoninstance();
        Singletontest s2 =  Singletontest.getSingletoninstance();
        System.out.println(s1 == s2);

        //饱汉单例模式测试
        Singletontestlazy s1lzay = Singletontestlazy.getSingletoninstance();
        Singletontestlazy s2lzay = Singletontestlazy.getSingletoninstance();
        System.out.println(s1lzay == s2lzay);

        // 结果都为true，说明两次创建的对象都是同一个对象
    }
}

饿汉式单例 直接静态生成

package Block;

public class Singleton {
    public static void main(String[] args) {
        Singleton1 s1 = Singleton1.s;

    }
}

class Singleton1{
    private  Singleton1(){}

    public static final Singleton1 s = new Singleton1(); 
}