我們知道一個單例類正常情況下只可以產生一個例項，為了能夠達到將單例類轉換成多例類（這裡純粹為了實現而實現沒有必要）

我們可以讓單例類實現Serializable介面，進行序列化

然後反序列化，在進行反序列時，由於單例類實現了序列化介面，因此會自動建立新的類，到達多例的效果

如果任然想在 單例類實現了序列化介面的情況下 依舊產生單例類 可以在單例類中加入readResolve()方法

package com.java.single;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamException;
import java.io.Serializable;
/**
 * 我們知道一個單例類正常情況下只可以產生一個例項，為了能夠達到將單例類轉換成多例類（這裡純粹為了實現而實現沒有必要）
 * 我們可以讓單例類實現Serializable介面，進行序列化
 * 然後反序列化，在進行反序列時，由於單例類實現了序列化介面，因此會自動建立新的類，到達多例的效果
 * 如果任然想在 單例類實現了序列化介面的情況下 依舊產生單例類 可以在單例類中加入readResolve()方法
 */
public class Data {
	//序列化
	public static void writeObject() throws Exception{
		Worm worm = Worm.getInstance();
		ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("d://worm.out"));
		out.writeObject(worm);
		out.close();//關閉的同時也重新整理清空了緩衝區
	}

	//反序列化
	public static Worm readObject() throws Exception{
		ObjectInputStream in = new ObjectInputStream(new FileInputStream("d://worm.out"));
		Worm readWorm = (Worm) in.readObject();
		return readWorm;
	}

	public static void main(String[] args) throws Exception{
//		writeObject();
		Worm worm1 = readObject();
		Worm worm2 = readObject();
		System.out.println(worm1 == worm2);
	}
}


class Worm implements Serializable{
	private static final long serialVersionUID = 1L;
	private static Worm instance = new Worm();//私有的例項成員，在類載入的時候就建立好了單例物件

	private Worm() {//私有構造方法，避免外部建立例項


	}
	public static Worm getInstance(){//僅此有一個公開的靜態方法，得到一個例項
		return instance;//返回例項
	}

	/**
	 * 如果採用了單例的類實現了序列化介面後，在進行反序列時，會自動建立新的類，
	 * 為了解決這個問題，可以採用readResolve()方法
	 */

//	private Object readResolve() throws ObjectStreamException {   
//		return instance;   
//	}   

}
 

 為什麼反序列化會產生新的物件了

 因此Worm readWorm = (Worm) in.readObject();反序列化的時候，只是簡單的恢復資料來建立物件，並沒有去呼叫任何的構造器，

 也就無法判斷改物件例項是否已經存在了，所以反序列化出來的都是 新的物件