Java基础教程.doc

D1:Java介绍
1.1 Java起源、发展历程和版本划分：
1982年SUN公司成立，1991年出现，”Oak”——Java的早期称呼，用于嵌入家电；
1998年发布JDK1.2，并使用“Java 2”；目前我们大部分用JDK1.6的版本；

Java根据应用方向，分为三个版本及对应的类库：
J2ME 移动版
J2SE 标准版
J2EE 企业版

1.2 Java语言特点
易于学习 ；
高效率的执行方式，即先编译后执行；
与平台无关，即跨平台，可运行于主流操作系统如UNIX LINUX Windows上；
分布式；
安全性；
丰富的API文档和类库；
多线程；
1.3、关于JDK和JVM？
要进行Java开发，必须得安装JDK。
JDK(Java Development Toolkit)是Java开发工具包的简称，包含运行Java程序的类库和命令；
JDK包含JRE，它包含比JRE更多的命令。
JRE只是运行时环境，所包含的类库比JDK小；一般来讲，开发人员都应采用对应的JDK，目前用JDK6版本；
JRE=JVM+Runtime Interpreter；
Java运行环境的三项主要功能：
l 加载代码：由class loader 完成；
l 校验代码：由bytecode verifier 完成；
l 执行代码：由 runtime interpreter完成。

关于Java虚拟机(JVM)
l 在一台计算机上由软件或硬件模拟的计算机。Java虚拟机(JVM)读取并处理经编译过的平台无关的字节码class文件 。
l Java编译器针对Java虚拟机产生class文件，因此是独立于平台的。
l Java解释器负责将Java虚拟机的代码在特定的平台上运行。
l Java语言是先编译源文件，后执行class文件！

1.4 Java程序分类
l Java Application
以main()方法作为程序入口，由Java解释器加载执行。
l Java Apple
没有main()方法作为程序入口，由浏览器或appletviewer加载执行。
l Jsp,Servlet
Web上的应用程序，即主流J2EE服务程序

1.5 JDK安装和配置
上级演示
1.6 第一个Java程序
Java应用程序举例HelloWorld.java：
源文件：HelloWorld.java
/*
*范例名称："Hello World"程序
*/
public class HelloWorld {
public static void main (String args[]) {
System.out.println("Hello World!");
}
}

先编译 javac 类名.java，(编译完会形成一个二进制的class文件，该文件与平台无关，即可以跨平台运行)后运行java 类名

1.7 小结
命名
如果.java 文件包含一个public 类，它必需按该类名命名。Java语言中单词拼写严格区分大小写；
类个数
一个源文件中最多只能有一个public 类。其它类的个数不限。

1.8、Java学习路线；
初级部分： Java核心技术(Core Java);
中级部分： JSP JavaBean Servlet等;
高级部分： SSH框架 EJB 数据库(Oracle SQL Server MySQL) 各种商用应用服务器配置;
项目部分： UML建模 需求分析等;

D2:Java基础
2.1 标示符和关键字
标示符：
标示符：Java程序中的类、属性、方法、对象、变量等元素都应有自己的名称，各元素的名称通称为标识符。
Java标识符定义规则：由字母、数字、_和$组成；开头字符必须是字母、下画线或$。

关键字：
l Java中一些赋以特定的含义、并用做专门用途的单词称为关键字（keyword）
l 所有Java关键字都是小写的，TURE、FALSE、NULL等都不是Java关键字 ；
l goto和const 虽然从未使用，但也作被为Java关键字保留；
l true,false,null虽被用做专门用途，但也不是Java关键字，它们只是显式常量值；

2.2 Java的基本数据类型
Java数据类型划分
数据类型

基本数据类型
引用数据类型
数值型
字符型(char)
布尔型（boolean）

整数类型(byte, short, int, long)
浮点类型(float, double)
类(class)
接口(interface)
数组

boolean布尔类型：只有true和false两种值；
char字符型：
字符常量是用单引号括起来的单个字符
char c = 'A';
Java字符采用Unicode编码，每个字符占两个字节，因而可用十六进制编码形式表示
char c1 = '\u0061'; //\u0061表示a (因为Java字符采用Unicode编码，每个字符占两个字节，故可用16进制编码表示)
Java语言中还允许使用转义字符'\'来将其后的字符转变为其它的含义
char c2 = '\n';
如\n代表换行，\r代表回车，\\代表反斜杠
整型：
类 型
占用存储空间
表数范围
byte
1字节
-128 ~ 127
short
2字节
-2的15次方 ~ 2的15次方-1
int
4字节
-2的31次方 ~ 2的31次方-1
long
8字节
-2的63次方 ~ 2的63次方-1
Java语言整数常量的三种表示形式：
十进制整数，如12, -314, 0。
八进制整数，要求以0开头，如012
十六进制数，要求0x或0X开头，如0x12
Java语言的整型常量默认为int型，如：
int i =3;
声明long型常量可以后加‘ l ’或‘ L ’ ，如：
long l = 3L;

浮点型：
Java浮点类型常量有两种表示形式
十进制数形式，必须含有小数点，例如:
3.14 314.0 .314
科学记数法形式，如
3.14e2 3.14E2 314E2
Java浮点型常量默认为double型,如要声明一个常量为float型，则需在数字后面加f或F，如：
double d = 3.14;
float f = 3.14f;
float 占4个字节，double占8个字节

范例代码VariableTest.java：
Java中变量的定义
class VariableTest{
public static void main (String args []) {
boolean b = true; //声明boolean型变量并赋值
int x, y=8; // 声明int型变量
float f = 4.5f; // 声明float型变量并赋值
double d = 3.1415; //声明double型变量并赋值
char c; //声明char型变量
c ='\u0031'; //为char型变量赋值
x = 010; //为int型变量赋值
System.out.println("b=" + b);
System.out.println("x=" + x);
System.out.println("y=" + y);
System.out.println("f=" + f);
System.out.println("d=" + d);
System.out.println("c=" + c);
}
}

2.3 基本数据类型转换
除了布尔型数据外，字符型 整型的数据和浮点类型的数据可以混合在一起进行运算，不同类型数据运算的结果是何种类型的呢？数据可由一种类型转换成另一种类型吗？在这一讲里这些疑问都将得到解决。

1整型和浮点类型都可看作是数值型数据，当不同的数值型数据运算时，有一个内在的规则：先统一为同一类型，再进行运算。结果就为运算前统一的类型。这里的“统一”就是自动类型转换。
自动类型数据转换总是从低级到高级进行，byte、char、short的级别最低，double的级别最高；
范例：
定义如下几个变量：
int x, byte y, long z, float a, double b, char c;

分析：x + y的结果应为int型，x + y + z的结果为long型，a + b的结果为double型，a - x - y的结果为float型，x + c的结果为int型。

2欲让高级数据转换成低级数据，需用到强制类型转换，其形式如 int x = (int)3.5;

class TypeConvertTest{
public static void main (String args []) {
char c1 = 'a';
System.out.println("c1=" + c1 + 1); //输出c1=a1
System.out.println(c1 + 1); //输出a的ASC码值97+1=98
}
}

2.4 运算符
算术运算符: +，―，*，/，%，++，――
关系运算符: >，<，>=，<=，==，!=
布尔逻辑运算符: !，& , | , ^ , &&，||
赋值运算符: = 扩展赋值运算符:+=，―=，*=，/=
字符串连接运算符: +

逻辑运算符
逻辑运算符功能
！-- 逻辑非 & -- 逻辑与 | -- 逻辑或
^ -- 逻辑异或 &&-- 短路与 || -- 短路或

逻辑运算符功能说明:
a
b
!a
a&b
a|b
a^b
a&&b
a||b
true
true
false
true
true
false
true
true
true
false
false
false
true
true
false
true
false
true
true
false
true
true
false
true
false
false
true
false
false
false
false
false

短路逻辑运算符应用
&& -- 第一个操作数为假则不判断第二个操作数
|| -- 第一个操作数为真则不判断第二个操作数

字符串连接符：
"+"运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串然后再进行连接
int i = 300 +5;
String s = "hello, " + i + "号";
System.out.println(s); //输出：hello, 305号

条件运算符：
三目条件运算符，语法格式：
x ? y : z
其中x为boolean类型表达式，先计算x的值，若为true，则整个三目运算的结果为表达式y的值，否则整个运算结果为表达式z的值。
举例：
int score = 50;
int result = x <60 ? 60: x;
String type = score <60 ? "不及格" : "及格";
2.5 分支结构之if
if (条件表达式) {

}else if (条件表达式) {

} else if (条件表达式) {

} else {

}

练习：写一方法,在调用时通过参数输入年号,判断是否为闰年。
算法: 根据闰年的判断条件
当年号能被4整除但不能被100整除时, 为闰年。
当年号能被400整除时, 为闰年。
2.6 分支结构之switch case
switch(变量){
case 常量1：
表达式；
break;
case 常量2：
表达式；
break；
default：
表达式；
注意: case后面的常量必须是整数或字符型；
通常在每一个case中都应使用break语句提供一个出口，使流程跳出开关语句。
switch中的表达式结果必须是一个整型值，该值用来与后续的值1、值2、……、值n比较，如果值是相同的，则执行case后的语句组。之后不再判断，连续地执行下去，直到遇到break语句或switch运行完毕

练习：输入一百分制成绩，输出对应的等级。90~100分的等级为A?0~89分的等级为B?0~79分的等级为C?0~69分的等级为D?60分以下的等级为E

2.7 循环结构
l 循环语句功能
在循环条件满足的情况下，反复执行特定代码
l 循环语句的四个组成部分
初始化部分（init_statement）
循环条件部分（test_exp）
循环体部分（body_statement）
迭代部分（alter_statement）
l 循环语句分类
for 循环
while 循环
do/while 循环

2.8 循环结构之for循环
public class HelloWorld
{
public static void main(String[] args)
{
int i,sum = 0;
for(i=1; i<=100; i++) {
sum += i;
}
System.out.println(sum);
}
}

2.9 循环结构之while循环
public class HelloWorld
{
public static void main(String[] args)
{
int i = 1,sum = 0;
while(i<=100)
{
sum += i;
i++;
}
System.out.println("sum="+sum);
}
}

2.10 循环结构之do {} while()
先执行循环体，再判断条件
public class HelloWorld
{
public static void main(String[] args)
{
int i = 1,sum = 0;
do
{
sum += i;
i++;
}
while (i<=100); //分号不能少
System.out.println(sum);
}
}

2.11 循环控制:break和continue的区别
break是立即终止循环，即便后面还有循环没有被执行；
continue只是中断满足条件的本次循环；

嵌套循环，代码测试@

2.12 return语句
return 语句：用于退出一个方法或程序体。return之后不能有其他语句.
用法举例：
public void get(String name){
if(name==null)
return;
}

D3:Java面向对象(上)
3.1 OOP(Object Oritented Program)面向对象概述
面向对象的编程思想力图使对计算机语言中对事物的的描述与现实世界中该事物的本来面目尽可能的一致。
类(class)和对象(object)是面向对象方法的核心概念。类是对一类事物描述，是抽象的、概念上的定义；对象是实际存在的该类事物的
每个个体，因而也称实例(instance)。
3.2 OOP 类和对象
万物皆对象;
对象一般都有两个特征:状态和行为;
在软件开发中,对象定义为相关数据和方法的集合;对象是现实世界对象的抽象模型;
类是抽象的,对象是具体的;
Java中,每段源代码就是一个类文件,类包括成员变量和成员方法两部分. 对象是类的实例;

3.3 声明类
类只包括两个部分，成员属性和成员方法；

例如我们要创建人类，可以归纳出人类共有的特性，把它定义为属性，比如年龄 姓名等；

比如，以创建人类为目标，我们来看如何定义Java中的类Person.java：
public class Person {
int age;
int getAge() {
return age;
}
void setAge(int i){
age = i;
}
}

成员变量的定义格式为：
[修饰符] 数据类型 变量名 [=默认值]；

成员方法的定义格式为：
[修饰符] 返回类型 方法名(形参列表){
方法体
}
3.4 对象的创建
l 使用new 类名的形式创建一个新的对象；标准格式如下 类名 对象名 = new 类名();
l 使用“对象名。对象成员”的方式访问成员变量或者方法；
l 创建对象也可写成两行代码的形式：
Person p1; //声明一个对象p1
//p1 = new Person(); //此时创建对象，在内存中分配地址给p1

EX时间：
练习如何创建人类，加入其它成员变量和方法。
巩固类和对象的概念：创建一个生日类BirthDate，包括年月日属性及各属性的setXXX和getXXX 方法；创建一个方法，在控制台输出年月日；

3.5 成员变量和局部变量
成员变量：
l 类的内部、方法的外部定义的变量；
l 作用域：依附于对象存在，具有与对象相同的生存期和作用域；
l 创建后由系统自动对其进行初始化；

局部变量：
l 方法或语句块中定义的变量；
l 作用域：所在的方法内；在程序调用方法时才被创建，随方法的退出而销毁；
l 使用前必须初始化值；

3.6 构造方法(Constructor Method)
构造方法：提供创建对象的不同方式；
l 构造方法的名称须与类名一致；
l 没有返回类型，也不能定义为void；
l 主要作用是完成对象的初始化工作，为成员变量赋值；
l 一个类中可以定义多个构造方法，如果没有显示定义构造方法，系统默认提供一个无参的构造方法；
l 构造方法的可以重载overload，满足重载的条件：方法名相同，参数列表要不同(以参数的个数、顺序或类型划分)；
3.7 static关键字
l 在Java类中声明变量、方法和内部类时，可使用关键字static做为修饰符。
l static标记的变量或方法由整个类(所有实例)共享，可不必创建该类对象而直接用类名加‘.’调用。
l static成员也称类成员或静态成员，如：类属性、类方法、静态方法等。
l 静态方法直接访问静态成员，静态方法需创建对象才能访问非静态成员；
l 非静态方法可以直接访问静态成员；

3.8 String和StringBuffer
String为不可变字符串，而StringBuffer为缓冲字符串类，又称为可变字符串，它的效率比String更高；
StringBuffer 只能这样创建：StringBuffer sb = new StringBuffer(new String(“hello”))；
错误的代码：StringBuffer sb = “hi”;
3.9 数组
数组属于引用类型，数组中的元素可以是任何数据类型，包括基本类型和引用类型；
一维数组的声明：
int a[]; int[] a; int []a; MyDate date[];
声明数组的时候不能指定其长度（数组元素的个数） 例如：int a[5] 是非法的

数组初始化三种方式：
l 静态初始化：定义数组即赋值
int a[] = {1,2,3};
l 动态初始化：数组定义和赋值分开进行
int a[] = new int[3]; a[0]=1; a[1]=2; a[2]=3;
l 默认初始化：数组的元素相当于类的成员变量，因此数组一旦分配空间，其中的每个元素也按照成员变量的方式被隐式初始化；

定义并用new运算符给数组分配空间后才能引用数组元素；
每个数组都有一个length属性指明它的长度；
3.10 Java中的参数传递
值传递：基本数据类型和String作为参数传递时，是传递值的拷贝，无论你怎么改变这个拷贝，原值是不会变的！
参考MethodParamTest.java
/*
*在Java中基本数据类型和字符串作为参数传递时，是把值拷贝了一份传给了参数，称为值传递
*/
public class MethodParamTest{
public static void main(String[] args){
int i =9;
String s = "中国";

modifyInt(i);
modifyString(s);

System.out.println(i); //9
System.out.println(s); //中国
}
static void modifyInt(int i){
i = 90;
}
static void modifyString(String str){
str = "美国";
}
}

引用传递：引用类型作为参数传递时，是传递对象的引用(即该对象在内存中的地址)；
参考MethodParamTest1.java和MethodParamTest2.java

3.11 Java三大特性之—封装
Java面向对象三大特性：
封装；
继承；
多态；

何为封装？为何需要封装？

封装：
即将客户端不应看到的信息包裹起来。
具体做法：将数据声明为私有的private，再提供一个或多个public 修饰的方法对其进行操作；
l 隐藏一个类的实现细节；
l 使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；
l 便于修改，增强代码的可维护性；

EX时间：上机理解为何需要封装及它的好处；理解private关键字的作用。

D4:Java面向对象(下)
4.1 Java三大特性之二—继承
何谓继承：利用extends关键字使类具有父子层次关系，子类默认拥有父类所有属性和方法；
当子类拥有和父类相同的变量，这时父类的变量将被隐藏；

继承需要注意的地方：
l Java只支持单一继承，也就是只有一个父类，利用extends 关键字继承；
l 父类的私有方法不能被子类覆盖；
l 父类的静态方法不能被子类覆盖为非静态方法；
l 父类的非静态方法不能被子类覆盖为静态方法；
l 子类中定义的成员变量和父类中定义的成员变量相同时，则父类中的成员变量被隐藏；见ExtendsTest1.java
l 当子类拥有和父类相同的方法定义(即方法名 参数列表完全相同时，不能以返回类型不同为依据，仅方法体不一样)，我们称之为方法重写(OverRide)；

隐藏和覆盖：
父类的静态变量和实例变量能被子类同名变量隐藏；
父类的静态方法被被子类的静态方法隐藏；
父类的非静态方法被子类的非静态方法覆盖；
见ExtendsTest2.java

继承关系中构造方法注意事项：
*1 子类不继承父类的构造方法
*2 子类的构造方法必须调用父类的构造方法
* 2.1 如果子类的构造方法中没有显示地调用父类构造方法，也没有使用this关键字调用重载的其它构造方法，则系统默认调用父类无参数的构造方法
* 2.2 如果子类构造方法中既未显式调用父类构造方法，而父类中又没有无参的构造方法，则编译出错
* 2.3 在子类的构造方法中可使用语句super(argument_list) 调用父类的构造方法
见ConstructorInitTest1.java和ConstructorInitTest2.java

Super关键字 ：
l 出现场合1：在子类构造方法调用父类构造方法；
l 出现场合2：在子类的实例方法内使用，用于访问父类被屏蔽的变量和方法；
l 不能在static和静态块内出现；
见SuperTest.java
4.2 Java三大特性之三—多态性
类的多态性：发送数据类型给某个对象，让该对象自行决定响应何种行为；
实现方式：让父类引用指向子类对象；
如 Person p1 = new Student();
//引用的类型是Person，对指向子类对象Student

/*多态性：
* 1 对于一个引用类型的变量，Java编译器按照它的声明的类型来处理
* 2 对于一个引用类型的变量，运行时Java虚拟机按照它的实际引用的对象来处理
* 运行时环境中，通过引用类型变量来访问所引用对象的方法和属性时，Java虚拟机采用以下绑定规则
* 3 实例方法与引用变量实际引用的对象的方法绑定，属于动态绑定
* 4 静态方法与引用变量所声明的类型的方法绑定，属于静态绑定
* 5 成员变量（包括静态和实例变量）与引用变量所声明的类型的成员变量绑定，属于静态绑定

见范例PolyTest1.java PolyTest2.java PolyTest3.java
4.3 类型转换
instanceof关键字：用于判断某个引用类型是否是某个对象的实例；
多态性中的类型转换：
1 子类到父类为自动转换；
2 父类到子类必须得强制转换，强转后可以调用子类新扩展的方法. 强转代码如下；
Student stu = (Student)person;
见InstanceofTest.java
4.4 抽象类
抽象类(Abstract Class)：
抽象类提供一个类型的部分实现，可以有实例变量，构造方法，抽象方法(Abstract Method 即不能有方法的实现哪怕是{})和具体方法。一个抽象类不会有实例；
一句话，它是用来继承的。它反映了一种一般/特殊化的关系。

设计抽象类的原则：
1抽象类应尽可能多地拥有具体类公共的代码，这样做可以提高代码的重用性。
2抽象类应尽可能少地拥有数据，数据应尽量放在具体类中。

抽象类要点：
1 可以含有抽象和非抽象方法。如果有一个抽象方法，那么该类一定是抽象类。
2 抽象类不能实例化，它只是用来继承的；
3 子类必须得重写抽象类的抽象方法；如果子类没有重写抽象方法，那么该类仍然是抽象类；
见范例AbstractTest.java
4.5 接口
接口(interface) 提供了一种类似于多重继承的机制，允许一个类实现N个接口；
接口中的数据默认都是public static final修饰，即常量，所以实现类不能对其重新定义或修改；
接口中的方法默认都是public抽象方法，不能有实现方法，实际上，它就是用来抽象化事情的描述；
接口反应的是一种“like - a”关系，而抽象类反应的是“is - a”关系；
接口可以继承其他接口，添加新的属性和方法。
4.6 包和访问控制符 final关键字
包(package)是类的容器，用于分割类名空间，避免命名冲突和易于组织管理类。
声明某个类在某个包下，如：
package com.app.dao; //只能在第一行出现
那么此源文件必须放在com->app->dao目录下。

Java的访问控制符分两类：
1 类：类只能被public或default（默认 什么都不写）修饰。
2 属性和方法：以下四个。

 同一类中
 同一包中
 同一子类中
 通用（其它） 
 private
   Yes

 default
   Yes
    Yes

 protected
   Yes
    Yes
     Yes

 public
   Yes
    Yes
     Yes
     Yes

final关键字：
final可以修饰成员变量、方法和类；不能修饰构造方法；
final修饰的变量为常量，一旦赋值不可更改；
final修饰的方法不能被子类覆盖；
final修饰的类不能被继承，因此类成员默认都是final类型的 因为没机会被覆盖；
当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。
4.7 基本数据类型的包装类(Wrapper Class)
每个基本数据类型都对应一个包装类，用于对象的操作；
需要在 基本类型如int——包装类Integer——String之间 互转；
public class WrapperTest {
public static void main(String args[]) {

//1 字符串转成 int
int i1 = Integer.parseInt("1");
int i2 = Integer.valueOf("2").intValue();

//2 字符串转成Integer
Integer i3 = Integer.valueOf("3");
Integer i4 = new Integer("4");

//3 int转成字符串
String s1 = String.valueOf(1);
String s2 = Integer.toString(2);
String s3 = "" + 3;

//4 int转成Integer
Integer integer1 = new Integer(4);

//5 Integer转成字符串
String s4 = integer1.toString();

//6 Integer转成int
int i5 = integer1.intValue();
}
}

4.8 ==和equals
equals被用来检测两个对象是否相等，即两个对象的内容是否相等；
==检测基本数据类型，只要值相等，结果即为true； 而在比较引用类型时，则是比较引用是否指向同一个对象，是则为true；

参照TestEqualsString.java
4.9 内部类
内部类：放在一个类的内部定义的类就叫内部类。分为静态和非静态内部类。
内部类类似于外部类的一个属性；

作用：
l 可以很好的实现隐藏，一般的类是不允许有private protected修饰的，内部类则可以；InnerTest1.java
l 内部类可以访问外部类的所有成员；
l 可以实现多重继承；InnerTest2.java
l 可以避免修改接口而实现同一类中两种同名方法的调用。

内部类和外部类互访规则：
l 外部类可以访问内部类的私有成员变量，反之也可；
l 非静态内部类只能含有非静态成员，可直接访问外部类成员，如遇同名变量，用 “外部类名.this.属性” 去访问；
l 外部类按照常规方式访问非静态内部类，如以下格式；
//适合外部类的非静态方法
InnerClass innerClass = new InnerClass();
innerClass.i = 1;
innerClass.methodA();

//适合外部类的静态方法(必须将内部类对象指向一个外部类实例的引用)
OuterClass outerClass = new OuterClass();
InnerClass innerClass = outerClass.new InnerClass();
innerClass.i = 1;
innerClass.methodA();
l 静态内部类可含有静态和非静态成员(和非静态内部类的区别)，非静态方法可直接访问外部类的静态成员，访问外部类非静态成员需new外部类实例；静态方法直接访问外部类静态方法，需创建外部类实例访问外部非静态方法；
l 外部类访问静态内部类成员，如：
OuterClass1.InnerClass2 inner2 = new OuterClass1.InnerClass2();
inner2.i = 10;
inner2.pay();
OuterClass1.InnerClass2.methodS(); //此句只针对访问静态内部类的静态方法

匿名(anonymous)内部类：有时候不需要内部类的对象名，即无名的内部类；
当一个内部类的类声名只是在创建此类对象时用了一次，而且要产生的新类需继承于一个已有的父类或实现一个接口，才考虑用匿名类。

方法中的类称为局部内部类，该类只在本方法中有效，而且只能访问方法中的final成员；
D5:异常处理
5.1 异常的概念
Java程序运行过程中所发生的异常事件可分为两类：
l 错误(Error):JVM系统内部错误、资源耗尽等严重情况；
l 异常(Exception): 其它因编程错误或偶然的外在因素导致的问题，例如：
数组越界
空指针访问
试图读取不存在的文件
网络连接中断
5.2 异常的层次

异常包括
1 Runtime运行时异常如数组越界 算数异常
2 非运行时异常如IO文件未找