JavaBean为什么实现Serializable(序列化)接口

Zotero+Obsidian+Bookxnote联动让文献阅读丝滑般体验 摘录文字或图片到Obsidian 阅读详情

今天在面试中遇到了这个问题,关于为什么要继承序列化这个东西,在网上搜了一下大概了解到

一篇是从BlogJava中看到的,大概内容如下:

为什么要使用序列化?最重要的两个原因是:将对象的状态保存在存储媒体中以便可以在以后重新创建出完全相同的副本;按值将对象从一个应用程序域发送至另一个应用程序域。例如,序列化可用于在 ASP.NET 中保存会话状态,以及将对象复制到 Windows 窗体的剪贴板中。它还可用于按值将对象从一个应用程序域远程传递至另一个应用程序域。本文简要介绍了 Microsoft .NET 中使用的序列化。

一.简介
    序列化是指将对象实例的状态存储到存储媒体的过程。在此过程中,先将对象的公共字段和私有字段以及类的名称(包括类所在的程序集)转换为字节流,然后再把字节流写入数据流。在随后对对象进行反序列化时,将创建出与原对象完全相同的副本。
    在面向对象的环境中实现序列化机制时,必须在易用性和灵活性之间进行一些权衡。只要您对此过程有足够的控制能力,就可以使该过程在很大程度上自动进行。例如,简单的二进制序列化不能满足需要,或者,由于特定原因需要确定类中那些字段需要序列化。以下各部分将探讨 .NET 框架提供的可靠的序列化机制,并着重介绍使您可以根据需要自定义序列化过程的一些重要功能。
二.持久存储
    我们经常需要将对象的字段值保存到磁盘中,并在以后检索此数据。尽管不使用序列化也能完成这项工作,但这种方法通常很繁琐而且容易出错,并且在需要跟踪对象的层次结构时,会变得越来越复杂。可以想象一下编写包含大量对象的大型业务应用程序的情形,程序员不得不为每一个对象编写代码,以便将字段和属性保存至磁盘以及从磁盘还原这些字段和属性。序列化提供了轻松实现这个目标的快捷方法。
    公共语言运行时 (CLR) 管理对象在内存中的分布,.NET 框架则通过使用反射提供自动的序列化机制。对象序列化后,类的名称、程序集以及类实例的所有数据成员均被写入存储媒体中。对象通常用成员变量来存储对其他实例的引用。类序列化后,序列化引擎将跟踪所有已序列化的引用对象,以确保同一对象不被序列化多次。.NET 框架所提供的序列化体系结构可以自动正确处理对象图表和循环引用。对对象图表的唯一要求是,由正在进行序列化的对象所引用的所有对象都必须标记为 Serializable(请参阅基本序列化)。否则,当序列化程序试图序列化未标记的对象时将会出现异常。当反序列化已序列化的类时,将重新创建该类,并自动还原所有数据成员的值。
三.按值封送
    对象仅在创建对象的应用程序域中有效。除非对象是从 MarshalByRefObject 派生得到或标记为 Serializable,否则,任何将对象作为参数传递或将其作为结果返回的尝试都将失败。如果对象标记为 Serializable,则该对象将被自动序列化,并从一个应用程序域传输至另一个应用程序域,然后进行反序列化,从而在第二个应用程序域中产生出该对象的一个精确副本。此过程通常称为按值封送。
    如果对象是从 MarshalByRefObject 派生得到,则从一个应用程序域传递至另一个应用程序域的是对象引用,而不是对象本身。也可以将从 MarshalByRefObject 派生得到的对象标记为 Serializable。远程使用此对象时,负责进行序列化并已预先配置为 SurrogateSelector 的格式化程序将控制序列化过程,并用一个代理替换所有从 MarshalByRefObject 派生得到的对象。如果没有预先配置为 SurrogateSelector,序列化体系结构将遵从下面的标准序列化规则(请参阅序列化过程的步骤)。
四.基本序列化
使用二进制格式化程序执行序列化时,一个类的所有成员变量都将被序列化,即使是那些已被标记为私有的变量。在此方面,二进制序列化不同于 XMLSerializer 类,后者只序列化公共字段。
    要使一个类可序列化,最简单的方法是使用 Serializable 属性对它进行标记,如下所示:
[Serializable]
public class MyObject {
   public int n1 = 0;
   public int n2 = 0;
   public String str = null;
}
以下代码片段说明了如何将此类的一个实例序列化为一个文件:
MyObject obj = new MyObject();
obj.n1 = 1;
obj.n2 = 24;
obj.str = "一些字符串";
IFormatter formatter = new BinaryFormatter();
Stream stream = new FileStream("MyFile.bin", FileMode.Create,
FileAccess.Write, FileShare.None);
formatter.Serialize(stream, obj);
stream.Close();
    本例使用二进制格式化程序进行序列化。您只需创建一个要使用的流和格式化程序的实例,然后调用格式化程序的 Serialize 方法。流和要序列化的对象实例作为参数提供给此调用。类中的所有成员变量(甚至标记为 private 的变量)都将被序列化,但这一点在本例中未明确体现出来。在这一点上,二进制序列化不同于只序列化公共字段的 XML 序列化程序。
将对象还原到它以前的状态也非常容易。首先,创建格式化程序和流以进行读取,然后让格式化程序对对象进行反序列化。以下代码片段说明了如何进行此操作。
IFormatter formatter = new BinaryFormatter();
Stream stream = new FileStream("MyFile.bin", FileMode.Open,
FileAccess.Read, FileShare.Read);
MyObject obj = (MyObject) formatter.Deserialize(fromStream);
stream.Close();
// 下面是证明
Console.WriteLine("n1: {0}", obj.n1);
Console.WriteLine("n2: {0}", obj.n2);
Console.WriteLine("str: {0}", obj.str);
    上面所使用的 BinaryFormatter 效率很高,能生成非常紧凑的字节流。所有使用此格式化程序序列化的对象也可使用它进行反序列化,对于序列化将在 .NET 平台上进行反序列化的对象,此格式化程序无疑是一个理想工具。需要注意的是,对对象进行反序列化时并不调用构造函数。对反序列化添加这项约束,是出于性能方面的考虑。但是,这违反了对象编写者通常采用的一些运行时约定,因此,开发人员在将对象标记为可序列化时,应确保考虑了这一特殊约定。
如果要求具有可移植性,请使用 SoapFormatter。所要做的更改只是将以上代码中的格式化程序换成 SoapFormatter,而 Serialize 和 Deserialize 调用不变。对于上面使用的示例,该格式化程序将生成以下结果。
<SOAP-ENV:Envelope
   xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance
   xmlns:xsd="http://www.w3.org/2001/XMLSchema"
   xmlns:SOAP- ENC=http://schemas.xmlsoap.org/soap/encoding/
   xmlns:SOAP- ENV=http://schemas.xmlsoap.org/soap/envelope/
   SOAP-ENV:encodingStyle=
   "http://schemas.microsoft.com/soap/encoding/clr/1.0
http://schemas.xmlsoap.org/soap/encoding/"
   xmlns:a1="http://schemas.microsoft.com/clr/assem/ToFile">
   <SOAP-ENV:Body>
     <a1:MyObject id="ref-1">
       <n1>1</n1>
       <n2>24</n2>
       <str id="ref-3">一些字符串</str>
     </a1:MyObject>
   </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
    需要注意的是,无法继承 Serializable 属性。如果从 MyObject 派生出一个新的类,则这个新的类也必须使用该属性进行标记,否则将无法序列化。例如,如果试图序列化以下类实例,将会显示一个 SerializationException,说明 MyStuff 类型未标记为可序列化。
public class MyStuff : MyObject
{
   public int n3;
}
    使用序列化属性非常方便,但是它存在上述的一些限制。有关何时标记类以进行序列化(因为类编译后就无法再序列化),请参考有关说明(请参阅下面的序列化规则)。
五.选择性序列化
    类通常包含不应被序列化的字段。例如,假设某个类用一个成员变量来存储线程 ID。当此类被反序列化时,序列化此类时所存储的 ID 对应的线程可能不再运行,所以对这个值进行序列化没有意义。可以通过使用 NonSerialized 属性标记成员变量来防止它们被序列化,如下所示:
[Serializable]
public class MyObject
{
   public int n1;
   [NonSerialized] public int n2;
   public String str;
}
六.自定义序列化
    可以通过在对象上实现 ISerializable 接口来自定义序列化过程。这一功能在反序列化后成员变量的值失效时尤其有用,但是需要为变量提供值以重建对象的完整状态。要实现 ISerializable,需要实现 GetObjectData 方法以及一个特殊的构造函数,在反序列化对象时要用到此构造函数。以下代码示例说明了如何在前一部分中提到的 MyObject 类上实现 ISerializable。
[Serializable]
public class MyObject : ISerializable
{
   public int n1;
   public int n2;
   public String str;
   public MyObject()
   {
   }
   protected MyObject(SerializationInfo info, StreamingContext context)
   {
     n1 = info.GetInt32("i");
     n2 = info.GetInt32("j");
     str = info.GetString("k");
   }
   public virtual void GetObjectData(SerializationInfo info,
StreamingContext context)
   {
     info.AddValue("i", n1);
     info.AddValue("j", n2);
     info.AddValue("k", str);
   }
}
    在序列化过程中调用 GetObjectData 时,需要填充方法调用中提供的SerializationInfo 对象。只需按名称/值对的形式添加将要序列化的变量。其名称可以是任何文本。只要已序列化的数据足以在反序列化过程中还原对象,便可以自由选择添加至 SerializationInfo 的成员变量。如果基对象实现了 ISerializable,则派生类应调用其基对象的 GetObjectData 方法。
    需要强调的是,将 ISerializable 添加至某个类时,需要同时实现 GetObjectData 以及特殊的构造函数。如果缺少 GetObjectData,编译器将发出警告。但是,由于无法强制实现构造函数,所以,缺少构造函数时不会发出警告。如果在没有构造函数的情况下尝试反序列化某个类,将会出现异常。在消除潜在安全性和版本控制问题等方面,当前设计优于SetObjectData 方法。例如,如果将 SetObjectData 方法定义为某个接口的一部分,则此方法必须是公共方法,这使得用户不得不编写代码来防止多次调用 SetObjectData 方法。可以想象,如果某个对象正在执行某些操作,而某个恶意应用程序却调用此对象的 SetObjectData 方法,将会引起一些潜在的麻烦。
    在反序列化过程中,使用出于此目的而提供的构造函数将 SerializationInfo 传递给类。对象反序列化时,对构造函数的任何可见性约束都将被忽略,因此,可以将类标记为 public、protected、internal 或 private。一个不错的办法是,在类未封装的情况下,将构造函数标记为 protect。如果类已封装,则应标记为 private。要还原对象的状态,只需使用序列化时采用的名称,从 SerializationInfo 中检索变量的值。如果基类实现了 ISerializable,则应调用基类的构造函数,以使基础对象可以还原其变量。
    如果从实现了 ISerializable 的类派生出一个新的类,则只要新的类中含有任何需要序列化的变量,就必须同时实现构造函数以及 GetObjectData 方法。以下代码片段显示了如何使用上文所示的 MyObject 类来完成此操作。
[Serializable]
public class ObjectTwo : MyObject
{
   public int num;
   public ObjectTwo() : base()
   {
   }
   protected ObjectTwo(SerializationInfo si, StreamingContext context) :
base(si,context)
   {
     num = si.GetInt32("num");
   }
   public override void GetObjectData(SerializationInfo si,
StreamingContext context)
   {
     base.GetObjectData(si,context);
     si.AddValue("num", num);
   }
}
    切记要在反序列化构造函数中调用基类,否则,将永远不会调用基类上的构造函数,并且在反序列化后也无法构建完整的对象。对象被彻底重新构建,但是在反系列化过程中调用方法可能会带来不良的副作用,因为被调用的方法可能引用了在调用时尚未反序列化的对象引用。如果正在进行反序列化的类实现了 IDeserializationCallback,则反序列化整个对象图表后,将自动调用 OnSerialization 方法。此时,引用的所有子对象均已完全还原。有些类不使用上述事件侦听器,很难对它们进行反序列化,散列表便是一个典型的例子。在反序列化过程中检索关键字/值对非常容易,但是,由于无法保证从散列表派生出的类已反序列化,所以把这些对象添加回散列表时会出现一些问题。因此,建议目前不要在散列表上调用方法。
七.序列化过程的步骤
    在格式化程序上调用 Serialize 方法时,对象序列化按照以下规则进行:
检查格式化程序是否有代理选取器。如果有,检查代理选取器是否处理指定类型的对象。如果选取器处理此对象类型,将在代理选取器上调用 ISerializable.GetObjectData。
如果没有代理选取器或有却不处理此类型,将检查是否使用 Serializable 属性对对象进行标记。如果未标记,将会引发 SerializationException。
如果对象已被正确标记,将检查对象是否实现了 ISerializable。如果已实现,将在对象上调用 GetObjectData。
如果对象未实现 Serializable,将使用默认的序列化策略,对所有未标记为 NonSerialized 的字段都进行序列化。 八.版本控制
    .NET 框架支持版本控制和并排执行,并且,如果类的接口保持一致,所有类均可跨版本工作。由于序列化涉及的是成员变量而非接口,所以,在向要跨版本序列化的类中添加成员变量,或从中删除变量时,应谨慎行事。特别是对于未实现 ISerializable 的类更应如此。若当前版本的状态发生了任何变化(例如添加成员变量、更改变量类型或更改变量名称),都意味着如果同一类型的现有对象是使用早期版本进行序列化的,则无法成功对它们进行反序列化。
如果对象的状态需要在不同版本间发生改变,类的作者可以有两种选择:
实现 ISerializable。这使您可以精确地控制序列化和反序列化过程,在反序列化过程中正确地添加和解释未来状态。
使用 NonSerialized 属性标记不重要的成员变量。仅当预计类在不同版本间的变化较小时,才可使用这个选项。例如,把一个新变量添加至类的较高版本后,可以将该变量标记为 NonSerialized,以确保该类与早期版本保持兼容。
九.序列化规则
    由于类编译后便无法序列化,所以在设计新类时应考虑序列化。需要考虑的问题有:是否必须跨应用程序域来发送此类?是否要远程使用此类?用户将如何使用此类?也许他们会从我的类中派生出一个需要序列化的新类。只要有这种可能性,就应将类标记为可序列化。除下列情况以外,最好将所有类都标记为可序列化:
    所有的类都永远也不会跨越应用程序域。如果某个类不要求序列化但需要跨越应用程序域,请从 MarshalByRefObject 派生此类。
    类存储仅适用于其当前实例的特殊指针。例如,如果某个类包含非受控的内存或文件句柄,请确保将这些字段标记为 NonSerialized 或根本不序列化此类。
某些数据成员包含敏感信息。在这种情况下,建议实现 ISerializable 并仅序列化所要求的字段。

另外一篇是从JavaEye中看到的

经常看到有些类调用了Serializable接口,而有些类又没有调用Serializable接口。那么什么情况下要调用Serializable接口。
    首先来了解一下Serializable。(类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。序列化接口Serializable没有方法或字段,仅用于标识可序列化的语义)
    实现了Serializable接口的对象,可将它们转换成一系列字节,并可在以后完全恢复回原来的样子。这一过程亦可通过网络进行。这意味着序列化机制能自动补偿操作系统间的差异。换句话说,可以先在Windows机器上创建一个对象,对其序列化,然后通过网络发给一台Unix机器,然后在那里准确无误地重新“装配”。不必关心数据在不同机器上如何表示,也不必关心字节的顺序或者其他任何细节。
    serialization主要用来支持2种主要的特性:
    1、RMI(Remote method invocation)。RMI允许象在本机上一样操作远程机器上的对象。当发送消息给远程对象和调用远程方法时,就需要用到serializaiton机制来发送参数和接收返回值。
    2、保存信息。在某个时候把状态信息保存起来,以便以后某个时候能恢复这些状态信息。
    Hibernaet和EJB中的实体Bean就用到了上面两个特性。
    另外:保存的时候不仅能保存对象的副本,而且还会把对象里面所引用的对象也保存起来,以此类推。就像在编译某个类一样,会涉及到所用到的所有类。但是所引用的对象也必须是可序列化的,不然会抛NotSerializableException异常。
    下面来写个例子:(A和B类都是可序列化的,WriteObj:将A序列化,ReadObj:将A反序列化) 

Java代码

  1. package woxingwosu;  
  2. import java.io.Serializable;  
  3. public class A implements Serializable{  
  4. private String name="my name is a";  
  5. private B b=null;  
  6.     A(){  
  7.         b=new B();  
  8.     }  
  9. public B getB() {  
  10. return b;  
  11.     }  
  12. public void setB(B b) {  
  13. this.b = b;  
  14.     }  
  15. public String getName() {  
  16. return name;  
  17.     }  
  18. public void setName(String name) {  
  19. this.name = name;  
  20.     }  
  21. public String show(){  
  22. return "a.toString <a.name=\""+this.name+"\" a.b.name=\""+this.b.getName()+"\">"
  23.             +"\na="+this.toString()+" b="+this.b.toString();  
  24.     }  
  25. } 

Java代码

  1. package woxingwosu;  
  2. import java.io.Serializable;  
  3. public class B implements Serializable{  
  4. private String name="my name is B";  
  5.     B(){}  
  6. public String getName() {  
  7. return name;  
  8.     }  
  9. public void setName(String name) {  
  10. this.name = name;  
  11.     }  
  12. } 

Java代码

  1. package woxingwosu;  
  2. import java.io.FileOutputStream;  
  3. import java.io.ObjectOutputStream;  
  4. /**
  5. * 写Object(系列化)
  6. * @author 我行我素
  7. */
  8. public class WriteSeri {  
  9. public static void main(String[] args) {  
  10.         ObjectOutputStream outObj=null;  
  11. try{  
  12.             FileOutputStream outStr=new FileOutputStream("obj.txt");  
  13.             outObj=new ObjectOutputStream(outStr);  
  14.             A a=new A();  
  15.             outObj.writeObject(a);  
  16.             System.out.println("write obj :"+a.show());  
  17.             outObj.flush();  
  18.         }catch(Exception e){  
  19.             e.printStackTrace();  
  20.         }finally{  
  21. try{  
  22. if(outObj!=null)  
  23.                     outObj.close();  
  24.             }catch(Exception e){  
  25.                 e.printStackTrace();  
  26.             }  
  27.         }  
  28.     }  
  29. } 

Java代码

  1. package woxingwosu;  
  2. import java.io.FileInputStream;  
  3. import java.io.ObjectInputStream;  
  4. /**
  5. * 读Object(反系列化)
  6. * @author 我行我素
  7. */
  8. public class ReadSeri {  
  9. public static void main(String[] args) {  
  10.         ObjectInputStream inObj=null;  
  11. try{  
  12.             FileInputStream inStr=new FileInputStream("obj.txt");  
  13.             inObj=new ObjectInputStream(inStr);  
  14.             A a=(A)inObj.readObject();  
  15.             System.out.println("read Object :"+a.show());  
  16.         }catch(Exception e){  
  17.             e.printStackTrace();  
  18.         }finally{  
  19. try{  
  20. if(inObj!=null)  
  21.                     inObj.close();  
  22.             }catch(Exception e){  
  23.                 e.printStackTrace();  
  24.             }  
  25.         }  
  26.     }  
  27. } 

首先,我们运行WriteObj,实现序列化,得到输出结果

write obj :a.toString <a.name="my name is a" a.b.name="my name is B">
a=woxingwosu.A@a90653 b=woxingwosu.B@de6ced

然后我们再运行ReadObj,实现反序列化,得到输出结果

read Object :a.toString <a.name="my name is a" a.b.name="my name is B">
a=woxingwosu.A@a90653 b=woxingwosu.B@de6ced

官方文档:如果可序列化类未显式声明 serialVersionUID,则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值,如“Java(TM) 对象序列化规范”中所述。不过,强烈建议 所有可序列化类都显式声明 serialVersionUID 值,原因计算默认的 serialVersionUID 对类的详细信息具有较高的敏感性,根据编译器实现的不同可能千差万别,这样在反序列化过程中可能会导致意外的 InvalidClassException。因此,为保证 serialVersionUID 值跨不同 java 编译器实现的一致性,序列化类必须声明一个明确的 serialVersionUID 值。还强烈建议使用 private 修改器显示声明 serialVersionUID(如果可能),原因是这种声明仅应用于立即声明类 -- serialVersionUID 字段作为继承成员没有用处。
    刚才写的例子中就没有用到serialVersionUID,这时JVM会根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段作为serialVersionUID。但是如果序列化和反序列化的JVM版本不一样的话,还是显示写上serialVersionUID安全。

华为OD机考2025B卷 - 报文响应时间(Java & Python& JS & C++ & C ) 华为OD机考2025B卷 - 报文响应时间 阅读详情

相关推荐

从HPPC测试到Simulink仿真:锂电池二阶RC模型参数辨识完整流程

本文详细介绍了从HPPC测试到Simulink仿真的锂电池二阶RC模型参数辨识完整流程。通过HPPC测试获取实验数据,利用Simulink的Parameter Estimation工具进行参数辨识和模型验证,为BMS算法开发提供精确的电池模型。文章涵盖测试设计、数据预处理、模型搭建及工程应用等关键步骤,助力新能源电池研发。

whisky的博客 687

Java学习中关于实现Serializable接口

Java学习中关于实现Serializable接口   为了保存在内存中的各种对象的状态(也就是实例变量,不是方法),并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保存object states,但是Java为我们提供一种很好保存对象状态的机制,那就是序列化。   简单来说序列化就是一种用来处理对象流的机制,所谓对象流也就是将对象的内容进行流化,流的概念这里不用多说(...

weixin_30485379的博客 320

Android图形系统(三)系统篇:渲染/合成的底层原理浅析

众所周知,渲染工作是由GPU负责,那么在聊GPU之前首先得知道什么是“渲染”?我们来举个例子感受一下在系统中申请一块10*101、把图层背景这玩意染成绿的2、从左上(0,0)到右下(10,10)画一条宽度为1颜色为红色的直线3、以坐标点(5,5)为中心,画一个半径为3的实心圆,颜色要蓝色好了,接下来操作系统会把这些“绘图指令”同步给GPU去执行渲染任务图片来源:自己画的GPU完成渲染工作后,我们将会得到一个大小为10*10二维数组,数组中的每个元素都保存着坐标点的颜色信息、深度信息。

1360

JavaBean 实现 implements Serializable 序列化

package com.qhyc.bonus.bean; import java.io.Serializable; import com.org.base.util.Models; public class bonusBean extends Models imp...

315

akshare 布林通道策略

import datetime import pandas as pd import backtrader as bt import matplotlib.pyplot as plt from datetime import datetime import matplotlib import akshare as ak %matplotlib inline class Boll_strategy(bt.Strategy): #自定义参数,每次买入1800手 params=(('size'.

qq_26742269的博客 5346

从配置文件加载顺序揭秘:为什么你的logback.xml读不到application.yml?

本文深入解析了Spring Boot中logback.xml无法读取application.yml配置的原因,揭示了Spring Boot配置加载机制与日志系统初始化的时序问题。通过对比logback.xml与logback-spring.xml的差异,提供了使用springProperty标签和系统属性传递等解决方案,帮助开发者有效解决日志配置问题。

weixin_29214335的博客 365

java.io.Serializable(序列化)接口详细总结

虚拟机是否允许反序列化,不仅取决于类路径和功能代码是否一致,一个非常重要的一点是两个类的序列化 ID 是否一致(就是 private static final long serialVersionUID = 1L)。

小鲁蛋的博客 8591

车载摄像头+max96712 + rk3568 调试过程中遇到的问题

本文主要讲述本人在调试rk3568通过mipi-csi2链接max967812,max96712再外接4路车载摄像头过程中遇到的问题,以及最终如何解决这些问题。图中会贴上很多重要且关键的波形图,以便读者在调试过程中进行比对,分析。 如果在调试过程中,mipi总线上的波形没得什么问题的话,还是抓图失败的情况下,需要着重检查 频率,lane数,摄像头分辨率,摄像头输入图像格式等重要配置。

Amelio Ming 2069

第五课 序列化接口

1、序列化接口 接口 特点 适用场景 Serializable Java中的序列化接口,使用简单,但是开销很大。 将对象序列化到存储设备或将对象序列化后通过网络传输时,用Serializable较简单。 Parcelable Android中的序列化方式,使用稍麻烦,但效率很高。 主要用于内存序列化,性能好。 2、Serializable接口 Serializable是一个空接口,为对象提供标准的序列化和反序列化操作。实现Serializable接口示例:

wishxiaozhu的博客 2845

GeoXCP:可解释人工智能中空间解释的不确定性量化

GeoXCP: uncertainty quantification of spatial explanations in explainable AI提出基于保形预测(conformal prediction)的不确定性量化框架——地理空间解释保形预测(GeoXCP),将空间依赖纳入建模过程,生成具有校准不确定性估计的空间自适应解释。通过大量模拟实验和真实世界数据集验证,GeoXCP在不同地理空间场景中能提供可靠解释并有效量化不确定性,推动可解释地理空间机器学习的发展,帮助决策者评估模型驱动洞察的可信度。

May the Force be with you 244

EtherCAT用TwinCAT 3跑DC报0x2C或者0x1A错误码

EtherCAT用TwinCAT 3跑DC报0x2C或者0x1A DC报错 ///////////////////////////////////////////////////////////////////////////////////////// /** \brief Checks communication and synchronisation variables and update AL status / AL status code if an error has occurr

PI_sunyang的博客 5308

mysql 序列化有什么好处_Serializable有什么作用

一般情况下,我们在定义实体类时会继承Serializable接口,类似这样:一般情况下,我们在定义实体类时会继承Serializable接口,类似这样:我们在实体类中引用了Serializable这个接口,那么这个接口到底有什么?细心的你会发现我们还定义了个serialVersionUID变量。这个变量到底有什么作用?什么是Serializable接口一个对象序列化的接口,一个类只有实现了Seri...

weixin_28844235的博客 715

MATLAB与ROS联合仿真——实例程序搭建思路

MATLAB与ROS联合仿真——实例程序搭建思路

慕羽★的博客 5229

javaBean为什么要实现 序列化 Serializable接口?

Java的"对象序列化"能让你将一个实现了Serializable接口的对象转换成一组byte,这样日后要用这个对象时候,你就能把这些byte数据恢复出来,并据此重新构建那个对象了。这一点甚至在跨网络的环境下也是如此,这就意味着序列化机制能自动补偿操作系统方面的差异。也就是说,你可以在Windows机器上创键一个对象,序列化之后,再通过网络传到Unix机器上,然后在那里进行重建。你不用担心在不同的

4135

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

JAVAbean为何要实现序列化 实现Serializable接口

Java的"对象序列化"能让你将一个实现了Serializable接口的对象转换成一组byte,这样日后要用这个对象时候,你就能把这些byte数据恢复出来,并据此重新构建那个对象了。这一点甚至在跨网络的环境下也是如此,这就意味着序列化机制能自动补偿操作系统方面的差异。也就是说,你可以在Windows机器上创键一个对象,序列化之后,再通过网络传到Unix机器上,然后在那里进行重建。你不用担心在不同的

u010214269的专栏 709

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

javaBean为什么要实现序列化 Serializable接口?

【引用位置:http://blog.163.com/gis_warrior/blog/static/193617173201339105255770/】 Java的"对象序列化"能让你将一个实现了Serializable接口的对象转换成一组byte,这样日后要用这个对象时候,你就能把这些byte数据恢复出来,并据此重新构建那个对象了。这一点甚至在跨网络的环境下也是如此,这就意味着序列化机制能

qq_25361331的博客 317

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

JavaBean (实现 Serializable(可序列化) 接口的类) 里 serialVersionUID 的作用

serialVersionUID作用:         序列化时为了保持版本的兼容性,即在版本升级时反序列化仍保持对象的唯一性。 有两种生成方式:        一个是默认的1L,比如:private static final long serialVersionUID = 1L;        一个是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段,比如:       

Tuzki_520的专栏 1877

为什么javabean要实现java.io.Serializable序列化接口

我们拿用户登录来举例子,当用户登录成功以后,用户信息就被保存到session中了,如果服务器停止,session钝化(持久化到硬盘上,位置是【tomcate安装路径】\work\Catalina\localhost\项目名称),如果不实现序列化接口,将不能持久化,并报错 转载于:https://blog.51cto.com/13579086/2083775...

weixin_33809981的博客 312

javabean规范中要求实现Serializable接口,有什么作用?

javabean规范中要求实现Serializable接口,有什么作用?

bz151531223的专栏 6165

javabean实现serializable接口的作用

一直都清楚JavaBean要继承Java.io.Serializable接口实现序列化,但是一直都没有深究为什么需要序列化?通过查看资料现在简单的描述如下以方便自己理解。 Serialize 是什么? 这是IO存储中的一个概念。计算机中所有的内容都是0或者1的数字。这些数字按顺序排列,便可以表示计算机中的万事万物,当然Java的对象也不例外。在内存中,无论如何表示,对我们的操作都没有影

阶段丶成长的博客 993
上一篇: SSH配置之web.xml .
下一篇: js在上传图片前判断大小
javaBenface
博客等级 码龄15年 21粉丝 7原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值