Java中的可外化接口-yiteyi-C++库

外部化服务于定制序列化的目的，在这里我们可以决定在流中存储什么。 java中存在的可外部化接口。io用于扩展可序列化接口的外部化。它由两种方法组成，我们必须重写这两种方法才能将对象写入流或从流中读取对象，这两种方法是-

null

// to read object from streamvoid readExternal(ObjectInput in) // to write object into streamvoid writeExternal(ObjectOutput out)

Serializable和Externalizable之间的关键区别

实施： 不像可串行化接口这将通过实现接口来序列化对象中的变量，这里我们必须明确指出要序列化的字段或变量。
方法： Serializable是一个没有任何方法的标记接口。Externalizable接口包含两个方法：writeExternal（）和readExternal（）。
过程： 实现可序列化接口的类将执行默认序列化过程。程序员为实现可外部化接口的类定义的序列化过程。
向后兼容性和控制： 如果您必须支持多个版本，则可以使用Externalizable接口进行完全控制。您可以支持对象的不同版本。如果你实现了Externalizable，你的责任就是序列化超级类。
公共无参数构造函数： Serializable使用反射来构造对象，不需要参数构造函数。但是Externalizable需要公共的无参数构造函数。

下面是外部化的例子-

JAVA

                         // Java program to demonstrate working of Externalization                       
                         // interface                       
                         import                                     java.io.*;                       
                         class                                     Car                                     implements                                     Externalizable {                       
                                                 static                                     int                                     age;                       
                                                 String name;                       
                                                 int                                     year;                       
           
                                                 public                                     Car()                       
                                                 {                       
                                                 System.out.println(                                     "Default Constructor called"                                     );                       
                                                 }                       
           
                                                 Car(String n,                                     int                                     y)                       
                                                 {                       
                                                 this                                     .name = n;                       
                                                 this                                     .year = y;                       
                                                 age =                                     10                                     ;                       
                                                 }                       
           
                                                 @Override                       
                                                 public                                     void                                     writeExternal(ObjectOutput out)                       
                                                 throws                                     IOException                       
                                                 {                       
                                                 out.writeObject(name);                       
                                                 out.writeInt(age);                       
                                                 out.writeInt(year);                       
                                                 }                       
           
                                                 @Override                       
                                                 public                                     void                                     readExternal(ObjectInput in)                       
                                                 throws                                     IOException, ClassNotFoundException                       
                                                 {                       
                                                 name = (String)in.readObject();                       
                                                 year = in.readInt();                       
                                                 age = in.readInt();                       
                                                 }                       
           
                                                 @Override                                     public                                     String toString()                       
                                                 {                       
                                                 return                                     (                                     "Name: "                                     + name +                                     ""                       
                                                 +                                     "Year: "                                     + year +                                     ""                       
                                                 +                                     "Age: "                                     + age);                       
                                                 }                       
                         }                       
           
                         public                                     class                                     ExternExample {                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 Car car =                                     new                                     Car(                                     "Shubham"                                     ,                                     1995                                     );                       
                                                 Car newcar =                                     null                                     ;                       
           
                                                 // Serialize the car                       
                                                 try                                     {                       
                                                 FileOutputStream fo                       
                                                 =                                     new                                     FileOutputStream(                                     "gfg.txt"                                     );                       
                                                 ObjectOutputStream so                       
                                                 =                                     new                                     ObjectOutputStream(fo);                       
                                                 so.writeObject(car);                       
                                                 so.flush();                       
                                                 }                       
                                                 catch                                     (Exception e) {                       
                                                 System.out.println(e);                       
                                                 }                       
           
                                                 // Deserialization the car                       
                                                 try                                     {                       
                                                 FileInputStream fi                       
                                                 =                                     new                                     FileInputStream(                                     "gfg.txt"                                     );                       
                                                 ObjectInputStream si                       
                                                 =                                     new                                     ObjectInputStream(fi);                       
                                                 newcar = (Car)si.readObject();                       
                                                 }                       
                                                 catch                                     (Exception e) {                       
                                                 System.out.println(e);                       
                                                 }                       
           
                                                 System.out.println(                                     "The original car is:"                                     + car);                       
                                                 System.out.println(                                     "The new car is:"                                     + newcar);                       
                                                 }                       
                         }                       

输出：

Default Constructor calledThe original car is:Name: ShubhamYear: 1995Age: 10The new car is:Name: ShubhamYear: 1995Age: 10

在这个例子中，Car类有两个方法——writeExternal和readExternal。因此，当我们将“Car”对象写入OutputStream时，会调用writeExternal方法来持久化数据。readExternal方法也是如此。重构可外部化对象时，首先使用公共无参数构造函数创建实例，然后调用readExternal方法。因此，必须提供无参数构造函数。当一个对象实现可序列化接口、被序列化或反序列化时，不会调用对象的构造函数，因此在构造函数中实现的任何初始化都无法完成。

本文由 Shubham Juneja .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

Java

Java中的可外化接口

JAVA

【100%纯棉】【运费险】【3件仅59元】

2022新款夏季纯棉短袖T恤

京东大额优惠券