serializable接口的作用,java里面 implements Serializable有什么作用？

serializable接口的作用,java里面 implements Serializable有什么作用？详细介绍

本文目录一览： serializable接口的作用

继承了serializable 就是表示这个类可以序列化
使用序列化保存数据比直接写在文件里更有安全性 而且读取的时候处理也简单
还有一个更重要的用途就是在rmi和ejb使用的时候 作为参数传递的对象必须是serializable的
调用outputStream的writeObject方法时，必须要实现serializable接口，这样javac编译时才会进行特殊处理，编译的类才能被writeObject方法操作。该接口是一个mini接口，没有必须要实现的方法，implements Serializable只是为了标注该对象是可被序列化的。如果你的对象要经过分布式系统进行网络传输或通过rmi等远程调用，这就需要在网络上传输对象，被传输的对象就必须实现Serializable接口。

为什么要实现serializable接口作用

最重要的两个原因是：
1、将对象的状态保存在存储媒体中以便可以在以后重新创建出完全相同的副本；
2、按值将对象从一个应用程序域发送至另一个应用程序域。
实现serializable接口的作用是就是可以把对象存到字节流，然后可以恢复。所以你想如果你的对象没实现序列化怎么才能进行网络传输呢，要网络传输就得转为字节流，所以在分布式应用中，你就得实现序列化，如果你不需要分布式应用，那就没那个必要实现序列化。

java serializable接口

java serializable接口是什么？让我们一起来了解一下吧！
java serializable接口是java程序中的serializable接口。serializable接口指的是运用其序列化功能的一个接口。如果没有这个接口的类便不可以让它们的任意状态变成序列化或者逆序列化。

serializable接口的定义代码：
public?interface?Serializable?{ }
serializable接口也被称为标识接口，它没有其他别的属性与方法。标识接口的定义是不能解决实际问题仅仅具有标识功能。
序列化的定义：序列化是将对象状态转换为可保持或传输的格式的过程。与序列化相应存在的是反序列化，它将流转换成对象。这两个过程结合起来，可以轻松地存储和传输数据。
序列化对于存储数据的好处：支持数据传输，特别是远程调用的时候。当我们需要把对象的状态信息通过网络传输或者需要将对象状态信息持久化，以便将来使用时都需要把对象进行序列化。
实战演练，具体代码如下: import?java.io.FileInputStream; ? import?java.io.FileOutputStream; ? import?java.io.IOException; ? import?java.io.ObjectInputStream; ? import?java.io.ObjectOutputStream; ? public?class?Test?{undefined ? public?static?void?main(String[]?args)?{undefined ? Person?p?=?new?Person(); ? p.setName("feige"); ? writeObj(p); ? Person?p2?=?readObj(); ? System.out.println(p2); ? } ? //?序列化 ? public?static?void?writeObj(Person?p)?{undefined ? try?{undefined ? ObjectOutputStream?objectOutputStream?=?new?ObjectOutputStream(new?FileOutputStream("E://1.txt")); ? objectOutputStream.writeObject(p); ? objectOutputStream.close(); ? }?catch?(IOException?e)?{undefined ? e.printStackTrace(); ? } ? } ? //?反序列化 ? public?static?Person?readObj()?{undefined ? Person?p?=?null; ? try?{undefined ? ObjectInputStream?objectInputStream?=?new?ObjectInputStream(new?FileInputStream("E://1.txt")); ? try?{undefined ? p?=?(Person)objectInputStream.readObject(); ? }?catch?(ClassNotFoundException?e)?{undefined ? e.printStackTrace(); ? } ? }?catch?(IOException?e)?{undefined ? e.printStackTrace(); ? } ? return?p; ? } ? }

Serializable接口怎么用？

public interface Serializable类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。
例如：当遍历一个图形时，可能会遇到不支持可序列化接口的对象。在此情况下，将抛出 NotSerializableException，并将标识不可序列化对象的类。
在序列化和反序列化过程中需要特殊处理的类必须使用下列准确签名来实现特殊方法：
private void writeObject(java.io.ObjectOutputStream out)
throws IOException
private void readObject(java.io.ObjectInputStream in)
throws IOException, ClassNotFoundException;
writeObject 方法负责写入特定类的对象的状态，以便相应的 readObject 方法可以还原它。通过调用 out.defaultWriteObject 可以调用保存 Object 的字段的默认机制。该方法本身不需要涉及属于其超类或子类的状态。状态是通过使用 writeObject 方法或使用 DataOutput 支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream 来保存的。
简介如下：
public interface Serializable类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。
要允许不可序列化类的子类型序列化，可以假定该子类型负责保存和还原超类型的公用 (public)、受保护的 (protected) 和（如果可访问）包 (package) 字段的状态。仅在子类型扩展的类（父类）有一个可访问的无参数构造方法来初始化该类的状态时，才可以假定子类型有此责任。如果不是这种情况，则声明一个类为可序列化类是错误的。该错误将在运行时检测到。
在反序列化过程中，将使用该类的公用或受保护的无参数构造方法初始化不可序列化类的字段。可序列化的子类必须能够访问无参数的构造方法。可序列化子类的字段将从该流中还原。

什么是java序列化？如何实现java序列化？Serializable接口的作用是什么？

【答案】：我们有时候将一个java对象变成字节流的形式传出去或者从一个字节流中恢复成一个java对象，例如，要将java对象存储到硬盘或者传送给网络上的其他计算机，这个过程我们可以自己写代码去把一个java对象变成某个格式的字节流再传输，但是，jre本身就提供了这种支持，我们可以调用OutputStream的writeObject方法来做，如果要让java 帮我们做，要被传输的对象必须实现serializable接口，这样，javac编译时就会进行特殊处理，编译的类才可以被writeObject方法操作，这就是所谓的序列化。需要被序列化的类必须实现Serializable接口，该接口是一个mini接口，其中没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的。

java里面 implements Serializable有什么作用？

serialization 允许将实现了Serializable接口的对象转换为字节序列，这些字节序列可以被完全存储以备以后重新生成原来的对象。 serialization不但可以在本机做，而且可以经由网络操作（就是猫小说的RMI）。这个好处是很大的----因为它自动屏蔽了操作系统的差异，字节顺序等。比如，在Window平台生成一个对象并序列化之，然后通过网络传到一台Unix机器上，然后可以在这台Unix机器上正确地重构这个对象。
import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; import java.net.ServerSocket; import java.net.Socket;//定义序列化(object)class Student implements Serializable { private int sno; private String sname; public Student(int sno, String sname) { this.sno = sno; this.sname = sname; } public int getSno() { return sno; } public void setSno(int sno) { this.sno = sno; } public String getSname() { return sname; } public void setSname(String sname) { this.sname = sname; } @Override public String toString() { return "学号:" + sno + ";姓名:" + sname; } } //(object)的反序列化过程class MyClient extends Thread { @Override public void run() { try { Socket s = new Socket("localhost", 9999); ObjectInputStream ois = new ObjectInputStream(s.getInputStream()); Student stu = (Student) ois.readObject(); System.out.println("客户端程序收到服务器端程序传输过来的学生对象>> " + stu); ois.close(); s.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } //(object)的序列化过程class MyServer extends Thread { @Override public void run() { try { ServerSocket ss = new ServerSocket(9999); Socket s = ss.accept(); ObjectOutputStream ops = new ObjectOutputStream(s.getOutputStream()); Student stu = new Student(1, "赵本山"); ops.writeObject(stu); ops.close(); s.close(); ss.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } //测试public class TestTransfer { public static void main(String[] args) { new MyServer().start(); new MyClient().start(); } }
有很多网络传输使用的都是Serializable
它可以先将代码保存为io，然后在反序列化回来了。
如果是android，实现这个接口，可以实现对象的传递。
通过实现这个接口可以实现序列化
对象的串行化（Serialization）
一、串行化的概念和目的 1.什么是串行化 对象的寿命通常随着生成该对象的程序的终止而终止。有时候，可能需要将对象的状态保存下来，在需要时再将对象恢复。我们把对象的这种能记录自己的状态以便将来再生的能力。叫作对象的持续性(persistence)。对象通过写出描述自己状态的数值来记录自己 ，这个过程叫对象的串行化(Serialization) 。串行化的主要任务是写出对象实例变量的数值。如果交量是另一对象的引用，则引用的对象也要串行化。这个过程是递归的，串行化可能要涉及一个复杂树结构的单行化，包括原有对象、对象的对象、对象的对象的对象等等。对象所有权的层次结构称为图表(graph)。 2.串行化的目的 Java对象的单行化的目标是为Java的运行环境提供一组特性，如下所示： 1) 尽量保持对象串行化的简单扼要 ，但要提供一种途径使其可根据开发者的要求进行扩展或定制。 2) 串行化机制应严格遵守Java的对象模型 。对象的串行化状态中应该存有所有的关于种类的安全特性的信息。 3) 对象的串行化机制应支持Java的对象持续性。 4) 对象的串行化机制应有足够的 可扩展能力以支持对象的远程方法调用(RMI)。 5) 对象串行化应允许对象定义自身 的格式即其自身的数据流表示形式，可外部化接口来完成这项功能。

二、串行化方法 从JDK1.1开始，Java语言提供了对象串行化机制 ，在java.io包中，接口Serialization用来作为实现对象串行化的工具 ，只有实现了Serialization的类的对象才可以被串行化。 Serializable接口中没有任何的方法。当一个类声明要实现Serializable接口时，只是表明该类参加串行化协议，而不需要实现任何特殊的方法。下面我们通过实例介绍如何对对象进行串行化。 1.定义一个可串行化对象 一个类，如果要使其对象可以被串行化，必须实现Serializable接口。我们定义一个类Student如下：
import java.io.Serializable; public class Student implements Serializable { int id;// 学号 String name;// 姓名 int age;// 年龄 String department; // 系别 public Student(int id, String name, int age, String department) { this.id = id; this.name = name; this.age = age; this.department = department; } }2.构造对象的输入／输出流 要串行化一个对象，必须与一定的对象输出／输入流联系起来，通过对象输出流将对象状态保存下来，再通过对象输入流将对象状态恢复。 java.io包中，提供了ObjectInputStream和ObjectOutputStream将数据流功能扩展至可读写对象 。在ObjectInputStream 中用readObject()方法可以直接读取一个对象，ObjectOutputStream中用writeObject()方法可以直接将对象保存到输出流中。
import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; public class ObjectSer { public static void main(String args[]) throws IOException, ClassNotFoundException { Student stu = new Student(981036, "LiuMing", 18, "CSD"); FileOutputStream fo = new FileOutputStream("data.ser"); ObjectOutputStream so = new ObjectOutputStream(fo); try { so.writeObject(stu); so.close(); } catch (IOException e) { System.out.println(e); } stu = null; FileInputStream fi = new FileInputStream("data.ser"); ObjectInputStream si = new ObjectInputStream(fi); try { stu = (Student) si.readObject(); si.close(); } catch (IOException e) { System.out.println(e); } System.out.println("Student Info:"); System.out.println("ID:" + stu.id); System.out.println("Name:" + stu.name); System.out.println("Age:" + stu.age); System.out.println("Dep:" + stu.department); } }运行结果如下：
Student Info: 　　ID:981036 　　Name:LiuMing 　　Age:18 　　Dep:CSD
在这个例子中，我们首先定义了一个类Student，实现了Serializable接口 ，然后通过对象输出流的writeObject()方法将Student对象保存到文件 data.ser中 。之后，通过对家输入流的readObjcet()方法从文件data.ser中读出保存下来的Student对象 。从运行结果可以看到，通过串行化机制，可以正确地保存和恢复对象的状态。 三、串行化的注意事项 1.串行化能保存的元素 串行化只能保存对象的非静态成员交量，不能保存任何的成员方法和静态的成员变量，而且串行化保存的只是变量的值，对于变量的任何修饰符都不能保存。 2.transient关键字 对于某些类型的对象，其状态是瞬时的，这样的对象是无法保存其状态的。例如一个Thread对象或一个FileInputStream对象 ，对于这些字段，我们必须用transient关键字标明，否则编译器将报措。 另外 ，串行化可能涉及将对象存放到 磁盘上或在网络上发达数据，这时候就会产生安全问题。因为数据位于Java运行环境之外，不在Java安全机制的控制之中。对于这些需要保密的字段，不应保存在永久介质中 ，或者不应简单地不加处理地保存下来 ，为了保证安全性。应该在这些字段前加上transient关键字。
下面是java规范中对transient关键字的解释： The transient marker is not fully specified by The Java Language Specification but is used in object serialization to mark member variables that should not be serialized.
以下是transient的一个应用举例:
//LoggingInfo.javaimport java.io.FileInputStream;import java.io.FileOutputStream;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;import java.util.Date;public class LoggingInfo implements java.io.Serializable { private static final long serialVersionUID = 1L; private Date loggingDate = new Date(); private String uid; private transient String pwd; LoggingInfo(String user, String password) { uid = user; pwd = password; } public String toString() { String password = null; if (pwd == null) { password = "NOT SET"; } else { password = pwd; } return "logon info: \n " + "user: " + uid + "\n logging date : "+ loggingDate.toString() + "\n password: " + password; } public static void main(String[] args) { LoggingInfo logInfo = new LoggingInfo("MIKE", "MECHANICS"); System.out.println(logInfo.toString()); try { ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("logInfo.out")); o.writeObject(logInfo); o.close(); } catch (Exception e) {// deal with exception } // To read the object back, we can write try { ObjectInputStream in = new ObjectInputStream(new FileInputStream("logInfo.out")); LoggingInfo logInfo1 = (LoggingInfo) in.readObject(); System.out.println(logInfo1.toString()); } catch (Exception e) {// deal with exception } }}

java中如何实现序列化，有什么意义

实现Serializable接口就行了，这个接口只是一个标记接口，不提供任何方法，Java序列化意义就是把Java在内存中的对象按照一定的格式以字节流的方式传输到别的地方，相当于传输协议，不然就会造成接收端数据错乱。
就像我和你打电话，你只能听懂中文，我硬是用英文跟你说了一大堆，在你看来那些英文就是一堆乱码，
一般需要序列化的都是实体类，只需要实现Serializable接口即可，意义在让java对象能够存到硬盘内存上，同时还能取出来变成一个java对象，底层实现还是IO流，具体就不知道了，小白一个
首先我们要把准备要序列化类，实现 Serializabel接口
例如：我们要Person类里的name和age都序列化
import java.io.Serializable;
public class Person implements Serializable { //本类可以序列化
private String name ;
private int age ;
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
public String toString(){
return "姓名：" + this.name + "，年龄" + this.age ;
}
}
然后：我们将name和age序列化（也就是把这2个对象转为二进制，统族理解为“打碎”）
package org.lxh.SerDemo;
import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream ;
public class ObjectOutputStreamDemo { //序列化
public static void main(String[] args) throws Exception {
//序列化后生成指定文件路径
File file = new File("D:" + File.separator + "person.ser") ; ObjectOutputStream oos = null ;
//装饰流（流）
oos = new ObjectOutputStream(new FileOutputStream(file)) ;
//实例化类
Person per = new Person("张三",30) ; oos.writeObject(per) ;//把类对象序列化
oos.close() ;
}
}
java 中实现序列化，只要实现Serializbale这个接口，那么这个类就能序列化了。
序列化就是把对象转化为二进制编码，有两个作用1.用于网络传输。2.可以存储到硬盘中，用来保存。类对象都是在内存中的，当系统关闭后对象就没了，下次启动时重新生成对象，不能保存当时状态。
有序列化，就有反序列化，反序列化就是恢复当时状态的类对象。

什么时候要用到Serializable呢

我的理解，对象的序列化就是对对象进行传输，持久化，
如果一个对象需要序列化，就要实现Serializable接口。
hibernate里面，实体类应该实现Serializable接口。
也不是 你的一些操作类是不需要序列化的
而实体是需要序列化，因为他们要持久到数据库
举个例子，你编写了一款游戏，保存记录时把所有状态一一保存非常麻烦，这时就可以使用Serializable（序列化接口），它的作用是可以将一个对象实例序列化，序列化后你可以选择将它保存在你需要的位置。
相对的，读取后生成的对象所有属性（除了设置为瞬时值的属性）将和原对象的属性相同（只是内存地址不同）。
这样可以方便的将一个java对象写入到磁盘中，保存该对象的所有状态！
值得注意的是序列化的对象中包含的属性和其他对象都需要实现序列化接口，不然无法正常序列化！
在hibernate里，并非所有的实体类必须实现序列化接口，因为在hibernate中我们通常是将基本类型的数值映射为数据库中的字段。而基础类型都实现了序列化接口（String也实现了）。
所以，只有在想将一个对象完整存进数据库（存储为二进制码），而不是将对象的属性分别存进数据库，读取时再重新构建的话，就可以不用实现序列化接口。

java序列化为什么要实现serializable

不一定要 根据需求
序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。
序列化:序列化是将对象转换为容易传输的格式的过程。例如，可以序列化一个对象，然后使用 HTTP 通过 Internet 在客户端和服务器之间传输该对象。在另一端，反序列化将从该流重新构造对象。
是对象永久化的一种机制。
　　 确切的说应该是对象的序列化，一般程序在运行时，产生对象，这些对象随着程序的停止运行而消失，但如果我们想把某些对象（因为是对象，所以有各自不同的特性）保存下来，在程序终止运行后，这些对象仍然存在，可以在程序再次运行时读取这些对象的值，或者在其他程序中利用这些保存下来的对象。这种情况下就要用到对象的序列化。
　　 只有序列化的对象才可以存储在存储设备上。为了对象的序列化而需要继承的接口也只是一个象征性的接口而已，也就是说继承这个接口说明这个对象可以被序列化了，没有其他的目的。之所以需要对象序列化，是因为有时候对象需要在网络上传输，传输的时候需要这种序列化处理，从服务器硬盘上把序列化的对象取出，然后通过网络传到客户端，再由客户端把序列化的对象读入内存，执行相应的处理。
　　 对象序列化是java的一个特征，通过该特征可以将对象写作一组字节码，当在其他位置读到这些字节码时，可以依此创建一个新的对象，而且新对象的状态与原对象完全相同。为了实现对象序列化，要求必须能够访问类的私有变量，从而保证对象状态能够正确的得以保存和恢复。相应的，对象序列化API能够在对象重建时，将这些值还原给私有的数据成员。这是对java语言访问权限的挑战。通常用在服务器客户端的对象交换上面，另外就是在本机的存储。
　　 对象序列化的最主要的用处就是在传递,和保存对象(object)的时候,保证对象的完整性和可传递性。譬如通过网络传输,或者把一个对象保存成一个文件的时候,要实现序列化接口