单例模式singleton

/*
 * 单例模式singletom
 * 应用场合:有些对象只要一个就足够了，比如老婆
 * 作用:保证整个应用程序中的实例只有一个
 * 类型:恶汉模型，懒汉模型
 */
//单例模式之懒汉模式
public class singleton {

	//1:构造方法私有化，不允许外界直接创建对象
	private singleton(){

	}
	//2:创建类的唯一实例
	static singleton instance1=new singleton();//法一
	//提供一个获取实例的方法
	//恶汉模式，类加载的时候创建这个实例，没用之前先创建，叫恶汉
	private static singleton instance2=new singleton();//封装
	public static singleton getInstance()
	{
		return instance2;
	}
		}

public class text {

    public static void main(String[] args) {

        //new singleton();
        //有默认构造方法就能创建多个实例，所以我们把构造方法私有化

        singleton s1=singleton.instance1;
        singleton s2=singleton.instance1;
        if (s1==s2) {
            System.out.println("s1和s2是同一个实例");
        }
        else {
            System.out.println("s1和s2不是同一个实例");
        }
        System.out.println("-----以上为法一-----");

        singleton s3=singleton.getInstance();
        singleton s4=singleton.getInstance();
        if (s3==s4) {
            System.out.println("s3和s4是同一个实例");
        }
        else {
            System.out.println("s3和s4不是同一个实例");
        }
        System.out.println("-----以上为法二-----");

        /*
         * s1和s2是同一个实例
           -----以上为法一-----
           s3和s4是同一个实例
           -----以上为法二-----

         */
    }

}

public class Test {

	public static void main(String[] args) {

		singleton2 s5=singleton2.getInstance();
		singleton2 s6=singleton2.getInstance();
		if (s5==s6) {
			System.out.println("s5和s6是同一个实例");
		}
		else {
			System.out.println("s5和s6不是同一个实例");
		}

	}

//懒汉模式
public class singleton2 {

    private singleton2(){

    }
    //声明类的实例，没用实例化
    private static singleton2 intance3;
    public static singleton2 getInstance()
    {
        if (intance3==null) {
            intance3=new singleton2();
            //第一次加载时候创建，以后直接用
        }
        return intance3;
    }
}

区别之懒汉模式和饿汉模式

饿汉模式特点：类加载的时候比较慢，但运行时获取对象的速度比较快，线程安全

懒汉模式特点：类加载的时候比较快，但运行时获取对象的速度比较慢，线程不安全