设计模式单例模式

实例

/**
 * 单例模式
 * 应用场合：有些对象只需要有一个就足够了
 * 作用：保证整个应用程序中某个实例有且只有一个
 * 类型：饿汉与懒汉
 * */
public class Singleton {
	/**
	 * 1.将构造方法私有化，不允许外部直接创建对象
	 * */
	private Singleton(){
	}
	/**
	 * 2.创建类的实例是唯一的，使用private static 修饰
	 * 将类实例定义成static静态可以让外部类通过Singleton s1=Singleton.instance;这种方式调用
	 * */
	static Singleton instance=new Singleton();
}

public class test {
   public static void main(String[] args) {
	   //创建了一个Singleton实例
	   /**
	    * 之所以可以创建实例是因为在Singleton中有一个默认公开的构造方法
	    * 将构造方法重写成私有的,外界就无法在直接通过构造方法创建时实例了，就可避免多个实例出现
	    * 
	    * */
	  Singleton s1=Singleton.instance;
	  Singleton s2=Singleton.instance;
	  
	  if(s1==s2){
		  System.out.println("s1与s2是同一个实例");
	  }else{
		  System.out.println("s1与s2不是同一个实例");
	  }
    }
}

结果

s1与s2是同一个实例

 另一个情况：将成员变量改为private时，外部就无法通过那个Singleton.instance方式调用，解决方法(通过封装的方式调整一下代码)

private static Singleton instance=new Singleton();
	
	/**
	 * 4.提供一个获取实例的方法，使用public static 修饰
	 * */
	public static Singleton getInstance(){
		return instance;
		}

 提供了获取实例的方法就可以通过Singleton.getInstance()，来获取到

Singleton s1=Singleton.getInstance();
	  Singleton s2=Singleton.getInstance();

结果

s1与s2是同一个实例

private static Singleton instance=new Singleton();

这段代码什么时候加载呢：static的静态的成员属于类所有，当类加载的时候它就会去执行，所以当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;
	}
}

/**
	   * 懒汉模式
	   * */
	  Singleton s3=Singleton.getInstance();
	  Singleton s4=Singleton.getInstance();
	  
	  if(s3==s4){
		  System.out.println("s3与s4是同一个实例");
	  }else{
		  System.out.println("s3与s4不是同一个实例");
	  }
    }

 区别

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