Java三种设计模式之单例模式、多例模式

单例设计模式：一个类只允许产生一个实例化对象。

（懒汉式存在多线程安全问题，而饿汉式不会）
单例和多例的共同特点

1. 构造方法私有化。
2. 类内部一定会提供一个static方法用于取得实例化对象

饿汉式单例模式

特点:构造方法私有化，外部无法产生新的实例化对象，只能通过private修饰的static方法取得实例化对象

 class Singleton{
     // 在类的内部可以访问私有结构，所以可以在类的内部产生实例化对象  
	//希望整体的操作之中只能够有一个实例化对象,所以加final
	 private  static final Singleton singleton=new Singleton();
	
	 //私有构造方法
	 private Singleton(){
		
	 }
	 public static Singleton getInstance(){
		 return singleton;
	 }
      public void print(){
	   System.out.println("hello");
     }
 }
 public class SingletonTest{
	 public static void main(String[] args){
		 //声明对象
		 Singleton singleton=null;
		 singleton=Singleton.getInstance();
		 singleton.print();
	 }
 }																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																				

懒汉式单例模式

特点：当第一次去使用Singleton对象的时候才会为其产生实例化对象的操作

 class Singleton{
     // 在类的内部可以访问私有结构，所以可以在类的内部产生实例化对象  
	
	 private static Singleton singleton;
	
	 //私有构造方法
	 private Singleton(){
		
	 }
	 public static Singleton getInstance(){
		 if(singleton==null){//表示此时未实例化
			 singleton=new Singleton();
		 }	
		 return singleton;
	 }
      public void print(){
	   System.out.println("hello");
     }
 }
 public class SingletonTest{
	 public static void main(String[] args){
		 //声明对象
		 Singleton singleton=null;
		 singleton=Singleton.getInstance();
		 singleton.print();
	 }
 }

instance = new Singleton()并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情。 给 instance 分配内存 ，调用 Singleton 的构造函数来初始化成员变量， 将instance对象指向分配的内存空间

class Singleton{ 
// 确保产生的对象完整性 
private volatile static Singleton instance = null; 
private Singleton() {} 
public static Singleton getInstance() {
	if(instance==null) { 
	// 检查对象是否初始化 
		synchronized (Singleton.class) {
			 if(instance==null) 
			 // 确保多线程情况下对象只有一个
			  instance = new Singleton();
	   } 
   }
   return instance;
  } 
}

多例设计模式

多例只是比单例追加了更多个内部实例化对象产生。构造方法私有化，类内部需要提供若干个实例化对象，后面通过static方法返回

 //性别多例
 class  Sex{
	 private String title;
	 public static final int M=1;
	 public static final int F=2;
	 private static final Sex MALE=new Sex("男");
	 private static final Sex FEMALE=new Sex("女");
	 private Sex(String title){
		 this.title=title;
	 }
      public static Sex getInstance(int flag){
		  switch(flag){
			  case M: 
			       return MALE;
			  case F: 
			       return FEMALE;
			  default:
			       return null;	
		  }
	 }
	 public String toString(){
		 return this.title;
	 }	
 }
 public class SingletonTest{
	 public static void main(String[] args){
		 Sex sex=Sex.getInstance(Sex.M);
		 System.out.println(sex);
	 }	
 }