问题：
序列化是为了作甚
1.数据持久化(少)
2.网络传输对象(多)
远程调用RMI和远程过程调用RPC都依赖于序列化序列化一般怎么用
第一种
继承serializable接口即可，serializable为标记接口，没有任何方法，但如果一个待序列化对象不实现该接口，将抛出NotSerializableException异常
String，Array，Enum，基本数据类型都可序列化。
跨进程怎么使用序列化，要求就是具有相同的对象class文件，相同指对象的功能和类路径都必须一致。serialVersionUID也一致。
第二种
实现Externalizable接口，该接口是Serializable的子接口
public interface Externalizable extends java.io.Serializable {
// 序列化
void writeExternal(ObjectOutput out) throws IOException;
// 反序列化
void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}
如果序列化时实现该接口，则需要自主控制所有序列化细节。也就是说，该接口是一个正常的接口，使用时遵循JAVA语法即可。作为标记接口的Serializable反序列化时不会调用构造方法，而实现该接口反序列时则需要调用类的无参构造方法，然后调用readExternal()方法。
class User implements Externalizable {
private static final long serialVersionUID = 42L;
private String name;
private transient String password;
public User() {}
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeUTF(name);
out.writeUTF(encrypt(password));
}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
this.name = in.readUTF();
String encryptStr = in.readUTF();
System.out.println(encryptStr);
this.password = decrypt(encryptStr);
}
}
- 什么情况下会序列化，什么情况下不会序列化，我怎么用实践证明它是否序列化。
transient，static 为什么不行，继承关系，子类继承serializable父类未继承serializable的情况，父类继承serializable子类未继承serializable的情况呢，以下代码
怎么看是否序列化 ，上代码
class BaseBean {
public String property1 = "property1";
public String property2 = "property2";
//无参构造,如没有无参构造,子类反序列化会失败
// public BaseBean(){
//
// }
}
class TestBean extends BaseBean implements Serializable {
public static final int serialVersionUID = 1;
public transient String desc = "transient";
public static String prostatic = "static";
}
public class Test2 {
public static void main(String[] args) {
TestBean testBean = new TestBean();
// testBean.property2 = "22222"; 即时定义了为“2222”，如果父类未Serializable继承接口，则返回的还是初始化的值“property2”
System.out.println(testBean);
serialization(testBean, "/Users/xxx/Desktop/testBean.ser");
System.out.println("序列化成功");
TestBean deserialization = deserialization("/Users/xxx/Desktop/testBean.ser");
System.out.println("反序列化成功");
System.out.println(deserialization);
}
public static void serialization(TestBean src, String target) {
FileOutputStream fos = null;
ObjectOutputStream oos = null;
try {
fos = new FileOutputStream(target);
oos = new ObjectOutputStream(fos);
oos.writeObject(src);
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static TestBean deserialization (String target){
FileInputStream fis = null;
ObjectInputStream ois = null;
try {
fis = new FileInputStream(target);
ois = new ObjectInputStream(fis);
Object o = ois.readObject();
return (TestBean) o;
} catch (Exception e) {
e.printStackTrace();
return null;
}finally {
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
问题：请问上图哪些序列化了哪些没有序列化。
**********输出：******************
TestBean{desc='transient', property1='property1', property2='property2'}
序列化成功
反序列化成功
TestBean{desc='null', property1='property1', property2='property2'}
*****如果BaseBean没有无参构造，输出：******
TestBean{desc='transient', property1='property1', property2='property2'}
序列化成功
java.io.InvalidClassException: TestBean; no valid constructor
at java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(ObjectStreamClass.java:169)
at java.io.ObjectStreamClass.checkDeserialize(ObjectStreamClass.java:885)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2099)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1624)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:464)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:422)
at Test2.deserialization(Test2.java:94)
at Test2.main(Test2.java:65)
反序列化成功
null
- 继承
当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口。当一个子类实现序列化，而父类没有实现序列化。序列化正常，但反序列化时抛出异常。
解决办法：父类不实现Serializable接口，但提供一个无参构造方法。此时，子类中的字段可以恢复为序列化前的值，但父类中的字段依然为初始化默认值。
静态
JAVA序列化保存的是对象的状态，而静态变量不是对象的状态而是类的状态，所以序列化不保存静态变量。transient
在不希望被序列化的字段前添加transient关键字，序列化时将忽略该字段。直接输出为null
