爪哇2博客
关
爪哇2博客

爪哇序列化

这是Java序列化教程的第1部分。

爪哇序列化教程：

爪哇 提供一种称为序列化的机制，以包含对象的字节序或字节序形式持久化Java对象’的数据以及有关对象的信息’的类型和存储在对象中的数据类型。

所以如果我们需要序列化任何 目的 然后可以使用对象对其进行读取和反序列化’的类型和其他信息，以便我们可以检索原始对象。

类ObjectInputStream和ObjectOutputStream是高级流，其中包含用于序列化和反序列化对象的方法。
ObjectOutputStream有许多方法可以序列化对象，但常用的方法是

1
2
3
4
5
6
 
  私人的 虚空 writeObject(ObjectOutputStream 操作系统) 抛出 IOException
  {
   
  }
 

同样，ObjectInputStream具有

1
2
3
4
5
6
 
  私人的 虚空 readObject(ObjectInputStream 是) 抛出 IOException, ClassNotFoundException
  {
   
  }
 

需要在Java中进行序列化吗？

当需要通过网络发送数据或存储在文件中时，通常使用序列化。数据是指对象，而不是文本。

现在的问题是您的网络基础结构和硬盘是可以理解位和字节但不能理解Java对象的硬件组件。

序列化是Java对象的翻译’s的值/状态转换为字节以通过网络发送或保存。反序列化是将字节码转换为相应的java对象。

serialVersionUID的概念：

serialVersionUID用于确保在反序列化期间加载相同的类（在序列化期间使用的类）。serialVersionUID用于对象的版本控制。有关更多信息，请参见 爪哇序列化中的serialVersionUID

对于Java中的序列化：
步骤是：

让我们举个例子：
在src-中创建Employee.java>org.arpit.javapostsforlearning

1，Employee.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
包 组织.Arpit.爪哇postsforlearning;
进口 爪哇.io.可序列化;
上市 类 雇员 实施 可序列化{ 
   私人的 静态的 最后 长 serialVersionUID = 1L; 
 整型 员工ID;
  串 员工姓名;
  串 部门;
 
  上市 整型 getEmployeeId() {
    返回 员工ID;
  }
  上市 虚空 setEmployeeId(整型 员工ID) {
    这个.员工ID = 员工ID;
  }
  上市 串 getEmployeeName() {
    返回 员工姓名;
  }
  上市 虚空 setEmployeeName(串 员工姓名) {
    这个.员工姓名 = 员工姓名;
  }
  上市 串 getDepartment() {
    返回 部门;
  }
  上市 虚空 setDepartment(串 部门) {
    这个.部门 = 部门;
  }
}
 

如上所示，如果要序列化任何类，则 它必须实现Serializable接口，这是标记 接口.
爪哇中的标记接口是没有字段或方法的接口，或者简单的单词空接口在Java中称为标记接口
在src-中创建SerializeMain.java>org.arpit.javapostsforlearning
2. SerializeMain.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
包 组织.Arpit.爪哇postsforlearning;
进口 爪哇.io.FileOutputStream;
进口 爪哇.io.IOException;
进口 爪哇.io.ObjectOutputStream;
 上市 类 SerializeMain {
 
/ **
  * @作者Arpit Mandliya
  */
上市 静态的 虚空 主要(串[] args) {
 
  雇员 emp = 新 雇员();
  emp.setEmployeeId(101);
  emp.setEmployeeName(“阿尔伯特”);
  emp.setDepartment(“ CS”);
  尝试
  {
   FileOutputStream fileOut = 新 FileOutputStream(“ employee.ser”);
   ObjectOutputStream 外流 = 新 ObjectOutputStream(fileOut);
   外流.writeObject(emp);
   外流.关();
   fileOut.关();
  }抓住(IOException i)
  {
   i.printStackTrace();
  }
}
}
 

对于反序列化：

步骤如下：

在src-中创建DeserializeMain.java>org.arpit.javapostsforlearning
3.DeserializeMain.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
包 组织.Arpit.爪哇postsforlearning;
进口 爪哇.io.IOException;
进口 爪哇.io.ObjectInputStream;
 
上市 类 DeserializeMain {
/ **
  * @作者Arpit Mandliya
  */
上市 静态的 虚空 主要(串[] args) {
 
  雇员 emp = 空值;
       尝试
       {
          FileInputStream fileIn =新 FileInputStream(“ employee.ser”);
          ObjectInputStream 在 = 新 ObjectInputStream(fileIn);
          emp = (雇员) 在 .readObject();
          在 .关();
          fileIn.关();
       }抓住(IOException i)
       {
          i.printStackTrace();
          返回;
       }抓住(ClassNotFoundException c)
       {
          系统.出.打印(“未找到员工类别”);
          c.printStackTrace();
          返回;
       }
       系统.出.打印(“反序列化的员工...”);
       系统.出.打印(“ Emp ID：” + emp.getEmployeeId());
       系统.出.打印(“名称： ” + emp.getEmployeeName());
       系统.出.打印(“部门： ” + emp.getDepartment());
}
}
 

4，运行它

首先运行SerializeMain.java，然后运行DeserializeMain.java，您将获得以下输出：
1
2
3
4
5
6
 
反序列化 雇员...
Emp ID: 101
名称: Arpit
部门: CS
 

因此，我们已经序列化了一个雇员对象，然后反序列化了它。看起来很简单，但是当引用对象，继承进入图片时，它可能会非常复杂。因此，我们将一一看到不同的情况，以及如何在不同的情况下应用序列化。

情况1-如果一个对象引用了其他对象怎么办

我们已经看到了一个非常简单的序列化情况，现在，如果它也引用了其他对象该怎么办。

那么它将如何序列化？引用对象也会被序列化吗？

是的，你不’不必显式序列化引用对象。当您序列化任何对象并且如果它包含任何其他对象引用时，Java序列化就会将该对象序列化’的整个对象图。

例如，假设Employee现在引用了地址对象，而Address可以引用了其他某个对象（例如Home），那么当您序列化Employee对象时，所有其他引用对象（例如address和home）将被自动序列化。让’■创建Address类，并添加Address对象作为对上述员工类的引用。

雇员.java：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
包 组织.Arpit.爪哇postsforlearning;
进口 爪哇.io.可序列化;
 
上市 类 雇员 实施 可序列化{ 
 
私人的 静态的 最后 长 serialVersionUID = 1L;
 整型 员工ID;
串 员工姓名;
串 部门;
地址 地址;
 
上市 整型 getEmployeeId() {
  返回 员工ID;
}
上市 虚空 setEmployeeId(整型 员工ID) {
  这个.员工ID = 员工ID;
}
上市 串 getEmployeeName() {
  返回 员工姓名;
}
上市 虚空 setEmployeeName(串 员工姓名) {
  这个.员工姓名 = 员工姓名;
}
上市 串 getDepartment() {
  返回 部门;
}
上市 虚空 setDepartment(串 部门) {
  这个.部门 = 部门;
}
上市 地址 getAddress() {
  返回 地址;
}
上市 虚空 setAddress(地址 地址) {
  这个.地址 = 地址;
}
}
 

在org.arpit.javapostsforlearning中创建Address.java
地址.java：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
包 组织.Arpit.爪哇postsforlearning;
上市 类 地址 {
 
整型 没有;
串 街;
串 市;
 上市 地址(整型 没有, 串 街, 串 市) {
  超();
  这个.没有 = 没有;
  这个.街 = 街;
  这个.市 = 市;
}
 上市 整型 getHomeNo() {
  返回 没有;
}
上市 虚空 setHomeNo(整型 没有) {
  这个.没有 = 没有;
}
上市 串 getStreet() {
  返回 街;
}
上市 虚空 setStreet(串 街) {
  这个.街 = 街;
}
上市 串 getCity() {
  返回 市;
}
上市 虚空 setCity(串 市) {
  这个.市 = 市;
}
}
 

在org.arpit.javapostsforlearning中创建SerializeDeserializeMain.java
SerializeDeserializeMain.java：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
包 组织.Arpit.爪哇postsforlearning;
进口 爪哇.io.FileInputStream;
进口 爪哇.io.FileOutputStream;
进口 爪哇.io.IOException;
进口 爪哇.io.ObjectInputStream;
进口 爪哇.io.ObjectOutputStream;
 
上市 类 SerializeDeserializeMain {
/ **
  * @作者Arpit Mandliya
  */
上市 静态的 虚空 主要(串[] args) {
 
  雇员 emp = 新 雇员();
  emp.setEmployeeId(101);
  emp.setEmployeeName(“阿尔伯特”);
  emp.setDepartment(“ CS”);
  地址 地址=新 地址(88,MG路,“浦那”);
  emp.setAddress(地址);
  //连载
  尝试
  {
   FileOutputStream fileOut = 新 FileOutputStream(“ employee.ser”);
   ObjectOutputStream 外流 = 新 ObjectOutputStream(fileOut);
   外流.writeObject(emp);
   外流.关();
   fileOut.关();
  }抓住(IOException i)
  {
   i.printStackTrace();
  }
 
  //反序列化
  emp = 空值;
  尝试
  {
   FileInputStream fileIn =新 FileInputStream(“ employee.ser”);
   ObjectInputStream 在 = 新 ObjectInputStream(fileIn);
   emp = (雇员) 在 .readObject();
   在 .关();
   fileIn.关();
  }抓住(IOException i)
  {
   i.printStackTrace();
   返回;
  }抓住(ClassNotFoundException c)
  {
   系统.出.打印(“未找到员工类别”);
   c.printStackTrace();
   返回;
  }
  系统.出.打印(“反序列化的员工...”);
  系统.出.打印(“ Emp ID：” + emp.getEmployeeId());
  系统.出.打印(“名称： ” + emp.getEmployeeName());
  系统.出.打印(“部门： ” + emp.getDepartment());
  地址=emp.getAddress();
  系统.出.打印(“城市：”+地址.getCity());
}
}
 

运行 ：
当您运行SerializeDeserializeMain.java时，您将获得以下输出
1
2
3
4
5
6
7
8
9
 
爪哇.io.NotSerializableException: 组织.Arpit.爪哇postsforlearning.地址
  在 爪哇.io.ObjectOutputStream.writeObject0(未知 资源)
  在 爪哇.io.ObjectOutputStream.defaultWriteFields(未知 资源)
  在 爪哇.io.ObjectOutputStream.writeSerialData(未知 资源)
  在 爪哇.io.ObjectOutputStream.writeOrdinaryObject(未知 资源)
  在 爪哇.io.ObjectOutputStream.writeObject0(未知 资源)
  在 爪哇.io.ObjectOutputStream.writeObject(未知 资源)
 

我们错了，出了什么问题。我忘了提，Address类也必须可序列化。因此，您必须通过实现serialzable接口使Address序列化。
地址.java：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
进口 爪哇.io.可序列化;
 
上市 类 地址 实施 可序列化{
 
私人的 静态的 最后 长 serialVersionUID = 1L;
整型 没有;
串 街;
串 市;
上市 地址(整型 没有, 串 街, 串 市) {
  超();
  这个.没有 = 没有;
  这个.街 = 街;
  这个.市 = 市;
}
 上市 整型 getHomeNo() {
  返回 没有;
}
上市 虚空 setHomeNo(整型 没有) {
  这个.没有 = 没有;
}
上市 串 getStreet() {
  返回 街;
}
上市 虚空 setStreet(串 街) {
  这个.街 = 街;
}
上市 串 getCity() {
  返回 市;
}
上市 虚空 setCity(串 市) {
  这个.市 = 市;
}
}
 

再次运行：
当您再次运行SerializeDeserializeMain.java时，将得到以下输出
1
2
3
4
5
6
7
 
反序列化 雇员...
Emp ID: 101
名称: Arpit
部门: CS
市 :浦那
 
案例2：如果您不这样做’无法访问参考对象’的源代码（例如，您不 ’无法访问上述地址类）
如果你不这样做’没有访问地址类的权限，那么您将如何在地址类中实现可序列化的接口呢？是的，您可以创建另一个扩展地址并使其可序列化的类，但是在许多情况下它可能会失败：

  • 如果将类声明为final怎么办
  • 如果类引用了其他不可序列化的对象，该怎么办？

那么您将如何序列化Employee对象呢？所以解决方案是您可以使其瞬变。’想要序列化任何字段然后使其变为瞬态。

1
2
3
 
短暂的 地址 地址
 

因此，在运行程序时在Employee类中使地址瞬态之后，您将获得nullPointerException，因为在反序列化期间地址引用将为null

情况3：如果您仍要保存引用对象的状态（例如，地址对象上方），该怎么办：

如果使地址瞬态，则在反序列化期间它将返回null。但是如果您仍然希望拥有与序列化地址对象时相同的状态该怎么办。Java序列化提供了一种机制，使得如果您拥有带有特定签名的私有方法，那么它们将在序列化和反序列化期间被调用，因此如果我们提供writeObject和员工类的readObject方法，将在Employee对象的序列化和反序列化期间调用它们。

雇员.java：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
包 组织.Arpit.爪哇postsforlearning;
进口 爪哇.io.IOException;
进口 爪哇.io.ObjectInputStream;
进口 爪哇.io.ObjectOutputStream;
进口 爪哇.io.可序列化;
 
上市 类 雇员 实施 可序列化{ 
 私人的 静态的 最后 长 serialVersionUID = 1L;
 
整型 员工ID;
串 员工姓名;
串 部门;
短暂的 地址 地址;
 
上市 整型 getEmployeeId() {
  返回 员工ID;
}
上市 虚空 setEmployeeId(整型 员工ID) {
  这个.员工ID = 员工ID;
}
上市 串 getEmployeeName() {
  返回 员工姓名;
}
上市 虚空 setEmployeeName(串 员工姓名) {
  这个.员工姓名 = 员工姓名;
}
上市 串 getDepartment() {
  返回 部门;
}
上市 虚空 setDepartment(串 部门) {
  这个.部门 = 部门;
}
上市 地址 getAddress() {
  返回 地址;
}
上市 虚空 setAddress(地址 地址) {
  这个.地址 = 地址;
}
 
私人的 虚空 writeObject(ObjectOutputStream 操作系统) 抛出 IOException, ClassNotFoundException
{
  尝试 {
   操作系统.defaultWriteObject();
   操作系统.writeInt(地址.getHomeNo());
   操作系统.writeObject(地址.getStreet());
   操作系统.writeObject(地址.getCity());
  }
  抓住 (例外 e)
  { e.printStackTrace(); }
}
 
私人的 虚空 readObject(ObjectInputStream 是) 抛出 IOException, ClassNotFoundException
{
  尝试 {
   是.defaultReadObject();
   整型 没有=是.readInt();
   串 街=(串) 是.readObject();
   串 市=(串) 是.readObject();
   地址=新 地址(没有,街,市);
 
  } 抓住 (例外 e) { e.printStackTrace(); }
}
}
 

应该记住的一点是，ObjectInputStream应该以我们将数据写入ObjectOutputStream的相同顺序读取数据。
在org.arpit.javapostsforlearning中创建Address.java
地址.java：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
包 组织.Arpit.爪哇postsforlearning;
进口 爪哇.io.可序列化;
 
上市 类 地址 {
 
整型 没有;
串 街;
串 市;
 
上市 地址(整型 没有, 串 街, 串 市) {
  超();
  这个.没有 = 没有;
  这个.街 = 街;
  这个.市 = 市;
}
上市 整型 getHomeNo() {
  返回 没有;
}
上市 虚空 setHomeNo(整型 没有) {
  这个.没有 = 没有;
}
上市 串 getStreet() {
  返回 街;
}
上市 虚空 setStreet(串 街) {
  这个.街 = 街;
}
上市 串 getCity() {
  返回 市;
}
上市 虚空 setCity(串 市) {
  这个.市 = 市;
}
}
 

在org.arpit.javapostsforlearning中创建SerializeDeserializeMain.java
SerializeDeserializeMain.java：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
包 组织.Arpit.爪哇postsforlearning;
进口 爪哇.io.FileInputStream;
进口 爪哇.io.FileOutputStream;
进口 爪哇.io.IOException;
进口 爪哇.io.ObjectInputStream;
进口 爪哇.io.ObjectOutputStream;
 
上市 类 SerializeDeserializeMain {
/ **
  * @作者Arpit Mandliya
  */
上市 静态的 虚空 主要(串[] args) {
 
  雇员 emp = 新 雇员();
  emp.setEmployeeId(101);
  emp.setEmployeeName(“阿尔伯特”);
  emp.setDepartment(“ CS”);
  地址 地址=新 地址(88,MG路,“浦那”);
  emp.setAddress(地址);
  //连载
  尝试
  {
   FileOutputStream fileOut = 新 FileOutputStream(“ employee.ser”);
   ObjectOutputStream 外流 = 新 ObjectOutputStream(fileOut);
   外流.writeObject(emp);
   外流.关();
   fileOut.关();
  }抓住(IOException i)
  {
   i.printStackTrace();
  }
 
  //反序列化
  emp = 空值;
  尝试
  {
   FileInputStream fileIn =新 FileInputStream(“ employee.ser”);
   ObjectInputStream 在 = 新 ObjectInputStream(fileIn);
   emp = (雇员) 在 .readObject();
   在 .关();
   fileIn.关();
  }抓住(IOException i)
  {
   i.printStackTrace();
   返回;
  }抓住(ClassNotFoundException c)
  {
   系统.出.打印(“未找到员工类别”);
   c.printStackTrace();
   返回;
  }
  系统.出.打印(“反序列化的员工...”);
  系统.出.打印(“ Emp ID：” + emp.getEmployeeId());
  系统.出.打印(“名称： ” + emp.getEmployeeName());
  系统.出.打印(“部门： ” + emp.getDepartment());
  地址=emp.getAddress();
  系统.出.打印(“城市：”+地址.getCity());
}
}
 

运行 ：

当您运行SerializeDeserializeMain.java时，您将获得以下输出

1
2
3
4
5
6
7
 
反序列化 雇员...
Emp ID: 101
名称: Arpit
部门: CS
市 :浦那
 

所以现在我们得到的地址对象的状态与序列化之前的状态相同。

爪哇中的序列化继承：

现在我们将看到 遗产 影响序列化，所以在某些情况下，超类是否可以序列化，如果不是，那么您将如何处理它以及它是如何工作的。

让’s see by example.
我们将创建Person.java，它将是Employee的超类。

情况4： 如果超类是可序列化的怎么办？
如果超类是可序列化的，则其所有子类都可以自动序列化。

情况5：如果超类不可序列化怎么办？
如果超类不能序列化，那么我们必须以完全不同的方式处理它。

  • 如果超类不可序列化，则它必须没有参数构造函数。

人.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
包 组织.Arpit.爪哇postsforlearning;
上市 类 人 {
 
串 名称=“默认”;
串 国籍;
 
上市 人()
{
  系统.出.打印(“人：构造函数”);
}
 
上市 人(串 名称, 串 国籍) {
  超();
  这个.名称 = 名称;
  这个.国籍 = 国籍;
}
 
上市 串 getName() {
  返回 名称;
}
 
上市 虚空 setName(串 名称) {
  这个.名称 = 名称;
}
 
上市 串 getNationality () {
  返回 国籍;
}
 
上市 虚空 国籍(串 国籍) {
  这个.国籍 = 国籍;
}
 
}
 

在org.arpit.javapostsforlearning中创建Employee.java
雇员.java：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
包 组织.Arpit.爪哇postsforlearning;
进口 爪哇.io.可序列化;
 
上市 类 雇员 延伸 人 实施 可序列化{ 
 私人的 静态的 最后 长 serialVersionUID = 1L;
整型 员工ID;
串 部门;
 
上市 雇员(整型 员工ID,串 名称,串 部门,串 国籍)
{
  超(名称,国籍);
  这个.员工ID=员工ID;
  这个.部门=部门;
  系统.出.打印(“员工：构造函数”);
}
 
上市 整型 getEmployeeId() {
  返回 员工ID;
}
上市 虚空 setEmployeeId(整型 员工ID) {
  这个.员工ID = 员工ID;
}
 
上市 串 getDepartment() {
  返回 部门;
}
上市 虚空 setDepartment(串 部门) {
  这个.部门 = 部门;
}
}
 

在org.arpit.javapostsforlearning中创建SerializeDeserializeMain.java
SerializeDeserializeMain.java：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
包 组织.Arpit.爪哇postsforlearning;
进口 爪哇.io.FileInputStream;
进口 爪哇.io.FileOutputStream;
进口 爪哇.io.IOException;
进口 爪哇.io.ObjectInputStream;
进口 爪哇.io.ObjectOutputStream;
 
上市 类 SerializeDeserializeMain {
 
/ **
  * @作者Arpit Mandliya
  */
上市 静态的 虚空 主要(串[] args) {
 
  //连载
  雇员 emp = 新 雇员(101,“阿尔伯特”,“ CS”,“印度人”);
  系统.出.打印(“序列化之前”);
  系统.出.打印(“ Emp ID：” + emp.getEmployeeId());
  系统.出.打印(“名称： ” + emp.getName());
  系统.出.打印(“部门： ” + emp.getDepartment());
  系统.出.打印(“国籍：” + emp.getNationality ());
  系统.出.打印(“ ************”);
  系统.出.打印(“序列化”);
  尝试
  {
   FileOutputStream fileOut = 新 FileOutputStream(“ employee.ser”);
   ObjectOutputStream 外流 = 新 ObjectOutputStream(fileOut);
   外流.writeObject(emp);
   外流.关();
   fileOut.关();
  }抓住(IOException i)
  {
   i.printStackTrace();
  }
 
  //反序列化
  系统.出.打印(“ ************”);
  系统.出.打印(“反序列化”);
  emp = 空值;
  尝试
  {
   FileInputStream fileIn =新 FileInputStream(“ employee.ser”);
   ObjectInputStream 在 = 新 ObjectInputStream(fileIn);
   emp = (雇员) 在 .readObject();
   在 .关();
   fileIn.关();
  }抓住(IOException i)
  {
   i.printStackTrace();
   返回;
  }抓住(ClassNotFoundException c)
  {
   系统.出.打印(“未找到员工类别”);
   c.printStackTrace();
   返回;
  }
  系统.出.打印(“序列化之后”);
  系统.出.打印(“ Emp ID：” + emp.getEmployeeId());
  系统.出.打印(“名称： ” + emp.getName());
  系统.出.打印(“部门： ” + emp.getDepartment());
  系统.出.打印(“国籍：” + emp.getNationality ());
}
}
 

运行 ：

当您运行SerializeDeserializeMain.java时，您将获得以下输出

如果超类不可序列化，则实例的所有值 变数 在反序列化过程中，将通过调用Non-Serializable Super类的构造函数来初始化从super类继承的继承。 所以这里name是从person继承的，因此在反序列化期间，name被初始化为默认值。

情况6-如果超类是可序列化的，但您却不知道该怎么办’希望子类可序列化
如果你不这样做’想要子类可序列化，则需要实现writeObject（）和readObject（）方法，并需要从这些方法中抛出NotSerializableException。

 情况7-您可以序列化静态变量吗？
不可以’t。如您所知，静态变量是在类级别而不是在对象级别，并且您序列化了一个对象，因此您可以’t序列化静态变量。

如果您想更好地控制序列化，可以使用外部化接口代替序列化。有关更多信息，请访问： 可外部化 在 爪哇

概要：

  • 爪哇的序列化是Java对象的翻译’s的值/状态转换为字节以通过网络发送或保存。反序列化是将字节码转换为相应的java对象。
  • 关于序列化的好处是整个过程是 虚拟机 独立的，这意味着对象可以在一个平台上序列化，并可以在完全不同的平台上反序列化。
  • 如果要序列化任何类，则它必须实现Serializable接口（即标记接口）。
  • 爪哇中的标记接口是没有字段或方法的接口，或者简单的单词空接口在Java中称为标记接口
  • serialVersionUID 用于确保在反序列化期间加载相同的对象（在序列化过程中使用的对象）。serialVersionUID用于对象的版本控制。
  • 当序列化任何对象并且如果它包含任何其他对象引用时，则Java序列化将序列化该对象’的整个对象图。
  • 如果你不这样做’不想序列化任何字段，然后创建它 短暂的.
  • 如果超类是可序列化的，则其子类将自动可序列化。
  • 如果超类不可序列化，则将从超类继承的实例变量的所有值将通过调用进行初始化 建设者 反序列化过程中不可序列化的Super类的标识。
  • 如果你不这样做’想要子类可序列化，则需要实现writeObject（）和readObject（）方法，并需要从这些方法中抛出NotSerializableException。
  • 您可以’t序列化静态变量。

那’关于Java中的序列化的全部内容。

分享这个

作者

关注作者

相关文章

  • 序列化面试问题
    2月14日

    爪哇序列化面试问答

    序列化是Java中最重要的概念之一。如果您要面对核心Java面试，那么可能会从序列化中询问您一些问题。 爪哇序列化教程：java中的序列化Java序列化访谈问题和答案Java序列化中的serialversionuid在Java中可外部化Java中的Transient关键字Serializable和Externalizable […]

  • 2月14日

    Difference between 可序列化 and 可外部化 在 爪哇

    在本教程中，我们将看到Java中可序列化和可外部化接口之间的差异。 爪哇序列化教程：Java的序列化Java序列化访谈问答Java的序列化Java的序列化Java的可外部化Java的Transient关键字Java的可序列化和可外部化之间的区别在理解差异之前，让我简要介绍一下Serializable […]

  • 19 May

    爪哇瞬时关键字与示例

    瞬态变量是其值在序列化过程中未序列化的变量。反序列化时，将获得这些变量的默认值。假设您有乡村课程而您没有’不想序列化总体属性，因为它会随着时间而变化，因此您可以将总体属性声明为瞬态，它会’t […]

  • 2月26日

    可外部化 在 爪哇

    这是Java序列化教程的第3部分Java序列化教程：Java中的序列化Java序列化访谈问答Java中的serialversionuid序列化java的externalizable 爪哇中的Transient关键字Java中的Serializable和Externalizable之间的区别在理解Externalizable接口之前，您需要对序列化有所了解您可以在序列化[…]

  • 3月11日

    爪哇序列化中的serialVersionUID

    这是Java序列化教程的第二部分Java序列化教程：Java序列化Java序列化访谈问答Java序列化中的serialversionuid在Java中可外部化Java中的Transient关键字Java中Serializable和Externalizable之间的区别serialVersionUID用于确保相同的类（在反序列化过程中加载序列化期间使用的序列。serialVersionUID为[…]

Comments

  9. 我们如何序列化具有非序列化属性的对象，该属性是我们无法访问的，因为该属性来自service。即服务使用了一些枚举，尽管我的对象实现了可序列化的接口，但我们无法对其进行序列化。

    请提出建议。

  12. 嗨，JAVA World的新手，我已经阅读了很多有关Java序列化的文章和文章，但是阅读这篇文章后就了解了。您能否发表更多与CORE JAVA相关的主题（即OOPS概念，多线程，同步）…

    如果是这样，那对我和其他人都将非常有帮助…

    谢谢…

发表评论

您的电子邮件地址不会被公开。 必需的地方已做标记 *

订阅我们的新闻

获取质量教程到您的收件箱。现在订阅。


让’s be Friends

©2020 爪哇2博客