我创建了一个Student类，然后用ObjectOutPutStream写入流，结果出现了一个NotSerializableException异常：具体代码如下
Student类：

1. class Student implements Comparable<Student>
   
2. {
   
3.         private String name;
   
4.         private int age;
   
5.         private String num;
   
6.        
   
7.         public Student() {}
   
8.         public Student(String name, int age, String num)
   
9.         {
   
10.                 this.name = name;
    
11.                 this.age = age;
    
12.                 this.num = num;
    
13.         }
    
14.         public void setName(String name)
    
15.         {
    
16.                 this.name = name;
    
17.         }
    
18.         public void setAge(int age)
    
19.         {
    
20.                 this.age = age;
    
21.         }
    
22.         public void setNum(String num)
    
23.         {
    
24.                 this.num = num;
    
25.         }
    
26.         public String getName()
    
27.         {
    
28.                 return name;
    
29.         }
    
30.         public int getAge()
    
31.         {
    
32.                 return age;
    
33.         }
    
34.         public String getNum()
    
35.         {
    
36.                 return num;
    
37.         }
    
38.        
    
39.         public void show()
    
40.         {
    
41.                 System.out.println("name:"+name+"   age:"+age+"   num:"+num);
    
42.         }
    
43.        
    
44.         public int hashCode()
    
45.         {
    
46.                 return num.hashCode();
    
47.         }
    
48.        
    
49.         public boolean equals(Object obj)
    
50.         {
    
51.                 if(!(obj instanceof Student))
    
52.                         throw new ClassCastException("不是Student类");
    
53.                        
    
54.                 Student s = (Student)obj;
    
55.                 return this.getName().equals(s.getName())&&this.getAge() == s.getAge();
    
56.         }
    
57.        
    
58.         public int compareTo(Student s)
    
59.         {
    
60.                 int n = this.getName().compareTo(s.getName());
    
61.                 if(0 == n)
    
62.                         return s.getAge() - this.getAge();
    
63.                 return n;
    
64.         }
    
65. }

复制代码

写入的代码：

1. import java.io.*;
   
2. 
   
3. class ObjectStreamDemo
   
4. {
   
5.         public static void main(String []args) throws IOException
   
6.         {
   
7.                 oosWrite();
   
8.         }
   
9.        
   
10.         public static void oosWrite() throws IOException
    
11.         {
    
12.                 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("f:\\obj.txt"));
    
13.                
    
14.                 oos.writeObject(new Student("孙悟空",1280,"花果山001"));
    
15. 
    
16.         }
    
17. }
    

复制代码

异常提示：


请大牛们给指点一下！

异常提示都很明确了，说Student 没有实现 java.io.Serializable 接口呢

Student类没有实现Serializable接口，

只需要class Student implements Comparable<Student> , Serializable就行了。
当然还要导入import java.io.Serializable;

ObjectInputStream与ObjectOutputStream 被操作的对象需要实现Serializable(标记接口即没有方法的接口)
这样这个类就会生成一个ID号，这个ID号是系统通过成员变量和成员函数计算出来的，用来标识这个类
如果你生成对象后，把对象序列化了(比如存到硬盘的文件里)，你又修改了类里的成员，再反序列化时(读取文件里的对象到内存中)
就会失败，因为修改了类里的成员，ID号就变了，与之前对象序列化时的就不一样了，就报错
有一种方法可以解决这个问题，可以在最开始定义类时自定义一个UID号：pubic static final long serialVersionUID = 42L; (注：42L这个值可以任意定义)
注：静态变量是不能被序列化的，因为它存储在方法区，而对象存在堆内存中，只能序列化堆内存中的数据。
如果非静态成员也不想序列化，就加关键字transient修饰，保证其值在堆内存中存在，而不在文件中存在。

我明白了，真是谢谢大家了！{:soso_e183:}