我们知道一个单例类正常情况下只可以产生一个实例,为了能够达到将单例类转换成多例类(这里纯粹为了实现而实现没有必要)
我们可以让单例类实现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();反序列化的时候,只是简单的恢复数据来创建对象,并没有去调用任何的构造器,
也就无法判断改对象实例是否已经存在了,所以反序列化出来的都是 新的对象