老师在上面说 如果实现了序列化接口那么其父类的则看不见父类的构造方法被调用。

如果是这样的话，最后的输出结果难道不应该是

bar1...

bar2...

吗？为什么我的结果确实连父类的构造方法也调用了？

package com.Java;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Objectserial2 {
	public static void main(String[] args) throws IOException, Exception {
//		ObjectOutputStream oos=new ObjectOutputStream(
//				new FileOutputStream("exer/obj.dat"));
//		Foo2 foo2=new Foo2();
//		oos.writeObject(foo2);
//		oos.flush();
//		oos.close();
//		
//		//反序列化是否递归调用父类的构造函数
//		ObjectInputStream ois=new ObjectInputStream(
//				new FileInputStream("exer/obj.dat"));
//		Foo2 foo21=(Foo2)ois.readObject();
//		System.out.println(foo21);
//		ois.close();
		
		
		ObjectOutputStream oos=new ObjectOutputStream(
				new FileOutputStream("exer/obj.dat"));
		Bar2 bar2=new Bar2();
		oos.writeObject(bar2);
		oos.flush();
		oos.close();
		
		//反序列化是否递归调用父类的构造函数
		
		ObjectInputStream ois=new ObjectInputStream(
				new FileInputStream("exer/obj.dat"));
		Bar2 bar21=(Bar2)ois.readObject();
		System.out.println(bar21);
		ois.close();
		
		/*
		 * 对子类对象进行反序列化操作时，
		 * 如果父类没有实现序列化接口
		 * 那么其父类的构造函数会被调用
		 */

	}

}




//一个类实现了序列化接口，那么其子类都可以实现序列化

class Foo implements Serializable{
	public Foo(){
		System.out.println("fooo");
	}
}
class Foo1 extends Foo{
	public Foo1(){
		System.out.println("fooo11");
	}
}
class Foo2 extends Foo1{
	public Foo2(){
		System.out.println("foo222");
	}
}

class Bar {
	public Bar(){
		System.out.println("bar");
	}
}
class Bar1 extends Bar implements Serializable{
	public Bar1(){
		System.out.println("bar1...");
	}
}

class Bar2 extends Bar1 {
	public Bar2(){
		System.out.println("bar2...");
	}
}