Java 核心技术之序列化 Serializable

最新推荐文章于 2023-02-27 13:09:49 发布
最新推荐文章于 2023-02-27 13:09:49 发布
阅读量605 收藏 3
点赞数 3
分类专栏： Java 核心技术 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzuhkp/article/details/106440635
版权

一、序列化概念

将对象在内存中的状态保存下来，在需要的时候获取。

  • 序列化：将对象转换为字节序列，以便在网络传输或存储。
  • 反序列化：将字节序列转换为对象。

二、序列化特点

  • 类必须实现Serializable接口，父类未实现Serializable接口则父类不参与序列化，父类实现Serializable接口后子类不需要显式实现Serializable接口；
  • 类的静态变量不参与序列化；
  • transient关键字修饰的变量不参与序列化；
  • 序列化对象的成员变量serialVersionUID和反序列化的对象的成员变量serialVersionUID值必须一致；
  • 对象的实例变量引用其他对象，引用的对象也将参与序列化

三、序列化步骤

  1. 创建OutputStream；
    OutputStream outputStream = new FileOutputStream("object.txt");
  2. 创建ObjectOutputStream；
    ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
  3. 调用ObjectOutputStream的writeObject方法进行序列化；
    objectOutputStream.writeObject(obj);
  4. 关闭输出流；
    objectOutputStream.close();

四、反序列化步骤

  1. 创建InputStream；
    InputStream inputStream = new FileInputStream("object.txt");
  2. 创建ObjectInputStream；
    ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
  3. 调用ObjectInputStream的readObject方法进行反序列化；
    Object obj = objectInputStream.readObject();
  4. 关闭输出流；
    objectInputStream.close();

五、序列化实例

5.1 实例一:类必须实现Serializable接口

  • Serializable接口是一个标记接口，本身并没有定义方法，但是类必须实现Serializable接口才能进行序列化，否则进行序列化时将抛出NotSerializableException异常。
public interface Serializable {
}
  • 类User包含username和password两个成员变量，并未实现Serializable接口。
package com.zzuhkp.javanote.serializable;

public class User{
    private String username;
    private String password;

    public User() {
        System.out.println("User no arg constructor");
    }

    public User(String username, String password) {
        System.out.println("User with arg constructor");
        this.username = username;
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}
  • 测试类Main对User类中的成员变量赋值，进行序列化后然后反序列化打印User信息；
package com.zzuhkp.javanote.serializable;

import java.io.*;

public class Main {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        User user = new User("zzuhkp", "123456");
        writeObj(user);
        System.out.println(readObj());
    }

    public static void writeObj(Object obj) throws IOException {
        OutputStream outputStream = new FileOutputStream("object.txt");
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
        objectOutputStream.writeObject(obj);
        objectOutputStream.close();
    }

    public static Object readObj() throws IOException, ClassNotFoundException {
        InputStream inputStream = new FileInputStream("object.txt");
        ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
        Object obj = objectInputStream.readObject();
        objectInputStream.close();
        return obj;
    }

}
  • 程序运行后抛出java.io.NotSerializableException异常，如下所示；
User with arg constructor
Exception in thread "main" java.io.NotSerializableException: com.zzuhkp.javanote.serializable.User
	at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
	at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)
	at com.zzuhkp.javanote.serializable.Main.writeObj(Main.java:16)
	at com.zzuhkp.javanote.serializable.Main.main(Main.java:9)

5.2 实例二 未实现Serializable的父类不参与序列化

  • 创建类CommonVO,其只有一个成员变量id，该类未实现Serializable接口；
package com.zzuhkp.javanote.serializable;

public class CommonVO {
    private String id;

    public CommonVO(){
        System.out.println("CommonVO no arg constructor");
    }

    public CommonVO(String id) {
        System.out.println("CommonVO with arg constructor");
        this.id = id;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "CommonVO{" +
                "id='" + id + '\'' +
                '}';
    }
}
  • 使User类继承CommonVO类；
package com.zzuhkp.javanote.serializable;

public class User extends CommonVO implements Serializable {
    //省略代码和实例一相同，未做改变
}
  • 修改测试类如下所示：
package com.zzuhkp.javanote.serializable;

import java.io.*;

public class Main {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        User user = new User("zzuhkp", "123456");
        user.setId("123");
        writeObj(user);
        User user1= (User) readObj();
        System.out.println(user1.toString());
        System.out.println("id:"+user1.getId());
    }

    //省略代码和实例一相同，未做改变

}
  • 程序运行结果如下所示，可以看到反序列化并没有把前面设置的父类成员变量id的值打印出来，并且可以看到反序列化时程序调用了User的无参构造方法创建了User的实例；
CommonVO no arg constructor
User with arg constructor
CommonVO no arg constructor
User{username='zzuhkp', password='123456'}
id:null

5.3 实例三 类的静态变量和transient修饰的变量不参与序列化；

  • 修改实例一中的User如下所示；
package com.zzuhkp.javanote.serializable;

import java.io.Serializable;

public class User  implements Serializable {
    public static String USER_TYPE="1";
    private transient String password;
    
    //省略代码和实例一中的User一致
}
  • 修改测试类如下所示；
package com.zzuhkp.javanote.serializable;

import java.io.*;

public class Main {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        User user = new User("zzuhkp", "123456");
        writeObj(user);
        User.USER_TYPE="2";
        User user1= (User) readObj();
        System.out.println(user1.toString());
        System.out.println(User.USER_TYPE);
    }

    //省略代码和实例一中的Main类保持一致

}
  • 序列化后修改User类的静态变量USER_TYPE，程序运行，打印结果如下。反序列化后获取的静态变量的值和序列化之前并不保持一致，说明类的静态变量不参数序列化；transient修饰的password变量在反序列化后并未打印出序列化之前设置的值，说明transient修饰的成员变量也不参与序列化。
User with arg constructor
User{username='zzuhkp', password='null'}
2

5.4 实例四 序列化ID serialVersionUID必须一致

  • 修改User类如下所示，注意serialVersionUID的值为1L。
package com.zzuhkp.javanote.serializable;

import java.io.Serializable;

public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String username;
    private String password;

    public User() {
        System.out.println("User no arg constructor");
    }

    public User(String username, String password) {
        System.out.println("User with arg constructor");
        this.username = username;
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}
  • 新建SocketClient类作为Socket连接的客户端，代码如下：
package com.zzuhkp.javanote.serializable;

import java.io.*;
import java.net.Socket;

public class SocketClient {

    public static void main(String[] args) throws IOException {
        Socket socket=new Socket("127.0.0.1",8080);
        User user = new User("zzuhkp", "123456");
        OutputStream outputStream = socket.getOutputStream();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
        objectOutputStream.writeObject(user);
        objectOutputStream.close();
    }
}
  • 新建项目，并在新项目中新建User类,User类的serialVersionUID为2L，其他内容和原项目User保值一致，代码如下；
package com.zzuhkp.javanote.serializable;

import java.io.Serializable;

public class User  implements Serializable {
    private static final long serialVersionUID = 2L;
    
    //省略代码和实例四上面User内容一致
}
  • 在新项目中新建SocketServer类作为Socket的服务端，代码如下：
package com.zzuhkp.javanote.serializable;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class SocketServer {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ServerSocket serverSocket=new ServerSocket(8080);
        Socket socket=serverSocket.accept();

        InputStream inputStream = socket.getInputStream();
        ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
        Object obj = objectInputStream.readObject();
        objectInputStream.close();
        System.out.println(obj.toString());
    }
}
  • 分别运行SocketServer和SocketClient，SocketServer程序运行报InvalidClassException异常，并提示 stream classdesc serialVersionUID = 1, local class serialVersionUID = 2，说明serialVersionUID必须保持一致才能序列化成功。
Exception in thread "main" java.io.InvalidClassException: com.zzuhkp.javanote.serializable.User; local class incompatible: stream classdesc serialVersionUID = 1, local class serialVersionUID = 2
	at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:687)
	at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1883)
	at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1749)
	at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2040)
	at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1571)
	at java.io.ObjectInputStream.readObject(ObjectInputStream.java:431)
	at com.zzuhkp.javanote.serializable.SocketServer.main(SocketServer.java:15)

六、序列化对象的writeObject方法和readObject方法

  • 序列化时ObjectOutputStream将通过反射获取并尝试调用序列化对象的private void writeObject(ObjectOutputStream objectOutputStream)方法进行序列化，如果不存在该方法则ObjectOutputStream使用默认的序列化方式进行序列化。在writeObject方法中可以先调用objectOutputStream.defaultWriteObject()方法进行默认的序列化，然后调用ObjectOutputStream类的其他方法序列化；
  • 反序列化时ObjectInputStream将通过反射获取并尝试调用序列化对象的private void readObject(ObjectInputStream objectInputStream)方法进行反序列化，如果不存在该方法则ObjectInputStream使用默认的反序列化方式进行反序列化。在readObject中可以先调用objectInputStream.defaultReadObject()方法进行默认的反序列化，然后调用ObjectInputStream类的其他方法反序列化；
  • 修改User类如下所示：
package com.zzuhkp.javanote.serializable;

import java.io.*;

public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String username;
    private transient String password;

    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException, ClassNotFoundException {
        objectOutputStream.defaultWriteObject();
        objectOutputStream.writeObject(this.password);
    }

    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
        objectInputStream.defaultReadObject();
        this.password = (String) objectInputStream.readObject();
    }
    
    //省略代码和实例一中的User类代码相同
}
  • 修改实例一中的Main类如下所示：
package com.zzuhkp.javanote.serializable;

import java.io.*;

public class Main {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        User user = new User("zzuhkp", "123456");
        writeObj(user);
        User user1= (User) readObj();
        System.out.println(user1.toString());
    }

    //省略代码和实例一中的Main类代码一致
}
  • 运行结果如下，说明使用自定义的序列化方式对transient修饰的成员变量序列化已经生效。
User with arg constructor
User{username='zzuhkp', password='123456'}

七、序列化接口Externalizable

Externalizable接口继承Serializable接口，并声明了两个方法用于分别对对象进行序列化和反序列化，查看Externalizable的主要源码如下：

package java.io;

import java.io.ObjectOutput;
import java.io.ObjectInput;

public interface Externalizable extends java.io.Serializable {
    
    void writeExternal(ObjectOutput out) throws IOException;
    
    void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}

一个类实现Externalizable接口，该类即可参与序列化，此时需要我们自己调用writeExternal方法进行序列化，调用readExternal方法进行反序列化，并且实现Serializable接口进行的默认序列化方式不会生效。

修改实例一中的User类如下：

package com.zzuhkp.javanote.serializable;

import java.io.*;

public class User implements Externalizable {
    private static final long serialVersionUID = 1L;
    private String username;
    private String password;

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(this.username);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        this.username = (String) in.readObject();
    }

    //省略代码和实例一中User的代码一致

}

修改Main类的代码如下：

package com.zzuhkp.javanote.serializable;

import java.io.*;

public class Main {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        User user = new User("zzuhkp", "123456");
        writeObj(user);
        User user1= (User) readObj();
        System.out.println(user1.toString());
    }

    //省略代码和实例一中Main方法的代码一致

}

在User类中只对成员变量username进行序列化和反序列化，运行结果如下所示,说明我们自定义的序列化和反序列化已经生效：

User with arg constructor
User no arg constructor
User{username='zzuhkp', password='null'}

八、序列化对象的writeReplace和readResolve方法

  • 如果序列化对象包含Object writeReplace() throws ObjectStreamException方法，在序列化时将使用writeReplace方法的返回值作为序列化的对象替代原序列化对象；
  • 如果序列化对象包含Object readResolve() throws ObjectStreamException方法，在反序列化时将使用readResolve方法的返回值作为反序列化的对象替代原反序列化对象。

修改实例一中的User类如下所示，注意添加了writeReplace()和 readResolve()方法。

package com.zzuhkp.javanote.serializable;

import java.io.*;

public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String username;
    private String password;

    private Object writeReplace() throws ObjectStreamException{
        System.out.println("writeReplace() is called");
        User user=new User("writeReplace Name","123");
        return user;
    }

    private Object readResolve() throws ObjectStreamException{
        System.out.println("readResolve() is called");
        User user=new User("readResolve Name","456");
        return user;
    }

    public User() {
        System.out.println("User no arg constructor");
    }

    public User(String username, String password) {
        System.out.println("User with arg constructor");
        this.username = username;
        this.password = password;
    }


    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

}

测试类Main类代码如下:

package com.zzuhkp.javanote.serializable;

import java.io.*;

public class Main {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        User user = new User("zzuhkp", "123456");
        writeObj(user);
        User user1= (User) readObj();
        System.out.println(user1.toString());
    }

    public static void writeObj(Object obj) throws IOException {
        OutputStream outputStream = new FileOutputStream("object.txt");
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
        objectOutputStream.writeObject(obj);
        objectOutputStream.close();
    }

    public static Object readObj() throws IOException, ClassNotFoundException {
        InputStream inputStream = new FileInputStream("object.txt");
        ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
        Object obj = objectInputStream.readObject();
        objectInputStream.close();
        return obj;
    }

}

运行结果如下，说明反序列化的对象已经被readResolve()方法的返回值替代。

User with arg constructor
writeReplace() is called
User with arg constructor
readResolve() is called
User with arg constructor
User{username='readResolve Name', password='456'}
大鹏cool
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
关于Java中Serializable的一些问题
viclee
05-15 1956
在面试中我常常会考察Serializable相关的问题，我认为这是一个很基础的知识点，是对候选人基础是否扎实的考察。但是结果有点出乎意料，候选人往往只是知道它和序列化有关，而对于其中的细节以及更深层次的原理都不是很清楚。因此，我决定整理一下Serializable相关的一些问题，希望能够对不了解的同学有所帮助。 一个类实现Serializable接口后可以被序列化。这...
JAVA序列化Serializable及Externalizable区别详解
08-18
主要介绍了JAVA序列化Serializable及Externalizable区别详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java serializable 序列化与反序列化
05-22
java 的序列化与反序列化举例测试
java 序列化对象 serializable 读写数据的实例
09-05
java 序列化对象 serializable 读写数据的实例，需要的朋友可以参考一下
java序列化和反序列化，面试必备
12-21
最近阅读Serializable接口和Externalizable接口的源码，并结合了一些资料，对面试过程中与序列化相关的内容做了一些总结。 一、序列化、反序列化、使用场景、意义。 序列化：将对象写入IO流中； 反序列化：从IO流中恢复对象； 意义：序列化机制允许将实现序列化的Java对象转换为字节序列，并将字节序列保存在磁盘中，或通过网络传输，以达到以后恢复成原来的对象。序列化机制使地对象可以脱离程序的运行而独立存在。 使用场景：所有在网络上传输的对象都必须是可序列化的。如：RMI (远程方法调用)，传入的参数或返回的对象都是可序列化的，否则会出错。所有必须保存到磁盘的java对象都必须是可
java serializable_Java 序列化 之 Serializable
weixin_33945512的博客
02-12 324
概念序列化：就是把对象转化成字节。反序列化：把字节数据转换成对象。对象序列化场景：1、对象网络传输例如：在微服务系统中或给第三方提供接口调用时，使用rpc进行调用，一般会把对象转化成字节序列，才能在网络上传输；接收方则需要把字节序列再转化为java对象。2、对象保存至文件中例如：hibernate中的二级缓存：把从数据库中查询出的对象，序列化转存到硬盘中，下次读取的时候，首先从内存中找是否有该对象...
一篇搞懂java序列化Serializable
ratel的博客
11-30 6385
序列化 (Serialization)将对象的状态信息转换为可以存储或传输的形式的过程。 一、序列化和反序列化的概念 把对象转换为字节序列的过程称为对象的序列化。 把字节序列恢复为对象的过程称为对象的反序列化。
Serializable序列化
nsnsttn的博客
06-24 4542
1、序列化是干啥用的？ 序列化的原本意图是希望对一个Java对象作一下“变换”，变成字节序列，这样一来方便持久化存储到磁盘，避免程序运行结束后对象就从内存里消失，另外变换成字节序列也更便于网络运输和传播，所以概念上很好理解： 序列化：把Java对象转换为字节序列。 反序列化：把字节序列恢复为原先的Java对象。而且序列化机制从某种意义上来说也弥补了平台化的一些差异，毕竟转换后的字节流可以在其他平台上进行反序列化来恢复对象。 2、对象序列化的方式？ 在Java中，如果一个对象要想实现序列化，必须要实现下面
java基础--19Java序列化（Serializable）
最后的武艺集大成者
11-05 1002
目录 1.何为序列化，为什么需要序列化 2.序列化的方式 3.自定义序列化 4.版本管理： 1.何为序列化，为什么需要序列化 如果我们将对象保存到磁盘或者进行网络传输，必须将这个对象进行序列化，即实现Serializable接口，如果不进行序列化，那么保存对象到磁盘的时候会报错，即磁盘IO操作对象的时候会报错： 说到底就是对象的格式不正确，必须通过序列化将...
JAVA基础 - Serializable的作用与用法
记录并分享
07-05 2355
Serializable是java.io包中定义的，用于将JAVA对象进行序列化和反序列化。序列化，将一个JAVA对象以二进制流的方式持久化到数据库、文件中，或者用于大对象暂存、网络传输、使用序列化实现深度克隆；反序列化，将之前持久化在数据库或文件中的二进制数据，以流的方式读取出来重新构造成一个和之前内容相同的JAVA对象。Serializable序列化接口没有任何方法或者字段，只是用于标识可序列化的语义。...
深入分析Java的序列化与反序列化
12-22
　为什么实现了java.io.Serializable接口才能被序列化 　transient的作用是什么 　怎么自定义序列化策略 　自定义的序列化策略是如何被调用的 　ArrayList对序列化的实现有什么好处 　Java对象的序列化 　...
java序列化
weixin_42383952的博客
08-09 116
可以看到编译器推荐两种方式，一种是生成默认的versionID，这个值为1L，还有一种方式是根据类名、接口名、成员方法及属性等来生成一个 64 位的哈希字段，只要类名、方法名、变量有修改或者有空格、注释、换行等操作，计算出来的哈希字段都会不同，当然这里需要注意，每次有以上的操作的时候尽量都要重新生成一次serialVerionUID，编译器并不会自动修改。当一个父类实现了序列化，那么子类会自动实现序列化，不需要显示实现序列化接口，反过来，子。如果序列化的属性是对象，对象必须也能序列化，否则会报错。...
Java之Serializable讲解
热门推荐
zhangsann_6的博客
07-29 1万+
在Java中操作数据库经常会遇到Serializable，那么它具体是什么呢？ 我们将从以下四个方面介绍： 1、什么是Serializable？ Serializable是Java提供的通用数据保存、读取和传输的接口， 其源码极为简洁，就是一个接口的声明。 2、Serializable作用 通过实现Serializable接口的类，该类所实例化的对象(实例变量)的状态信息在内存中可以持久化保存、传输，该过程称为序列化。 与之相反的是，将序列化的结果变成对象的过程称为反序列化。 3、Serializ
Java基础篇-Serializable序列化详解
qq_33351639的博客
02-27 2121
如果此时几个不同的服务之间要去共享同一个数据对象怎么办？ 这时就要用到序列化了。以Java语言为例，我们都知道Java属于一门对象编程语言,它是与人交互的语言。但是二进制这种010101的数字属于机器语言，是与CPU做交互的。那么我们的Java对象要想被机器所理解，使其变成“二进制流”，这个转换编码的过程就叫做“序列化”。将二进制流转为Java对象的解码过程被称为“反序列化”。
Java序列化Serializable
zjm807778317的博客
05-28 1124
在数据传输过程中，两者需要协商好相应的传输协议和文件格式，Java给我们提供了一种方案Serializable，这篇我们对Serializable的使用和原理进行简单解析。
java序列化和反序列化
v2ish1yan的博客
10-12 471
那么在对这个类的对象进行反序列化时，就不会执行原本的readObject()而是这个类中重写的readObject()，从而执行命令弹计算器。因为这个key是HashMap的键，所以我们可以找一个同样拥有hashCode()方法的类，来调用。2.在反序列化过程中，它的父类如果没有实现序列化接口，那么将需要提供无参构造函数来重新创建对象。3.入口类参数中包含可控类，该类又调用其他有危险方法的类，readObject时调用。就不会被序列化，从而在反序列化的时候就是用父类的无参构造函数来初始化父类的属性。
Java 序列化之Serializable完全解读
键盘上流淌的日子
06-11 8775
  Serializable 概念   Serializable是一个对象序列化接口，一个类实现了Serializable接口，表示它可以通过JDK本身进行序列化和反序列化操作。   Serializable工具类   Serializable依赖的是ObjectInputStream和ObjectOutputStream，使用ObjectOutputStream的writeObject方法将JavaBean的序列化内容写入输出流，使用ObjectInputStream的readObject将反序列化内容读
Java 序列化Serializable详解
Jeason的博客
12-12 777
转载 Java 序列化Serializable详解（附详细例子） 1、什么是序列化和反序列化 Serialization（序列化）是一种将对象以一连串的字节描述的过程；反序列化deserialization是一种将这些字节重建成一个对象的过程。2、什么情况下需要序列化 a）当你想把的内存中的对象保存到一个文件中或者数据库中时候； b）当你想用套接字在网络上传送对象的时候； c）当你想通
Serializable引起的崩溃NotSerializableException
Ung8023
12-28 319
此类中还调用了其他的类对象(也就是上文中的VipInfo)，调用的类对象必须一并实现Serializable。在Android中使用时，我将它作为一个参数，通过Bundle传递给Fragment，但是在序列化时报错了。
java -- 序列化(serializable)
最新发布
06-28
在Java中，只有实现了Serializable接口的对象才能被序列化，否则会抛出NotSerializableException异常。序列化可以通过ObjectOutputStream类来实现，反序列化可以通过ObjectInputStream类来实现。序列化在Java中广泛...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大鹏cool

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值