精华内容
下载资源
问答
  • 在serializable接口中定义了
    千次阅读
    2022-03-06 13:56:22

    在上周使用 Mybatis-Plus 做项目时无意发现,对于储存信息的实体类上面自动实现了 Serializable 接口,这不禁让我回忆到刚开始学 Java 时,对于 Serializable 接口的作用只停留在进行序列化的理解上,当初的理解认为对于序列化这个解释,就是把实体类信息进行封装存储到数据库中或者将实体类信息进行磁盘上的存储。但是疑问点来了,既然 Serializable 接口是为了将实体类信息进行存储,那为什么我们平时写的实体类在存储到数据库时没有实现接口却仍然可以进行数据的存储?

    虽然网上答案众多,但是让我能够真正明白的还是这篇文章:
    谈谈实现Serializable接口的作用和必要性

    序列化作用:

    • 提供一种简单又可扩展的对象保存恢复机制。
    • 对于远程调用,能方便对对象进行编码和解码,就像实现对象直接传输。
    • 可以将对象持久化到介质中,就像实现对象直接存储。
    • 允许对象自定义外部存储的格式。

    综合上面所述,序列化的作用是为了更好的保存和传输数据,也就是在进行数据的保存和传输时可以提供一个更佳可靠的方案来保证数据的安全性,虽然我们平时定义的实体类里面没有实现 Serializable 接口也并不影响我们进行数据信息的传输和保存。但是对于实现的实体类来说有了更加可靠的数据传输保护。那这具体是什么意思呢?
    对于基本类型,我们在使用数据库时,都有一个与之相对应的数据类型进行匹配如:

    Java             数据库
    int       ->     int
    String    ->     varchar
    Long      ->     bigint
    ....             ....
    
    

    所以在使用时一般不必注意实体类的序列化,但是当使用的是 NoSql 类型的数据库时,这种类型的数据库中根本没有与之相对应的数据结构来进行匹配,因此就需要使用序列化来进行数据的安全传输和存储。而对于更加复杂的操作中,如果不进行序列化的实现,往往是会出现一些错误的。

    Serializable类型的参数
    关于 Serializable 接口还要提到的一点是,有时候我们会看见在方法的参数里面接收着 Serializable 类型的参数,而Java 中的包装类几乎都实现了这个接口,因此方法里面可以传Integer、String、实现了Serializable接口的类等等,我觉有点类似于泛型的感觉了。

    如果文章对小伙伴有帮助,不妨点个攒👍,谢谢啦~⭐

    更多相关内容
  • java对象如何实现serializable接口

    千次阅读 2022-04-07 11:47:56
    还没有深入了解serializable接口之前,像很多程序员一样,以为一个对象实现serializable接口就被序列化了。 最近接触ehcache缓存的时候,将对象缓存起来,该对象需要先实现Serializable接口,然而,我们会发现...

    java对象实现Serializable接口
    在还没有深入了解serializable接口之前,像很多程序员一样,以为一个对象实现serializable接口就被序列化了。
    最近在接触ehcache缓存的时候,将对象缓存起来,该对象需要先实现Serializable接口,然而,我们会发现对象并没有真正的被序列化。
    下面让我们一起来总结一下Serializable接口的实现原理。
    当一个类实现了Seializable接口(该接口仅为标记接口,不包含任何方法定义),表示该类可以序列化,序列化的目的是将一个实现了Serializable接口的对象可以转换成一个字节序列,保存对象的状态。
    把该字节序列保存起来(例如:保存在一个文件里),以后可以随时将该字节序列恢复为原来的对象。甚至可以将该字节序列放到其他计算机上或者通过网络传输到其他计算机上恢复,只有该计算机平台存在相应的类就可以正常恢复为原来的对象。
    一个对象实现Serializable接口序列化,先要创建某些OutputStream对象,然后将其封装在一个ObjectOutputStream对象内,再调用writeObject()方法,即可序列化一个对象,反序列化,InputStream,再调用readObject()方法。(writeObject和readObject本身就是线程安全的,传输过程中是不允许被并发访问的,所以对象只能一个一个接连不断的传过来)。
    如果某个类能够被序列化,其子类也可以被序列化。声明为static和transient类型的成员数据不能被序列化。因为static代表类的状态,transient代表对象的临时数据, static对象变量在反序列化时取得的值为当前jvm中对应类中对应static变量的值,而transient(瞬态)关键字则一般用于标识那些在序列化时不需要传递的状态变量。
    Person类
    package org.test.domain;
     
    import java.io.Serializable;
     
    public class Person implements Serializable{
     
        /**
         * 
         */
        private static final long serialVersionUID = 1L;
        
        protected String name;
        protected transient int age;
        
        
        public Person(){}
        
        public Person(String name,int age){
            this.name = name;
            this.age = age;        
        }
        
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
     
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        
        public String toString()
        {
            return "this is person:"+"name:"+this.name+"——age:"+this.age;
        }
    }

    User类
    package org.test.domain;
     
    import java.io.Serializable;
     
    public class User extends Person{
     
        /**
         * 
         */
        private static final long serialVersionUID = 1L;
        
        private String name;
        private String password;
        
        public User() {
            
        }
     
        public User(String name,String password,int age)
        {
            this.name = name;
            this.password = password;
            this.age = age;
        }
        
        public String getName() {
            return name;
        }
     
        public void setName(String name) {
            this.name = name;
        }
     
        public String getPassword() {
            return password;
        }
     
        public void setPassword(String password) {
            this.password = password;
        }
     
        public String toString()
        {
            return "this is user:"+"name:"+this.name+"——password:"+this.password+"——age:"+this.age;
        }
        
    }

    SerializableTest类
    package org.test.main;
     
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
     
    import org.test.domain.Person;
    import org.test.domain.User;
     
    public class SerializableTest {
     
        public static void main(String[] args) {
            
            Person p1 = (Person)deSerialByte(serialByte(new User("user","1234",15)));
            
            //Person p2 = (Person)deSerialByte(serialByte(new Person("person",10)));
            
            System.out.println("p1:"+p1.toString());
            
            //System.out.println("p2:"+p2.toString());
        }
        
        //序列化一个对象(可以存储到一个文件也可以存储到字节数组)这里存储到自己数组
        public static byte[] serialByte(Object obj)
        {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos;
            try {
                oos = new ObjectOutputStream(baos);
                oos.writeObject(obj);
                oos.close();
                return baos.toByteArray();
            } catch (IOException e) {
                throw new RuntimeException(e.getMessage());
            }
        }
        
        //反序列化一个对象
        public static Object deSerialByte(byte[] by)
        {
            ObjectInputStream ois;
            try {
                ois = new ObjectInputStream(new ByteArrayInputStream(by));
                return ois.readObject();
            } catch (Exception e) {
                throw new RuntimeException(e.getMessage());
            }
        }
    }

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

    当你一个类实现了Serializable接口,如果没有定义serialVersionUID,Eclipse会提供这个提示功能告诉你去定义 。在Eclipse中点击类中warning的图标一下,Eclipse就会自动给定两种生成的方式。如果不想定义它,在Eclipse的设置中也
           可以把它关掉的,设置如下: 
            Window ==> Preferences ==> Java ==> Compiler ==> Error/Warnings ==>
            Potential programming problems 
            将Serializable class without serialVersionUID的warning改成ignore即可。

    如果你没有考虑到兼容性问题时,就把它关掉,不过有这个功能是好的,只要任何类别实现了Serializable这个接口的话,如果没有加入serialVersionUID,Eclipse都会给你warning提示,这个serialVersionUID为了让该类别Serializable向后兼容。

    如果你的类Serialized存到硬盘上面后,可是后来你却更改了类别的field(增加或减少或改名),当你Deserialize时,就会出现Exception的,这样就会造成不兼容性的问题。

    但当serialVersionUID相同时,它就会将不一样的field以type的预设值Deserialize,可避开不兼容性问题。

    注意以下几点:

    1、若继承的父类没有实现Serializable接口,但是又想让子类可序列化,子类实现Serializable接口,子类必须有可访问的无参构造方法,用于保存和恢复父类的public或protected或同包下的package字段的状态,否则在序列化或反序列化时会抛出RuntimeException异常,对于序列化后的子类,在进行反序列化时,理论上无法初始化父类中private(不可访问)对象变量的状态或值。

    2、在对可序列化类中的属性进行序列化时,如果遇到不可序列化的对象变量,此时会针对不可序列化的类抛出NotSerializableException异常

    3、对于可序列化的非数组类,强烈建议显示声明static型、long型、final型serialVersionUID字段用于标识当前序列化类的版本号,否则在跨操作系统、跨编译器之间进行序列化和反序列化时容易出现InvalidClassException异常
     

    展开全文
  • Serializable接口

    千次阅读 2019-01-23 19:55:23
    Serializable,之前一直有使用,默认的实体类就会实现Serializable接口,对具体原因一直不是很了解,同时如果没有实现序列化,同样没什么影响,什么时候应该进行序列化操作呢?今天查了下资料,大致总结一下。 1、...

    1、Serializable接口概述

    Serializable是java.io包中定义的、用于实现Java类的序列化操作而提供的一个语义级别的接口。Serializable序列化接口没有任何方法或者字段,只是用于标识可序列化的语义。实现了Serializable接口的类可以被ObjectOutputStream转换为字节流,同时也可以通过ObjectInputStream再将其解析为对象。例如,我们可以将序列化对象写入文件后,再次从文件中读取它并反序列化成对象,也就是说,可以使用表示对象及其数据的类型信息和字节在内存中重新创建对象。

    而这一点对于面向对象的编程语言来说是非常重要的,因为无论什么编程语言,其底层涉及IO操作的部分还是由操作系统其帮其完成的,而底层IO操作都是以字节流的方式进行的,所以写操作都涉及将编程语言数据类型转换为字节流,而读操作则又涉及将字节流转化为编程语言类型的特定数据类型。而Java作为一门面向对象的编程语言,对象作为其主要数据的类型载体,为了完成对象数据的读写操作,也就需要一种方式来让JVM知道在进行IO操作时如何将对象数据转换为字节流,以及如何将字节流数据转换为特定的对象,而Serializable接口就承担了这样一个角色。

    下面我们可以通过例子来实现将序列化的对象存储到文件,然后再将其从文件中反序列化为对象,代码示例如下:

    先定义一个序列化对象User:

    public class User implements Serializable { 
        private static final long serialVersionUID = 1L; 
     
        private String userId; 
        private String userName; 
     
        public User(String userId, String userName) { 
            this.userId = userId; 
            this.userName = userName; 
        } 
    } 
    

    然后我们编写测试类,来对该对象进行读写操作,我们先测试将该对象写入一个文件:

    public class SerializableTest { 
        /** 
         * 将User对象作为文本写入磁盘 
         */ 
        public static void writeObj() { 
            User user = new User("1001", "Joe"); 
            try { 
                ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("/Users/guanliyuan/user.txt")); 
                objectOutputStream.writeObject(user); 
                objectOutputStream.close(); 
            } catch (IOException e) { 
                e.printStackTrace(); 
            } 
        }  
        public static void main(String args[]) { 
            writeObj(); 
        } 
    } 
    

    运行上述代码,我们就将User对象及其携带的数据写入了文本user.txt中,我们可以看下user.txt中存储的数据此时是个什么格式:

    java.io.NotSerializableException: cn.wudimanong.serializable.User 
        at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184) 
        at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348) 
        at cn.wudimanong.serializable.SerializableTest.writeObj(SerializableTest.java:19) 
        at cn.wudimanong.serializable.SerializableTest.main(SerializableTest.java:27)
    

    我们看到对象数据以二进制文本的方式被持久化到了磁盘文件中。在进行反序列化测试之前,我们可以尝试下将User实现Serializable接口的代码部分去掉,看看此时写操作是否还能成功,结果如下:

    结果不出所料,果然是不可以的,抛出了NotSerializableException异常,提示非可序列化异常,也就是说没有实现Serializable接口的对象是无法通过IO操作持久化的。

    接下来,我们继续编写测试代码,尝试将之前持久化写入user.txt文件的对象数据再次转化为Java对象,代码如下:

    public class SerializableTest { 
        /** 
         * 将类从文本中提取并赋值给内存中的类 
         */ 
        public static void readObj() { 
            try { 
                ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("/Users/guanliyuan/user.txt")); 
                try { 
                    Object object = objectInputStream.readObject(); 
                    User user = (User) object; 
                    System.out.println(user); 
                } catch (ClassNotFoundException e) { 
                    e.printStackTrace(); 
                } 
            } catch (IOException e) { 
                e.printStackTrace(); 
            } 
        } 
     
     
        public static void main(String args[]) { 
            readObj(); 
        } 
    } 
    

    通过反序列化操作,可以再次将持久化的对象字节流数据通过IO转化为Java对象,结果如下:

    cn.wudimanong.serializable.User@6f496d9f 
    

    此时,如果我们再次尝试将User实现Serializable接口的代码部分去掉,发现也无法再文本转换为序列化对象,报错信息为:

    ava.io.InvalidClassException: cn.wudimanong.serializable.User; class invalid for deserialization 
        at java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(ObjectStreamClass.java:157) 
        at java.io.ObjectStreamClass.checkDeserialize(ObjectStreamClass.java:862) 
        at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2038) 
        at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1568) 
        at java.io.ObjectInputStream.readObject(ObjectInputStream.java:428) 
        at cn.wudimanong.serializable.SerializableTest.readObj(SerializableTest.java:31) 
        at cn.wudimanong.serializable.SerializableTest.main(SerializableTest.java:44)
    

    提示非法类型转换异常,说明在Java中如何要实现对象的IO读写操作,都必须实现Serializable接口,否则代码就会报错!

    2、序列化&反序列化

    通过上面的阐述和示例,相信大家对Serializable接口的作用是有了比较具体的体会了,接下来我们上层到理论层面,看下到底什么是序列化/反序列化。序列化是指把对象转换为字节序列的过程,我们称之为对象的序列化,就是把内存中的这些对象变成一连串的字节(bytes)描述的过程。

    而反序列化则相反,就是把持久化的字节文件数据恢复为对象的过程。那么什么情况下需要序列化呢?大概有这样两类比较常见的场景:

    • 需要把内存中的对象状态数据保存到一个文件或者数据库中的时候,这个场景是比较常见的,例如我们利用mybatis框架编写持久层insert对象数据到数据库中时;
    • 网络通信时需要用套接字在网络中传送对象时,如我们使用RPC协议进行网络通信时;

    3、关于serialVersionUID

    对于JVM来说,要进行持久化的类必须要有一个标记,只有持有这个标记JVM才允许类创建的对象可以通过其IO系统转换为字节数据,从而实现持久化,而这个标记就是Serializable接口。而在反序列化的过程中则需要使用serialVersionUID来确定由那个类来加载这个对象,所以我们在实现Serializable接口的时候,一般还会要去尽量显示地定义serialVersionUID,如:

    private static final long serialVersionUID = 1L; 
    

    在反序列化的过程中,如果接收方为对象加载了一个类,如果该对象的serialVersionUID与对应持久化时的类不同,那么反序列化的过程中将会导致InvalidClassException异常。例如,在之前反序列化的例子中,我们故意将User类的serialVersionUID改为2L,如:

    private static final long serialVersionUID = 2L; 
    

    那么此时,在反序例化时就会导致异常,如下:

    java.io.InvalidClassException: cn.wudimanong.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:1880) 
        at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1746) 
        at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2037) 
        at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1568) 
        at java.io.ObjectInputStream.readObject(ObjectInputStream.java:428) 
        at cn.wudimanong.serializable.SerializableTest.readObj(SerializableTest.java:31) 
        at cn.wudimanong.serializable.SerializableTest.main(SerializableTest.java:44)
    

    如果我们在序列化中没有显示地声明serialVersionUID,则序列化运行时将会根据该类的各个方面计算该类默认的serialVersionUID值。但是,Java官方强烈建议所有要序列化的类都显示地声明serialVersionUID字段,因为如果高度依赖于JVM默认生成serialVersionUID,可能会导致其与编译器的实现细节耦合,这样可能会导致在反序列化的过程中发生意外的InvalidClassException异常。因此,为了保证跨不同Java编译器实现的serialVersionUID值的一致,实现Serializable接口的必须显示地声明serialVersionUID字段。

    此外serialVersionUID字段地声明要尽可能使用private关键字修饰,这是因为该字段的声明只适用于声明的类,该字段作为成员变量被子类继承是没有用处的!有个特殊的地方需要注意的是,数组类是不能显示地声明serialVersionUID的,因为它们始终具有默认计算的值,不过数组类反序列化过程中也是放弃了匹配serialVersionUID值的要求。

    推荐博客:Java 序列化的高级认识

    展开全文
  • 啥是序列化. ...Serializable接口和JDK序列化的关系 为了实现序列化JDK提供了两个序列化API: java.io.ObjectOutputStream:表示对象输出流。它的writeObject(Object obj)方法可以对参数指定的obj对象进

    啥是序列化.

    Serialization(序列化)是一种将对象以一连串的字节描述的过程;
    反序列化deserialization是一种将这些字节重建成一个对象的过程。将程序中的对象,比如放入文件中保存就是序列化,将文件中的字节码重新转成对象就是反序列化。
    如图
    在这里插入图片描述

    Serializable接口和JDK序列化的关系

    为了实现序列化JDK提供了两个序列化API:
    java.io.ObjectOutputStream:表示对象输出流。它的writeObject(Object obj)方法可以对参数指定的obj对象进行序列化,把得到的字节序列写到一个目标输出流中。
    java.io.ObjectInputStream:表示对象输入流。
    它的readObject()方法从源输入流中读取字节序列,再把它们反序列化成为一个对象,并将其返回。

    实现序列化的要求

    1. 如果没有实现Serializable接口而进行序列化操作就会抛出NotSerializableException异常。

    2. 能够序列化的字段:属性变量、父类的属性变量(父类也需要实现Serializablie接口)

    3. 不能序列化的字段:静态变量、父类的属性变量、关键字transient修饰的变量、没有实现Serializable接口的对象属性

    一个序列化反序列化的例子

    创建要序列化的对象TypeDto

    
    public class TypeDto implements Serializable {
        private Long id;
        private String name;
        //***set  get方法省略
    }
    

    序列化方法将对象写入文件,再反序列化读出来

        public static void main(String[] args) throws IOException {
            TypeDto typeDto = new TypeDto(1L, "强强强");
    
            //创建一个ObjectInputStream输入流
            File file = new File("TypeDto.txt");
            if (!file.exists()) {
                file.createNewFile();
            }
            try (ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(file));) {
                outputStream.writeObject(typeDto);
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            TypeDto newType = null;
            try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file))) {
                newType = (TypeDto) ois.readObject();
            } catch (Exception e) {
                e.printStackTrace();
            }
    
    		System.out.println("原对象:" + typeDto.getName()+typeDto.getId());
            System.out.println("新对象:" + newType.getName()+newType.getId());
    
            System.out.println("原对象地址:" + typeDto);
            System.out.println("新对象地址:" + newType);
        } 
    

    结果:
    在这里插入图片描述
    如果序列化对象不加Serializable接口的,不管是序列化对象还是还原对象都会报出异常。
    在这里插入图片描述

    Serializable接口是啥

    Serializable接口是一个空接口,没有定义任何的方法和属性,所以Serialiazable接口的作用就是起到一个标识的作用,源码如下

    public interface Serializable {​

    实现了Serializable接口的serialVersionUID作用是什么?

    在反序列化时,JVM需要知道所属的class文件,在序列化的时候JVM会记录class文件的版本号,默认是JVM自动生成,也可以手动定义。反序列化时JVM会按版本号serialVersionUID找指定版本的class文件进行反序列化.

    **具体序列化的过程是这样的:**序列化操作时会把系统当前类的serialVersionUID写入到序列化文件中,当反序列化时JVM会自动检测文件中的版本号serialVersionUID,判断它是否与当前类中的serialVersionUID一致。如果一致说明序列化文件的版本与当前类的版本是一样的,可以反序列化成功,否则就失败;会抛异常提示版本号不一致的异常,即InvalidCastException。

    serialVersionUID有两种显示的生成方式:
    一是默认的1L,比如:private static final long serialVersionUID = 1L;

    二是根据包名,类名,继承关系,非私有的方法和属性,以及参数,返回值等诸多因子计算得出的,极度复杂生成的一个64位的哈希字段。基本上计算出来的这个值是唯一的。比如:private static final long serialVersionUID = xxxxL;

    所以 默认的serialVersionUID 会根据包名,类名,继承关系,非私有的方法和属性,以及参数,返回值等诸多因子的改变而改变,如果你再序列化完成之后改变了它的属性,那么serialVersionUID 也会发生改变,再次反序列化时就会失败。

    对于要不要加上一个固定的序列化serialVersionUID 看自己的需要就可以。如果项目要上线最好还是加上。

    展开全文
  • Serializable接口介绍Serializable是java.io包中定义的、用于实现Java类的序列化操作而提供的一个语义级别的接口。Serializable序列化接口没有任何方法或者字段,只是用于标识可序列化的语义。实现了Serializable...
  • 添加后的效果: 添加:Settings --》 Editor --》Inspections --》勾选 Serializable class without ‘serialVersionUID’
  • JavaSerializable接口

    2020-03-15 22:05:43
    Serializable接口定义: public interface Serializable { } 该接口没有任何属性和方法,这样的接口称为标识接口。 标识接口:只是起标识作用,而不解决实际问题,实际问题交给其他机制处理。如上课的时候,学生...
  • 问题来源 使用shiro搭建项目 之前的user 未曾改变 后来user添加了两个属性 就出来下图错误 最终搜了搜记录下 这个序列化id作用 项目使用了Redis作为缓存(序列化后的对象存入redis缓存)对象经常要通过IO进行...
  • Serializable接口的意义和用法

    万次阅读 多人点赞 2018-05-18 11:33:17
    本人软件工程大三妹子一枚,以下为个人观点仅供参考: 最近云课堂学习springmvc+mybatis项目时,发现老师实体类引用了serializable这个接口,如下:   import java.io.Serializable;...Serializable接口...
  • 平时的开发肯定发现实体类会实现Serializable接口,并且指定serialVersionUID的值。像这样 你可能会有疑问,为什么要实现Serializable接口呢。实现这个接口是为了序列化和反序列化。 如果这个实体类有内存...
  • 一句话解释就是:反序列化过程用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类,再简化就是为了反序列化后验证兼容性。 如果不声明会对类进行计算产生默认值,但是这种默认值充满不...
  • Serializable接口的理解

    2021-04-20 11:17:36
    一般情况下,我们在定义实体类时会继承Serializable接口,类似这样: 我们实体类引用了Serializable这个接口,那么这个接口到底有什么?细心的你会发现我们还定义了个serialVersionUID变量。这个变量到底有什么...
  • Serializable接口:序列化

    2020-10-11 00:21:22
    麻木地搬着Ctrl-C、Ctrl-V的砖,不知道重复了多少次定义Java实体对象时“implements Serializable”的C/V大法后,脑海突然冒出一个思维(A):问了自己一句“Java实体对象为什么一定要实现Serializable接口呢?...
  • 谈谈实现Serializable接口的作用和必要性

    千次阅读 多人点赞 2020-12-11 11:33:04
    Java编程我们会看到源码或者别人代码很多实体Bean都实现了Serializable接口,但是我很多实体使用并没有序列化也能正常使用。由此引发了我的疑问,到底需不要实现Serializable接口?答案是必要,请由我...
  • 一个对象序列化的接口,一个类只有实现了Serializable接口,它的对象才能被序列化。 什么是序列化? 序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。序列化期间,对象将其当前状态...
  • Java Web编程,很多实体类会实现Serializable 接口,但是很多实体使用并没有序列化也能正常使用。 定义:把对象转换为字节序列的过程称为对象的序列化 把字节序列恢复为对象的过程称为对象的反序列化 ...
  • 对象的串行化Serializable 接口

    千次阅读 2014-03-31 10:55:25
    Serializable 接口–java.io.serializable 作用:类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。...
  • javaSerializable接口的作用

    千次阅读 2018-04-16 16:29:56
    将对象的状态信息转换为可以存储或传输的形式的过程,序列化期间,对象将其当前状态写入到临时存储区或持久性存储区,之后,便可以通过从存储区读取或反序列化对象的状态信息,来重新创建该对象什么情况下需要...
  • 主要介绍了PHP自定义序列化接口Serializable用法,结合实例形式分析了Serializable自定义序列化接口的概念、功能、定义及使用方法,需要的朋友可以参考下
  • 定义实体类并继承Serializable接口 这个serialVersionUID是用来辅助对象的序列化与反序列化的,原则上序列化后的数据当中的serialVersionUID与当前类当中的serialVersionUID一致,那么该对象才能被反序列化成功。这...
  • 【Android】Android中Serializable接口定义和使用 1、序列化是干什么的?  简单说就是为了保存内存的各种对象的状态(也就是实例变量,不是方法),并且可以把保存的对象状态再读出来。虽然你可以...
  • Serializable接口的意义

    2020-11-03 21:34:25
    什么是Serializable接口 一个对象序列化的接口,一个类只有实现了Serializable接口,它的对象才可以被序列化。打开Serializable接口源码,里面什么都没有。 什么是序列化和反序列化 序列化是将对象状态转换为可...
  • JDK1.8Serializable接口详解

    千次阅读 2020-05-10 09:52:06
    java.io.Serializable接口是一个标志性接口,接口内部没有定义任何属性与方法。只是用于标识此接口的实现类可以被序列化与反序列化。 一、如何让某些属性不参与序列化与反序列化的过程? 如果一个属性被...
  • Serializable是什么,为什么要实现Serializable接口

    千次阅读 多人点赞 2020-08-06 13:45:07
    一般情况下,我们在定义实体类时会实现Serializable接口,例如: 什么是Serializable接口 一个对象序列化的接口,一个类只有实现了Serializable接口,它的对象才能被序列化。 Serializable是java.io包中定义
  • *Serializable接口是一种标记性接口,即它没有方法,实现这个接口可以启动Java的序列化机制,自动完成存储对象和数组的过程。 *Java提供一个内在机制完成写对象的过程,这过程称为:对象序列化(Object ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 139,037
精华内容 55,614
热门标签
关键字:

在serializable接口中定义了