最近在研究跨進程通信的問題，於是又再一次研究了，我們熟悉而又陌生的Serializable接口。

那麽好，做過Java開發的朋友肯定對這個接口不陌生吧，Java中就是通過這個接口，來實現了序列化和反序列化的，那麽下面看看使用Serializable接口的小例子。

1. public class User implements Serializable{
2. private String name;
3. private int age;
4. private float height;
5. public String getName() {
6. return name;
7. }
8. public void setName(String name) {
9. this.name = name;
10. }
11. public int getAge() {
12. return age;
13. }
14. public void setAge(int age) {
15. this.age = age;
16. }
17. public float getHeight() {
18. return height;
19. }
20. public void
    setHeight(float height) {
21. this.height = height;
22. }
23. @Override
24. public String toString() {
25. return "User [name=" + name + ", age=" + age + ", height=" + height + "]";
26. }
28. }

public class User implements Serializable{    private String name;    private int age;    private float height;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    public float getHeight() {        return height;    }    public void setHeight(float height) {        this.height = height;    }    @Override    public String toString() {        return "User [name=" + name + ", age=" + age + ", height=" + height + "]";    }    }

上面是我們常見寫法的bean，不過呢，Eclipse就會有這個提示：The serializable class User does not declare a static final serialVersionUID field of type long，意思就是說讓你添加一個serialVersionUID的值。

不過呢，我們就算不添加，那麽也是可以正常序列化的。下面貼一下序列化和反序列化的代碼。

1. public class Test {
3. private static String FILE_PATH = "cache.txt";
5. /**
6. * 測試SerialVersionUID和不同是否能發序列化成功
7. *
8. * @param args
9. */
10. public static void main(String[] args) {
11. // 創建一個對象
12. User user = new User();
13. user.setAge(10);
14. user.setName("小可愛");
15. user.setHeight(175.6f);
16. // 開始序列化
17. ObjToFile(user);
18. // 開始反序列化
19. Object o = FileToObj();
20. System.out.println("=====================");
21. System.out.println(o.toString());
22. }
24. /**
25. * 序列化
26. */<del>
27. </del> public static void ObjToFile(Serializable s) {
28. ObjectOutputStream _Oos = null;
29. try {
30. _Oos = new ObjectOutputStream(new FileOutputStream(FILE_PATH));
31. _Oos.writeObject(s);
32. _Oos.flush();
33. System.out.println("序列化成功！");
34. } catch (FileNotFoundException e) {
35. e.printStackTrace();
36. } catch (IOException e) {
37. e.printStackTrace();
38. } finally {
39. if (_Oos != null) {
40. try {
41. _Oos.close();
42. } catch (IOException e) {
43. e.printStackTrace();
44. }
45. }
46. }
47. }
49. /**
50. * 反序列化
51. */
52. public static Serializable FileToObj() {
53. ObjectInputStream _Ois = null;
54. try {
55. _Ois = new ObjectInputStream(new FileInputStream(FILE_PATH));
56. Serializable s = (Serializable) _Ois.readObject();
57. System.out.println("反序列化成功");
58. return s;
59. } catch (FileNotFoundException e) {
60. e.printStackTrace();
61. } catch (IOException e) {
62. e.printStackTrace();
63. } catch (ClassNotFoundException e) {
64. e.printStackTrace();
65. } finally {
66. if (_Ois != null) {
67. try {
68. _Ois.close();
69. } catch (IOException e) {
70. e.printStackTrace();
71. }
72. }
73. }
74. return null;
75. }
77. }

public class Test {    private static String FILE_PATH = "cache.txt";    /**     * 測試SerialVersionUID和不同是否能發序列化成功     *      * @param args     */    public static void main(String[] args) {        // 創建一個對象        User user = new User();        user.setAge(10);        user.setName("小可愛");        user.setHeight(175.6f);        // 開始序列化        ObjToFile(user);        // 開始反序列化        Object o = FileToObj();        System.out.println("=====================");        System.out.println(o.toString());    }    /**     * 序列化     */<del></del>    public static void ObjToFile(Serializable s) {        ObjectOutputStream _Oos = null;        try {            _Oos = new ObjectOutputStream(new FileOutputStream(FILE_PATH));            _Oos.writeObject(s);            _Oos.flush();            System.out.println("序列化成功！");        } catch (FileNotFoundException e) {            e.printStackTrace();        } catch (IOException e) {            e.printStackTrace();        } finally {            if (_Oos != null) {                try {                    _Oos.close();                } catch (IOException e) {                    e.printStackTrace();                }            }        }    }    /**     * 反序列化     */    public static Serializable FileToObj() {        ObjectInputStream _Ois = null;        try {            _Ois = new ObjectInputStream(new FileInputStream(FILE_PATH));            Serializable s = (Serializable) _Ois.readObject();            System.out.println("反序列化成功");            return s;        } catch (FileNotFoundException e) {            e.printStackTrace();        } catch (IOException e) {            e.printStackTrace();        } catch (ClassNotFoundException e) {            e.printStackTrace();        } finally {            if (_Ois != null) {                try {                    _Ois.close();                } catch (IOException e) {                    e.printStackTrace();                }            }        }        return null;    }}

其實，如果你不添加serialVersionUID，那麽Eclipse在會根據這個類的結構（成員變量，成員變量的個數等），生成一個hash值，然後將這個值作為serialVersionUID。

告訴大家實驗步驟：

1、序列化User對象的時候，不要添加serialVersionUID。

2、然後給User對象添加serialVersionUID = 2L,可以隨便是個long值。

3、開始對新添加的User對象，進行反序列化。

接著大家就可以看到控制臺打印的報錯了。

我這邊的報錯是這樣的：

java.io.InvalidClassException: com.peng.test.User; local class incompatible: stream classdesc serialVersionUID = -2110639933710420778, local class serialVersionUID = 2

Serializable中的serialVersionUID到底有啥用