JAVA基础知识总结
第一章 Java入门：
1. java诞生：
19xx年5月23日Sun公司发布了jdk1.0版本；作者：James Gosling.
JAVAME微型版
手机软件开发
JAVASE标准版
桌面应用程序
JAVAEE企业版
企业级应用开发
2. java语言特点：
1.简单
没有C、C++中的头文件，指针，运算符重载
2.面向对象
可以开发出较大型的应用程序
3.分布式
通过网络访问应用程序，突破空间限制
4.健壮性(编译时错误检测)
消除有出错倾向的状态：指针
5.安全性(蠕虫病毒)
禁止运行时堆栈溢出、内存空间未授权读写
6.可移植性
JVM
3. JAVA的特性、核心机制：
特性：封装 ：对外部不可见，保护类中的操作不被外部直接访问
属性私有化，提供公共的get、set方法
封装的好处：
1.数据更安全，可以在方法内增加验证
2.可以让调用者不去关心实现的细节，重用
继承 ：扩张类的功能
多态 ：
是允许将父对象引用一个子对象的技术
Employee employee = manager;
允许父类对象来引用子类对象，但是实际运行过程中调用的是子类的方法或者属性
编译时调用父类方法，运行时调用的是实际引用类型的方法，这种现象叫做动态绑定
多态现象：运行时多态、编译时多态
1.编译时多态：方法的重载(不建议举例)
2.运行时多态：方法的覆盖(建议举例)
核心机制： 虚拟机(JVM java virtual machine) 垃圾回收机制 garbage collector
4.JDK:（Java Development Kit）19xx年 SUN公司JDK1.0 98年JDK1.2 接下来是JDK1.3 1.4 目前JDK1.5已经更名为JAVA 5.0 正在使用的是java 6.0版本.
JDK安装目录介绍：
Bin 编译器和工具
Demo 演示
Docs HTML格式的类库文档
Include 用于编译本地方法的文件
Jre java运行环境文件
Lib 类库文件
Src 类库源文件
5.Java运行环境变量配置：
JAVA_HOME：JDK安装目录，方便在后面两个环境变量的配置中直接被
调用即可
path：%JAVA_HOME%\bin 列出可执行文件的搜素路径
classpath：%JAVA_HOME%\lib\tools.jar
%JAVA_HOME%\lib\dt.jar
.（当前路径）
是java加载类的路径，只有在classpath设置的路径中的类才能被加载
6.Java中注释：
1.单行注释：
//
2.多行注释：
/* */
3.文档注释
/** */
通过javadoc命令将文档注释提取出来生成java帮助文档：Java的三种注释：
7.Class 与public class区别：
如果一个类声明的时候使用了public进行声明，则类名称必须与文件名称完全一致，如果类的声明使用了class的话，则类名称可以与文件名称不一致，但执行的时候肯定执行的是生成后的类名称。
第二章 标示符，运算符
1. 标示符：在java语言中用来给一个类、变量或方法命名的符号
标示符的命名规则：
1.以字母, “_” 或 “$”符号开头
2.可以包含字母、 “_” 、“$”和数字符号
3.大小写敏感
4.不能与保留关键字冲突
5.没有长度限制
Java中命名规范：
1.类名, 接口名 ：每个单词的首字母应该大写
2.字段、方法以及对象：第一个单词首字母应小写，其他单词首字母大写
3.常量：全部用大写字母表示
4.Java包（Package）：它们全都字母小写
5.命名要做到见名知意
2.运算符：
1.算数运算符：
2.自增，自减运算符：
3.关系运算符：boolean型 运行结果 true false
4.逻辑运算符：&& || !
支持短路运算
&&：左边表达式为false，右边表达式不会被执行
||：左边表达式为true，右边表达式不会被执行
5.赋值运算符：= 不要将其与（= =）等号运算符混淆
6.运算符： & 、|、 ~、 ^、 <<、 >> 、>>>
1.~ ：取反。1变0,0变1
2.&：按位与。有0为0
3.^：按位异或。相同为0，不同为1
4.|：按位或。有1为1
7.instanceof运算符：左面操作一个对象，右面操作一个类，当左面对象是右面的类创建时，该运算符的结果是true，否则是false。
第三章 表达式，语句：
1. 表达式：算术表达式 关系表达式 逻辑表达式 赋值表达式
2. 语句：方法调用语句 表达式语句 复合语句 控制语句 package和import语句
控制语句：1.条件控制语句 if if-else
2.switch开关语句 switch(){case}
switch case:
说明：
1.表达式expression可以是以下四种基本数据类型和枚举 类型(byte，short，int，char)
2.case子句中的值必须是常量，而且所有case子句中的值应是不同的。
3.case通常与break语句联用，以保证多路分支的正确实现，多个case可以公用一组执行语句。
循环语句：1.for循环语句for
2.while循环语句
3.do-while循环语句
4.break和continue语句
break语句，跳出它所在的循环语句或switch 语句，并从紧跟该循环语句或switch 语句后的第一条语句处执行
continue语句，用来结束本次循环，跳过循环体中下面尚未执行的语句，接着进行终止条件的判断，以决定是否继续循环
第四章 数据类型，字符串，数组：
1.数据类型：
基本数据类型：
数值型
整数型：
字节型：byte(1个字节)
整型：int(4个字节)
长整型：long (8个字节)
短整型：short(2个字节)
实数型:浮点型：
单精度浮点型：float(4个字节)
双精度浮点型： double(8个字节)}
字符型{char(2个字节)}
布尔型{beloon型(1位)：true 或者 false}
空类型：NULL；
引用数据类型：{数组 接口 类}：就是将一个堆内存的空间使用权交给了其他对象；
自动类型转换：低优先级数据转换为高优先级数据：
byte-short-char-int-long-float-double
强制类型转换：高优先级数据强制转换为低优先级数据
例：double b=3.2222d；
int a= (int)b；
3. 字符串：
==与equals的区别：
在Object类中equals(Object obj)方法与==的比较结果一致的 但是equals是一个方法可以被重写，例如在String类中equals比较的就是字符串的内容
String本身是一个类，在String类中定义的构造方法：public String (String original) 可以接收一个String类的对象，并重新实例化String对象，String还可以采用直接赋值的方式进行对象的实例化
一个字符串是使用 “”括起来的 那么一个字符串的常量实际上本身就属于String的一个匿名对象
String str = "hello" ; 与 String str = new String("hello"); 有什么区别？、
String str="hello " 如果内存已经为"hello"分配了内存空间，那么Str只要指向"hello"内存对象地址；
String str = new String("hello"); 内存中重新分配一块内存区域给"hello"，str指向"hello",也就是内存中有两个hello的对象了，而且指向的地址不一样。
String与StringBuffer的区别？
他们都可以存储和操作字符串；
StringBuffer 使用来存储字符串变量，他的对象是可以更改和扩充的，也可以
用来存储字符串常量；
String是用来存储字符串常量，存储的字符串是不可以更改的
字符串的内容一旦声明之后则无法修改，实际上字符串变量的改变改变的是内存空间的地址的指向，而本身的字符内容没有任何的变化。
1.根据字符串中的索引找到指定位置的字符：public char charAt(int index)
2.将字符串变为字符数组：public char[]toCharArray()
3.将字符数组变为字符串：
将全部的字符数组变为String类型：public String(char[]value) 将部分的字符数组变为String类型：public String（char[]value，int offset，intcount）
4.String- 字节数组：public bute[] gerBytes()
字节数组-String：
全部：public String(byte[]bytes)
部分：public String(byte[]byres,int offset,int length)
5. 判断是否以指定的字符串开头：public Boolean startsWith(String prefix)
判断是否以指定的字符串结尾：public Boolean endsWith(String suffix)
6.替换操作：public String replaceAll(String regex,String replacement)
7.字符串截取：
全部截取：public String substring(int beginIndex)
部分截取：public String substring(int beginIndex.int endIndex)
8.字符串拆分：public String[]split(string regex)
9.字符串查找：
取得指定字符串的位置：public int indexOf(String str),public int indexOf(String str,int fromIndex)此方法返回int型的数据，如果查找到了怎返回位置，查找不到，返回-1
直接查找：public Boolean contains(String s)
10.字符串的其他操作:
去掉左右空格：public String trim()
取得字符串的长度：public int length()
转大写：public String toUpperCase()
转小写：public String toLowerCase()
4.数组: 属于引用数据类型，使用时需要开辟内存空间；
数据类型 数组名称[]=new 数据类型[长度]；
数据类型 数组名称[]=null；
数组名称=new数据类型[长度]；
关键字new只要一出现，怎肯定表示数据类型是是引用数据类型，要进行堆-栈空间的开辟
二维数组：动态初始化：数据类型 数组名称[][]=new 数据类型[长度][长度]
静态初始化：
数据类型 数组名称[][]={{2,3，2}{2，32,2}}；
char[] 缺省值为0所对应的字符
boolean[]缺省值为false
User[] 自定义类型数组缺省值为null
求数组的长度：
ar.length 属性
二维数组循环打印：
for(int m=0;m<h.length;m++){
for(int n=0;n<h[m].length;n++){
System.out.print(h[m][n]);
}
System.out.println();
}
数组拷贝：
System.arraycopy(Object src,
int srcPos,
Object dest,
int destPos,
int length);
src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量
第五章 类，方法，关键字 保留字：
1. 类：
类的基本概念：是用来封装一类对象的状态和方法，类是用来定义对象的模板。是由属性和方法组成；类的属性全部保存在对内存中，全部的方法保存在全局代码中。
抽象类：
包含一个抽象方法的类称为抽象类，抽象方法是只声明而未实现的方法，所有的抽象方法必须使用abstract关键字声明，所有的抽象类也需要使用abstract关键字声明，对于抽象类，不能直接进行实例化的操作，但是可以声明，如果要想使用抽象类，则必须依靠子类，抽象类是必须被子类继承的，而且被继承的子类需要实现抽象类中的全部抽象方法；
抽象类中允许有构造方法，但是构造方法是不能直接调用的，是交给子类去调用的，子类对象的实例化过程中永远是先调用父类中的构造方法---实际上来讲 抽象类就比普通类多了一个抽象方法而已
抽象类中的属性如果要想初始化，则肯定还是依赖于构造方法
内部类：
作用
1.内部类可以很好的实现隐藏,也就是封装性。一般的非内部类，是不允许有 private 与protected权限的，但内部类可以
2.内部类拥有外围类的所有元素的访问权限
3.可是实现多重继承
4.可以避免修改接口而实现同一个类中两种同名方法的调用
在一个类的内部还有另外一个类。内部类的缺点：是程序的结构混乱。内部类的唯一优点：在于可以方便访问外部类中的私有成员。如果要在外部类中直接使用内部类的实例化对象
外部类.内部类 内部类对象=外部类实例.new 内部类实例（）
一个内部类如果使用static关键字声明的话，则此内部类就将成为外部类，可以直接通过外部类.内部类的形式访问
内部类可以在任意地方使用，如在方法中声明方法中定义的内部类可以直接访问外部类的各个成员，但是如果要访问方法中的参数，则参数中要使用final关键字；
普通代码块{ }
构造块：直接在类中定义的代码块( 构造块会重复调用多次；构造块会优先与构造方法执行)
静态块：用static关键字声明的代码块：主要目的是用来为静态属性初始化化。优先于主方法和构造块执行；而且只执行一次；
匿名类：
匿名内部类：在抽象类和接口的基础上发展起来的，在一般的开发中匿名内部类中使用较少，现在只有两种情况下可以经常看到匿名内部类的使用： Java图形界面
Spring开发框架
异常类：Exception
异常与错误：
1.异常是在一个程序执行过程中出现的一个事件，它中断了正常指令的执行
2.偏离了可接受代码的一个动作或实例就是错误
异常结构的分类：
Throwable
Error Exception
未检查异常(运行时) 已检查异常(编译时)
对异常处理方式-捕获：
try{
<可能出现异常的代码块>
}catch(Exception e){
<如果try中代码出现异常，则执行catch中的代码>
}
**注意：catch()代码块可以存在多个，但是catch中的异常类型应该由小到大 try{
<可能出现异常的代码块>
}catch(Exception e){
<如果try中代码出现异常，则执行catch中的代码>
}finally{
<无论有无异常都会被执行的代码块>
}
**注意：try{}finally{}可以搭配使用
对异常的处理-抛出：throws表明当前函数不处理出现的异常，将异常抛出，交给调用方去处理(处理的方式：捕获、继续抛出)
throw关键字，表明被捕获的异常没有经过处理直接抛出
在继承关系中，子类覆盖父类的方法，抛出的异常类型不能比父类更宽泛
所谓异常处理，就是指程序在出现问题时依然可以正确的执行完
异常处理格式：try {可能出现的异常语句}
Catch（异常类，异常对象）{异常类，异常对象}{异常处理}..finaly{异常出口}
对于java来讲，当程序出现异常，实际上都是产生了一个类的实例化对象
异常类最大的父类：Throwable
Error：一般表示JVM错误，与程序无关
Exception：一般指的是程序的错误，所以一般开发中如果想要进行程序的处理，基本上都是使用此类表示；
Class类：
包装类：包装类用于基本数据类型的区别：
1.包装类是对基本数据类型的一种扩展，定义了很多类型之间的转换方法
2.针对一些集合类型，他们要求我们存入集合的是Object，那么基本数据类型不能满足要求，就只能放包装类的对象
数值型：Integer,Byte,Short ,Float,Double,Long都是Nummber的子类 其他类型：Character，Boolean---Object子类；
装箱操作：Integer i=new Integer(i);
拆箱操作：int j=i.intValue();
jDk 1.5之后增加了很多新特性如：foreach 可变参数，即自动装箱拆箱操作； Integet i=I; 自动装箱操作
int j=i; 自动拆箱操作
Object类：
如果一个类中没有明确指定继承那个父类，则默认情况下就是继承Object类；任何类的对象都可以使用object进行接收，不光可以接收类的引用，只要是引用数据类型都可以使用object类接收
对于一个完整的类来讲，应该覆写Object类中的以下三个方法：
toString ：对象打印时调用public String toString（）
equals（）：对象比较时调用，实际上String类就已经覆写好了此方法 public Boolean equals（object obj）
hasCode() 暂时不看
Object可以接收任意的应用数据类型的引用
2. 方法：就是一段可以重复调用的代码段；一个方法可以接受一个数组或者返回一个数组，但是在接受数组的时候一定要注意，数组是引用数据类型，所以方法中对数组所做的一切修改最终都会被保留下来；
方法调用过程：
1.为被调用方法分配临时存储空间
2.将实参复制一份传给形参
3.跳入被调用方法中执行
4.方法体执行完成或遇到return语句，返回主方法，同时被调用方法的临时存储空间被收回
抽象方法：
构造方法：一个用来初始化对象的一个方法，在每个类中都存在一个构造方法。构造方法的主要目的是为类中属性初始化；所有的构造方法应该是对象操作前最早调用的；如果一个类中没有明确声明一个构造方法，则会自动生成一个无参的什么都不做的构造方法；当使用关键字new时才会调用类中的构造方法；
要求：构造方法名称与类名称一致
构造方法定义没有返回值类型的声明
不能在构造方法中使用return返回一个内容
用new +构造方法来创建一个新的对象
构造方法私有化-单例设计，一个类只能产生一个实例化对象；实现的核心：一个类中必须有构造方法，如果将构造方法私有化之后，那么外部无法产生新的实例化对象了；
重载：指的是方法名称相同，但是参数的类型和个数不同
方法名相同，参数列表不同
参数列表：1.参数类型 2.参数个数
系统会根据调用时传递的参数自动找到匹配的同名方法进行调用
覆写：发生在继承的关系中，子类覆写了父类中的相关方法，子类定义了与父类同名的方法，成为方法的覆写；在方法覆写时候注意：被覆写的方法不能拥有比子类更加严格的访问权限；访问权限 private<default<public
在使用子类实例化对象调用类中被覆写过的方法时，调用的永远是被覆写过的操作，永远不是覆写，而是从新定义；
如果希望调用父类中被子类覆写过的方法，则只能通过super方法（）形式调用；
属性的覆盖，子类中声明了父类中同名的方法成为覆盖，但从实际的开发来讲，属性基本上属于private类型，所以覆盖这种概念根本不存在
调用
在使用递归操作的时候一定要注意递归操作要有明确的截止条件，否则会出现异常；
3. 关键字关键字列表：
abstract boolean break byte case catch char class continue default do double else extends enum false final finally float for if implements import instanceof int interface long native new null package private protected public return short static super switch synchronized this throw throws transient true try void volatile while
Java 中 true false 不是关键字,而是boolean类型的字面量 所有的关键字都是小写，friendly，sizeof不是java的关键字
Super：
1.调用父类的方法或属性，前提是方法和属性在子类中是可见的
2.super()调用父类中的无参构造
3.在调用父类构造方法的 时候必须放在第一句
Abstract：abstract类：
1.如果一个方法没有方法体，那么该方法一定为abstract方法
2.如果一个类中有一个abstract的方法，那么该类一定为abstract类
3.abstract类不能被实例化
Abstract a = new MyClass();//MyClass extends Abstract
Final：
声明类：声明的类不能有子类
声明方法：声明的方法不能被子类覆写
声明变量：声明的变量就称为常量，常量是不可以修改的
在java中如果使用final声明一个常量的话，怎常量的标示符必须全部大写 使用public static final 声明的常量称为全局常量
This：
可以表示当前对象；通过this.属性表示当前类中的属性；通过this.方法（）表示当前类的方法；通过this（）可以调用本类中的其他构造方法，但是要求至少有一个构造方法中没有使用this（），而此构造方法将作为调用的出口，一般这个出口都会使用无参构造完成；而且调用时this（）要放在构造方法的首行
Static：1.修饰变量，变量被所有实例所共享
2.修饰方法，方法内不可以引用非静态成员；但是非静态方法可以引用静态成员
使用static关键字可以声明全局变量，所有对象共同拥有
Static属性或方法可以直接通过类名称调用
Static方法只能调用static属性方法，而不能调用非static的属性或方法 静态属性和方法可以在没有实例化对象的时候调用。使用static可以统计一个类产生了多少个实例化对象，因为static的属性是所有对象共享的；在开发中还可以使用static进行自动命名操作；
Throws：在程序中的方法声明处可以使用throws关键字，使用此关键字的最大好处是：在方法中不处理任何的异常，而是交给调用处处理；
在程序中可以使用throw关键字人为的抛出一个异常，在异常的处理中，实际上每次产生异常的时候都产生了一个异常类的实例化对象，那么此时也可以通过抛出异常对象的方式完成
异常处理的其他操作；NumberFormatException 是RuntimeException 的子类那么也就是说只要是RuntimeException的异常对象 虽然使用了throws 但是在程序中也可以不使用 try?catch 进行处理
一个类只要继承了Exception则就表示一个自定义的异常，当发现系统中提供的异常类不够时就可以这样做；
assert：表示断言，就是表示说当程序执行到某条语句之后，其结果肯定是固定值；
4.保留字：asser enum const goto
第六章 对象，继承，接口, 包：
1． 对象： 声明对象： 类名 对象名称=null；
实例化对象：对象名称=new 类名（）；
类名 对象名称=new 类名（）；
访问属性：对象名称.属性名
访问方法：对象名称.方法名（）
匿名对象：在一个对象被创建之后，调用对象的方法是可以不定义对象的引用变量，直接调用该对象的方法；只是用一次的对象；
2． 继承：可以复用代码，缩短开发周期，节约成本
就是扩展已有类的功能，在继承中分为子类和父类；父类有时候又称为超类，子类有时候成为派生类；extends 继承类限制：在使用继承类的时候虽然可以扩充类的功能，但是其本身也存在以下限制：在java中不允许多重继承：一个子类只能继承一个父类，不能继承多个父类；
在java中允许多层继承，在继承中子类不能访问父类中的私有操作，而只能继承全部的公有操作，对于私有内容不能直接访问，但是可以通过其他途径访问
在实例化子类对象时候肯定要先实例化父类中的内容，为父类初始化，那么实际，此时对于子类的构造方法而言，实际上就隐藏了一个super（）语句---表示父类的无参构造；
子类对象的实例化过程：先去调用父类中的构造方法，之后再执行子类自己的构造方法，父类的构造方法执行完之后实际上是为父类中的属性初始化了，但是未执行完的话，子类的构造方法就永远不能调用，那么子类的所有属性都无法初始化，那么默认值为0
一个子类永远不要去继承一个已经实现好的类，要么继承抽象类，要么实现接口，这个原则必须始终记住；
如果想要进行向下转型，则首先必须产生向上转型的关系
3． 接口
1.接口是一个特殊的抽象类
2.接口中的方法都是public 的抽象方法
3.一个类可以实现多个接口
InterfaceTest implements MyInterfaceA,MyInterfaceB
4.接口中的所有属性都会自动声明为final static
final static int a = 10;
public abstract void showA();
接口是一个特殊的类，在java中接口是抽象方法和全局常量组成的，在java中使用interface来定义一个接口
实现接口通过implements关键字来完成
一个类虽然只能继承一个父类，但是一个类可以实现多个接口，使用接口完成多继承的功能，一个类既要实现接口又要继承抽象类的话，则必须按照以下形式：
Class子类 extends抽象类 implement是 接口A，接口B,…..{}
一个抽象类可以实现多个接口，但是一个接口不能继承一个抽象类，一个接口虽然不可以继承一个抽象类，但是一个接口却可以同时继承多个接口；
接口也可以像抽象类那样通过对象的多态性进行对像的实例化操作；
正常情况下 一个接口的之类要实现全部的抽象方法；
4． 包：就是一个文件夹，不同的文件件中可以存在同名的类 在java中使用
package语法定义包；
通过javac –d ./ Hello.java 命令进行打包编译；
d：表示生成目录；根据package的定义生成
. ：表示在当前所在的文件夹中生成
导入包 在程序中很多类都存放在不同的包中，使用import语句进行导包操作时，如果一个包中的类需要被外部所访问，那么此类一定声明public class；类型
静态导入：如果一个包中某个类中的方法全部都是static类型 则就可以使用静态导入；
系统用包：
Java. Lang.此包中包含了各种常用的类，此包属于自动导入，但是在JDK 1.0 时此包必须手工导入；
Java.lang.reffect:此包属于反射机制包，是整个java中最重要的包，此包完成大量的低层操作
Java.util包：工具包，如果把此包掌握非常清楚，则可以方便做各种开发，做各种设计
Java.IO包：IO操作
Java.net：网络编程
Java。Sql:数据库编程：
Java.text：国际化程序运用
5、什么是Java序列化，如何实现Java序列化？
Java 串行化技术可以使你将一个对象的状态写入一个Byte 流里，并且可以从其它地方把该Byte 流里的数据读出来，重新构造一个相同的对象。这种机制允许你将对象通过网络进行传播，并可以随时把对象持久化到数据库、文件等系统里。Java的串行化机制是RMI、EJB等技术的技术基础。用途：利用对象的串行化实现保存应用程序的当前工作状态，下次再启动的时候将自动地恢复到上次执行的状态。
序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。
序列化的实现：将需要被序列化的类实现Serializable接口，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。
2、串行化的特点：
（1）如果某个类能够被串行化，其子类也可以被串行化。如果该类有父类，则分两种情况来考虑，如果该父类已经实现了可串行化接口。则其父类的相应字段及属性的处理和该类相同；如果该类的父类没有实现可串行化接口，则该类的父类所有的字段属性将不会串行化。
（2）声明为static和transient类型的成员数据不能被串行化。因为static代表类的状态，transient代表对象的临时数据；
（3）相关的类和接口：在java.io包中提供的涉及对象的串行化的类与接口有ObjectOutput接口、ObjectOutputStream类、ObjectInput接口、ObjectInputStream类。
（1）ObjectOutput接口：它继承DataOutput接口并且支持对象的串行化，其内的writeObject()方法实现存储一个对象。ObjectInput接口：它继承DataInput接口并且支持对象的串行化，其内的readObject()方法实现读取一个对象。
（2）ObjectOutputStream类：它继承OutputStream类并且实现ObjectOutput接口。利用该类来实现将对象存储（调用ObjectOutput接口中的writeObject()方法）。ObjectInputStream类：它继承InputStream类并且实现ObjectInput接口。利用该类来实现读取一个对象（调用ObjectInput接口中的readObject()方法）。
对于父类的处理，如果父类没有实现串行化接口，则其必须有默认的构造函数（即没有参数的构造函数）。否则编译的时候就会报错。在反串行化的时候，默认构造函数会被调用。但是若把父类标记为可以串行化，则在反串行化的时候，其默认构造函数不会被调用。这是为什么呢？这是因为Java 对串行化的对象进行反串行化的时候，直接从流里获取其对象数据来生成一个对象实例，而不是通过其构造函数来完成。
import java.io.*;
public class Cat implements Serializable {
private String name;
public Cat () {
this.name = "new cat";
}
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public static void main(String[] args) {
Cat cat = new Cat();
try {
FileOutputStream fos = new FileOutputStream("catDemo.out");
ObjectOutputStream oos = new ObjectOutputStream(fos);
System.out.println(" 1> " + cat.getName());
cat.setName("My Cat");
oos.writeObject(cat);
oos.close();
} catch (Exception ex) { ex.printStackTrace(); }
try {
FileInputStream fis = new FileInputStream("catDemo.out");
ObjectInputStream ois = new ObjectInputStream(fis);
cat = (Cat) ois.readObject();
System.out.println(" 2> " + cat.getName());
ois.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
}//writeObject和readObject本身就是线程安全的，传输过程中是不允许被并发访问的。所以对象能一个一个接连不断的传过来