import java.io.ByteArrayInputStream;   
import java.io.ByteArrayOutputStream;   
import java.io.ObjectInputStream;   
import java.io.Serializable;   
public class TestClass implements Serializable{   
    private static final long serialVersionUID = 0L;   
    public TestClass() throws Exception {   
        throw new Exception("哎呀媽呀,異常啦!!!!");   
    }   
    public static void main(String[] args) throws Exception {   
        byte[] head = { -84, -19, 0, 5, 115, 114, 0 };   
        byte[] ass = { 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 120, 112 };   
        String name = TestClass.class.getName();   
        ByteArrayOutputStream baos = new ByteArrayOutputStream();   
        baos.write(head);   
        baos.write(name.length());   
        baos.write(name.getBytes());   
        baos.write(ass);   
        baos.flush();   
        baos.close();   
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));   
        TestClass o = (TestClass) ois.readObject();   
        ois.close();   
        System.out.println("建立物件: " + o);   
    }   
}   
 

看到這裡先彆著急執行,先看看.你覺得能夠正常執行嗎? 結果是什麼?
-----------------------------------------------------------------------------------
執行結果:  建立物件: [email protected]
CSDN某帖子 寫道 物件建立的幾種方法:
1.使用new關鍵字 2.使用clone方法 3.反射機制 4.反序列化
其中1,3都會明確的顯式的呼叫建構函式
2是在記憶體上對已有物件的影印 所以不會呼叫建構函式
4是從檔案中還原類的物件 也不會呼叫建構函式
上述程式碼就是反序列化的結果
RednaxelaFX 寫道 嗯順帶推薦Effective Java, Second Edition的第74條 引用 Normally, objects are created using constructors;
serialization is an extralinguistic mechanism for creating objects. Whether
you accept the default behavior or override it, deserialization is a “hidden constructor”
with all of the same issues as other constructors.
大體的意思是反序列化有一定的風險.破壞了封裝.相當於一個隱藏的構造器.
RednaxelaFX 寫道 1、Java的例項構造器只負責初始化，不負責建立物件；Java虛擬機器的位元組碼指令的設計也反映了這一點，有一個new指令專門用於建立物件例項，而呼叫例項構造器則使用invokespecial指令。
2、“this”是作為例項構造器的第一個實際引數傳入的。
Java反序列化實際上是呼叫了基類的構造方法.
ObjectStreamClass中呼叫ReflectionFactory.newConstructorForSerialization(cl, cons);
Objectstreamclass程式碼  

1. cons = reflFactory.newConstructorForSerialization(cl, cons);  

cons = reflFactory.newConstructorForSerialization(cl, cons);

根據cl引數(TestClass類的Class物件)和cons引數(基類Object的構造器)建立了一個新的構造器
列印生成的構造器物件,輸出資訊為public java.lang.Object(),表面生成的構造器是TestClass父類Object的無參構造器.
但是呼叫newInstance()的結果卻產生了TestClass類的物件.(おかしい......)

ReflectionFactory.newConstructorForSerialization()例子
Java程式碼

 

1. Constructor superCons = TestClass.class.getSuperclass().getConstructor();   
2. System.out.println(superCons);   
3. ReflectionFactory reflFactory = ReflectionFactory.getReflectionFactory();   
4. Constructor c = reflFactory.newConstructorForSerialization(TestClass.class,superCons);   
5. System.out.println(c.newInstance());  

        Constructor superCons = TestClass.class.getSuperclass().getConstructor();
        System.out.println(superCons);
        ReflectionFactory reflFactory = ReflectionFactory.getReflectionFactory();
        Constructor c = reflFactory.newConstructorForSerialization(TestClass.class,superCons);
        System.out.println(c.newInstance());

執行結果程式碼  

1. public java.lang.Object()   
2. [email protected]  

public java.lang.Object()
[email protected]

通過基類的方法呼叫生成了子類.繞開了TestClass類的構造方法.生成了看似不可能存在的TestClass物件

-----------------------------------------------------------------------------------
感謝FX,之前一篇關於構造器的詳細論述.傳送門http://rednaxelafx.iteye.com/blog/652719
FX寫的關於本篇的更詳細講解在這裡,傳送門http://rednaxelafx.iteye.com/blog/850082