Serialization and deserialization of Java

The public interface Serializable class enables its serialization functionality by implementing the Java.io.Serializable interface. Classes that do not implement this interface will not be able to serialize or deserialize any of their states. All the subtypes of a serializable class are themselves serializable. The serialized interface has no methods or fields and is used only to identify the semantics of serializable.

Serialization is the preservation of the state of an object (the amount of each property), which is then obtained at the appropriate time.
　　
Serialization consists of two parts: serialization and deserialization. Serialization is the first part of this process that decomposes data into a byte stream for storage in a file or on a network. Deserialization is the opening of a byte stream and refactoring the object. Object serialization not only converts the base data type to a byte representation, but sometimes restores the data. Recovering data requires an object instance with recovery data
　　
What are the characteristics of serialization:
　　
If a class can be serialized, its subclasses can also be serialized.

member data declared as static and transient types cannot be serialized.

Static is shared by the class, and when an object of that class is serialized, the static variable may be changed by another object, so this determines that the static variable cannot be serialized, but if it is final, it is possible because this is a constant.

If you declare an instance variable with transient, its value does not need to be maintained when the object is stored. In other words, a member variable tagged with the transient keyword does not participate in the serialization process.

When to use serialization:

Object serialization enables the implementation of distributed objects. Main applications For example: RMI to use object serialization to run a service on a remote host, just as you would when running an object on a local machine.

Java object serialization preserves not only the data of an object, but also the data of each object referenced by the object. You can write the entire object hierarchy to a stream of bytes that can be saved in a file or passed on a network connection. Object serialization allows you to "deep copy" the object, which is to copy the object itself and the referenced object itself. Serializing an object may get the entire sequence of objects.

Java code 650) this.width=650; "class=" star "src=" Http://injavawetrust.iteye.com/images/icon_star.png "alt=" Favorites Code "style = "border:0px;"/>

2. import java.io.Serializable;

6. /**

8.  * 

10. * @author Injavawetrust

12.  *

14.  */

16. Public class Person implements serializable{

20. Private Static Final long serialversionuid = -399858645849256406l;

24. Private String name;

26. Private String sex;

28. Public String GetName () {

30. return name;

32. }

34. Public void setName (String name) {

36. this. Name = name;

38. }

40. Public String Getsex () {

42. return sex;

44. }

46. Public void setsex (String sex) {

48. this. Sex = sex;

50. }

54. }

Java code 650) this.width=650; "class=" star "src=" Http://injavawetrust.iteye.com/images/icon_star.png "alt=" Favorites Code "style = "border:0px;"/> get ""

2. import java.io.File;

4. import Java.io.FileInputStream;

6. import java.io.FileNotFoundException;

8. import Java.io.FileOutputStream;

10. import java.io.IOException;

12. import Java.io.InputStream;

14. import Java.io.ObjectInputStream;

16. import Java.io.ObjectOutputStream;

18. import Java.io.OutputStream;

22. /**

24. * Serialization and deserialization

26. * @author Injavawetrust

28.  *

30.  */

32. Public class Testperson {

36. Public Static void Main (string[] args) {

38. Person person = New person ();

40. Person.setname ("Java");

42. Person.setsex ("F");

44. File File = new file ("D:\\person.txt");

46. Try {

48. File.createnewfile ();

50. } catch (IOException e) {

52. E.printstacktrace ();

54. }

56. Try {

58. //Serialization

60. OutputStream OS = new fileoutputstream (file);

62. ObjectOutputStream Oos = new objectoutputstream (OS);

64. Oos.writeobject (person);

66. Oos.flush ();

68. Oos.close ();

70. Os.close ();

72. //Deserialization

74. InputStream is = new fileinputstream (file);

76. ObjectInputStream ois = new ObjectInputStream (IS);

78. Person per = (person) ois.readobject ();

80. System.out.println ("name[" + per.getname () + "]");

82. System.out.println ("sex[" + per.getsex () + "]");

84. Ois.close ();

86. Is.close ();

88. } catch (FileNotFoundException e) {

90. E.printstacktrace ();

92. } catch (IOException e) {

94. E.printstacktrace ();

96. } catch (ClassNotFoundException e) {

98. E.printstacktrace ();

100. }

102. }

106. }

Serialization and deserialization of Java