模式的秘密--单例模式

1，单例模式分：饿汉模式和懒汉模式。

饿汉模式：在加载类的时候就自动创建

懒汉模式：在加载类的时候只声明，只有在调用的时候才创建。

单利模式Singleton

• 应用场合：有些对象只需要一个就够了，如：皇帝，老婆
• 作用：保证某个应用程序中某个实例有且只有一个
• 类型：饿汉模式，懒汉模式
• 区别：饿汉模式的特点是加载类时候比较慢，但是运行时候获取对象的速度比较快。线程安全
• 懒汉模式的特定加载类的时候比较快，但运行时候获取对象比较慢。线程不安全。

单例模式：最重要的是通过构造方法私有化，限制外部初始化实例，在内部创建，通过static关键字，使得外部可以通过类名调用方法，获取类唯一实例。

饿汉模式实例：

package com.Singleton;

/*单利模式Singleton
 * 应用场合：有些对象只需要一个就够了，如：皇帝，老婆
 * 作用：保证某个应用程序中某个实例有且只有一个
 * 类型：饿汉模式，懒汉模式
 * 区别：饿汉模式的特点是加载类时候比较慢，但是运行时候获取对象的速度比较快。线程安全
 *         懒汉模式的特定加载类的时候比较快，但运行时候获取对象比较慢。线程不安全。
 * */

/*饿汉模式：类加载后，这个类实例就会因为static关键字创建
 * */
public class Singleton {
    //1,将构造方法私有化，不允许外部直接创建对象
    private Singleton()
    {
        
    }
    //2,创建唯一的应用实例，使用private static
    private static Singleton instance=new Singleton();
    
    //3,提供一个用于获取实例的方法，使用public static
    public static Singleton getInstance()
    {
        return instance;
    }

}

懒汉模式实例：

package com.Singleton;

/*懒汉模式
 * 懒汉模式：并不会在加载类的时候创建实例，而是在方法调用，用到的时候才会创建。
 * */
public class Singleton2 {
    
    //1,将构造方法私有化，不允许外部直接创建对象
    private Singleton2()
    {
        
    }
    //2,声明类唯一的应用实例，使用private static
    private static Singleton2 instance;
    
    //3,提供一个用于获取实例的方法，使用public static
    public static Singleton2 getInstance()
    {
        if(instance==null)
        {
            instance=new Singleton2();
        }
        return instance;
    }

}

调用这两个类测试：

package com.Singleton;

public class Test {
    
    public static void main(String[] args) {
        
        //饿汉模式
        Singleton s1=Singleton.getInstance();
        Singleton s2=Singleton.getInstance();
        if(s1==s2)
        {
            System.out.println("s1等于s2");
        }
        else
        {
            System.out.println("s1不等于s2");
        }
        
        //懒汉模式
        Singleton2 s3=Singleton2.getInstance();
        Singleton2 s4=Singleton2.getInstance();
        if(s3==s4)
        {
            System.out.println("s3等于s4");
        }
        else
        {
            System.out.println("s3不等于s4");
        }
    }

}