java中的单例模式、多例模式、工厂模式

在学习java的过程中，java存在着几大特征中：抽象、封装、继承、多态，抽象与封装构成了我们所编写的各种类，而在我们创建类的实例即对象时候，常常用new Object（）方法进行构建，而以下是在创建对象时所涉及的几种模式。

单例模式

指在创建对象使用一种方式使其系统中只会构建一个对象，所有请求都由这个对象进行处理，即在编写代码创建对象中，只会创建一个对象实例。

常见单例模式实现方法：
思想：利用一种方法返回一个对象而不是"new 对象"的方式创建对象，保证无论时候我们要使用的该对象只是一个相同的对象。

1. 懒汉模式： 所谓懒汉，顾名思义就是在需要的时候才会创建对象并返返回。

/**
 * 懒汉模式
 */
public class TObject {

    private static TObject object;

    //构造函数私有化
    private TObject() {
        super();
        System.out.println("创建了Tobject对象:"+this.toString());
    }

    /**
     * 懒汉模式获取对象
     * @return
     */
    public static TObject getInstance(){
        if (object==null){
            object=new TObject();
        }
        return object;
    };

}

2. 饿汉模式： 一开始就创建对象，在遇到需求的时候返回该对象，但只会返回最开始构建的对象。

/**
 * 饿汉模式
 */
public class TObject1 {
    private static TObject1 object1=new TObject1();
    /**
     * 构造函数私有化
     */
    private TObject1() {
        super();
        System.out.println("创建了TObject1对象"+this.toString());
    }

    public static TObject1 getInstance(){
        return object1;
    }
}

测试类：

/**
 * 该类是测试单例模式类
 */
public class ModeTest {

    /**
     * 懒汉模式测试
     */
    @Test
    public void lazyModeTest(){
        TObject object1=TObject.getInstance();//懒汉单例模式
        TObject object2=TObject.getInstance();//懒汉单例模式
        if (object1==object2){
            System.out.println("o1与o2相同");
        }

    }

    /**
     * 饿汉模式测试
     */
    @Test
    public void hungerModeTest(){
        TObject1 object3=TObject1.getInstance();//饿汉单例模式
        TObject1 object4=TObject1.getInstance();//饿汉单例模式
        if (object3==object4){
            System.out.println("o3与o4相同");
        }
    }
}

测试结果：


总结：在单例模式实现中，我们必须将对象类构造方法隐藏掉不对外暴露，再构建static 对象,利用静态方法将其返回。

多例模式

所谓多例(Multiton Pattern)实际上就是单例模式的自然推广，属于对象
创建类型的模式，多例模式其实就是限制了对象的数量，并且有可能对对象进行重复使用。
引用别人代码：（原帖：https://blog.csdn.net/qq_29924041/article/details/87277689 —CSDN博主「^_ 小小码nong」的原创文章）

public class Emperor {
	private static final int maxNumberOfEmperor = 2;
	private static ArrayList emperorInfoList = new ArrayList(maxNumberOfEmperor);
	private static ArrayList emperorList = new ArrayList(maxNumberOfEmperor);
	
	private static int countNumofEmperor = 0;
	
	static{
		for(int i = 0; i < maxNumberOfEmperor ; i++){
			emperorList.add(new Emperor("第"+i+"皇帝"));
		}
	}
	
	
	private Emperor(){
		
	}
	
	private Emperor(String info){
		emperorInfoList.add(info);
	}
	
	public static Emperor getInstance(int num){
		countNumofEmperor = num;
		if (num == 0) {
			return (Emperor) emperorList.get(0);
		}else if(num == 1){
			return (Emperor) emperorList.get(1);
		}else{
			System.out.println("error");
			return null;
		}
	}
	
	  public static Emperor getInstance(){  
	        Random random=new Random();  
	        countNumofEmperor=random.nextInt(maxNumberOfEmperor);  
	        return (Emperor)emperorList.get(countNumofEmperor);  
	  }  
	
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return (String) emperorInfoList.get(countNumofEmperor);
	}
}

工厂模式：

指创建工厂来产生对象，取得对象都需要通过工厂生产取得。
具体可看：
https://www.cnblogs.com/yssjun/p/11102162.html
讲得很好！

引用资料
单例模式——饿汉模式（作者：TLpigff）
设计模式-单例与多例的区别（转自： robbin_ch）

记录一下以便于学习，如有错误，不吝赐教，共同探讨！！。