目录
第一章 异常
什么是异常?Java代码在运行时期发生的问题就是异常。
在Java中,把异常信息封装成了一个类。当出现了问题时,就会创建异常类对象并抛出异常相关的信息(如异常出现的位置、原因等)。
1.1 异常的继承体系
在Java中使用Exception类来描述异常。
查看API中Exception的描述,Exception 类及其子类是 Throwable 的一种形式,它用来表示java程序中可能会产生的异常,并要求对产生的异常进行合理的异常处理。继续观察,我们可以发现Exception有继承关系,它的父类是Throwable。Throwable是Java 语言中所有错误或异常的超类,即祖宗类。
另外,在异常Exception类中,有一个子类要特殊说明一下,RuntimeException子类,RuntimeException及其它的子类只能在Java程序运行过程中出现。
我们再来观察Throwable类,能够发现与异常Exception平级的有一个Error,它是Throwable的子类,它用来表示java程序中可能会产生的严重错误。解决办法只有一个,修改代码避免Error错误的产生。
异常继承体系总结:
Throwable: 它是所有错误与异常的超类(祖宗类)
|- Error 错误
|- Exception 编译期异常,进行编译JAVA程序时出现的问题
|- RuntimeException 运行期异常, JAVA程序运行过程中出现的问题
1.2 异常与错误的区别
异常:指程序在编译、运行期间发生了某种异常(XxxException),我们可以对异常进行具体的处理。若不处理异常,程序将会结束运行。
错误:指程序在运行期间发生了某种错误(XxxError),Error错误通常没有具体的处理方式,程序将会结束运行。Error错误的发生往往都是系统级别的问题,都是jvm所在系统发生的,并反馈给jvm的。我们无法针对处理,只能修正代码。
1.3 异常的产生过程解析
1.4 抛出异常throw
在java中,提供了一个throw关键字,它用来抛出一个指定的异常对象。那么,抛出一个异常具体如何操作呢?
1,创建一个异常对象。封装一些提示信息(信息可以自己编写)。
2,需要将这个异常对象告知给调用者。怎么告知呢?怎么将这个异常对象传递到调用者处呢?通过关键字throw就可以完成。throw 异常对象;
throw用在方法内,用来抛出一个异常对象,将这个异常对象传递到调用者处,并结束当前方法的执行。
异常中的关键字
throw,在方法内部,抛出异常的对象
throw 后面,必须写new对象,必须是异常的对象,必须是Exception或者子类。
if( arr == null){
//抛出异常的形式,告诉调用者
//关键字 throw
throw new Exception("传递数组不存在");
}
1.5 声明异常throws
将问题标识出来,返回给调用者。如果方法内通过throw抛出了编译时异常,而没有捕获处理,那么必须通过throws进行声明,让调用者去处理。
方法中声明异常关键字(告诉调用者可能会出现异常)
throws 用于在方法的声明上,标明出方法可能出现异常,请调用者处理
throws 后面必须写异常类的类名
public static int getArray(int[] arr) throws Exception {
}
public static void main(String[] args) throws Exception {
}
调用了一个抛出异常的方法,调用者就必须处理
不处理,编译失败
package day21.demo1;
/*
* 异常中的关键字
* throw,在方法内部,抛出异常的对象
* throw 后面,必须写new 对象,必须是异常的对象,必须是Exception或者子类
*
* 方法中声明异常关键字
* throws 用于在方法的声明上,标明次方法,可能出现异常
* 请调用者处理
* throws 后面必须写异常类的类名
*
* 调用了一个抛出异常的方法,调用者就必须处理
* 不处理,编译失败
*/
public class ExceptionDemo {
public static void main(String[] args) throws Exception {
int[] arr = {};
int i = getArray(arr);
System.out.println(i);
}
//对数组的最后索引*2,返回
public static int getArray(int[] arr) throws Exception {
//对方法参数进行合法性的判断,进行判断是不是null
if( arr == null){
//抛出异常的形式,告诉调用者
//关键字 throw
throw new Exception("传递数组不存在");
}
//对数组进行判断,判断数组中,是不是有元素
if(arr.length == 0){
//抛出异常的形式,告诉调用者,数组没有元素
throw new Exception("数组中没任何元素");
}
int i = arr[arr.length-1];
return i*2;
}
}
throws用于进行异常类的声明,若该方法可能有多种异常情况产生,那么在throws后面可以写多个异常类,用逗号隔开。
多个异常的情况,例如:
public static int getElement(int[] arr,int index) throws NullPointerException, ArrayIndexOutOfBoundsException {
}
1.6 捕获异常try…catch…finally
throws是出现问题,调用者解决。捕捉异常是出现问题,自己解决。
捕获:Java中对异常有针对性的语句进行捕获,可以对出现的异常进行指定方式的处理。
捕获异常格式:
try {
//需要被检测的语句。
}
catch(异常类 变量) {
//参数。
//异常的处理语句。
}
finally {
//一定会被执行的语句。
}
try:该代码块中编写可能产生异常的代码。
catch:用来进行某种异常的捕获,实现对捕获到的异常进行处理。
finally:有一些特定的代码无论异常是否发生,都需要执行。另外,因为异常会引发程序跳转,导致有些语句执行不到。而finally就是解决这个问题的,在finally代码块中存放的代码都是一定会被执行的。
/*
* 异常的处理方式:
* try...catch...finally
* 格式:
* try{
* 被检测的代码
* 可能出现异常的代码
* }catch(异常类名 变量){
* 异常的处理方式
* 循环,判断,调用方法,变量
* }finally{
* 必须要执行代码
* }
*/
public class ExceptionDemo1 {
public static void main(String[] args) {
int[] arr = null;
try{
int i = getArray(arr);
System.out.println(i);
}catch(NullPointerException ex){
System.out.println("###"+ex);
}catch(ArrayIndexOutOfBoundsException ex){
System.out.println("!!!!!!"+ex);
}
System.out.println("Game Over");
}
/*
* 定义方法,抛出异常
* 调用者使用try catch
*/
public static int getArray(int[] arr)throws NullPointerException,ArrayIndexOutOfBoundsException{
//对数组判空
if( arr == null){
//手动抛出异常,抛出空指针异常
throw new NullPointerException("数组不存在");
}
//对数组的索引进行判断
if( arr.length < 3){
//手动抛出异常,抛出数组的索引越界异常
throw new ArrayIndexOutOfBoundsException("数组没有3索引");
}
return arr[3]+1;
}
}
1.7 运行时期异常
1. 异常分为编译异常和运行时期异常:
编译异常: 调用了抛出异常的方法,不处理编译失败 (try throws)
运行异常: 抛出的异常是RuntimeException类,或者是他的子类
2. 异常的特点:
方法中抛出运行时期异常,方法定义中无需throws声明,调用者也无需处理此异常
运行时期异常一旦发生,需要程序人员修改源代码。
3. 设计原因:
运行异常,不能发生,但是如果发生了,程序人员停止程序修改源代码运行异常: 一旦发生,不要处理,请你修改源代码, 运行异常一旦发生,后面的代码没有执行的意义
RuntimeException和他的所有子类异常,都属于运行时期异常。NullPointerException,ArrayIndexOutOfBoundsException等都属于运行时期异常.
/*
* 异常分为编译异常和运行时期异常
* 编译异常: 调用了抛出异常的方法,不处理编译失败 (try throws)
* 运行异常: 抛出的异常是RuntimeException类,或者是他的子类
*
* 运行异常的特点:
* 方法内部抛出的异常是运行异常, new XXXException
* 方法的声明上,不需要throws语句,调用者,不需要处理
* 设计原因:
* 运行异常,不能发生,但是如果发生了,程序人员停止程序修改源代码
*
* 运行异常: 一旦发生,不要处理,请你修改源代码, 运行异常一旦发生,后面的代码没有执行的意义
*/
public class RuntimeExceptionDemo {
public static void main(String[] args) {
double d = getArea(-1);
System.out.println(d);
}
/*
* 定义方法,计算圆形的面积
* 传递参数0,或者负数,计算的时候没有问题
* 但是,违反了真实情况
* 参数小于=0, 停止程序,不要在计算了
*/
public static double getArea(double r){
if(r <= 0)
throw new RuntimeException("圆形不存在");
return r*r*Math.PI;
}
public static void function(){
int[] arr = {1,2,3};
//对数组的5索引进行判断,如果5索引大于100,请将5索引上的数据/2,否则除以3
//索引根本就没有
if(arr[5] > 100){
arr[5] = arr[5]/2;
}else{
arr[5] = arr[5]/3;
}
}
}
运行结果:
1.8 异常在方法重写中细节
继承后,在子类重写父类方法的时候,异常处理结论:
1. 父类的方法,如果抛出异常,子类重写后—可以不抛出异常
—也可以抛出异常,但是,如果子类要抛,抛出的异常不能大于父类的异常(大于,指的是继承关系)
2. 父类的方法,没有异常抛出,子类重写后也不能抛出异常。(父无子无)3. 如果子类中调用了抛出异常的方法,别无选择,只能try..catch处理。
Ctrl+1 自动生成try...catch
package day21.demo1;
/*
* 继承后,在子类重写父类方法的时候,异常处理
* 结论:
* 父类的方法,如果抛出异常,子类重写后
* 可以不抛出异常
* 也可以抛出异常,但是,如果子类要抛,抛出的异常不能大于父类的异常
* 大于,都指的是继承关系
*
* 父类的方法,没有异常抛出,子类重写后
* 也不能抛出异常
* 如果子类中调用了抛出异常的方法,别无选择,只能try..catch处理
*/
public class ExceptionDemo3 {
public static void main(String[] args) {
Fu f = new Zi();
f.function();
}
}
class Fu{
public void function(){
}
}
class Zi extends Fu{
public void function(){
try {
method();
} catch (Exception e) {
e.printStackTrace();
}
}
public void method()throws Exception{
}
}
1.9 异常中常用方法
在Throwable类中为我们提供了很多操作异常对象的方法,常用的如下:
(API是英译汉的,因此难免此处的“详细与简短”有所出入,以运行结果为准)
- getMessage方法:返回该异常的详细信息字符串,即异常提示信息
- toString方法:返回该异常的名称与详细信息字符串
- printStackTrace:在控制台输出该异常的名称与详细信息字符串、异常出现的代码位置
package day21.demo1;
/*
* Throwable类中的方法
* 三个方法,都和异常的信息有关系
* String getMessage() 对异常信息的详细描述 异常了!
* String toString() 对异常信息的简短描述 java.lang.Exception: 异常了!
* void printStackTrace() 将异常信息追踪到标准的错误流 异常信息最全,JVM默认调用方法也是这个方法
*/
public class ExceptionDemo4 {
public static void main(String[] args) {
try{
function();
}catch(Exception ex){
System.out.println(ex.getMessage());
System.out.println(ex.toString());
ex.printStackTrace();
}
}
public static void function() throws Exception{
throw new Exception("异常了!");
}
}
运行结果:
第二章 自定义异常
通过阅读异常源代码:发现java中所有的异常类,都是继承Throwable,或者继承Throwable的子类。这样该异常才可以被throw抛出。
说明这个异常体系具备一个特有的特性:可抛性:即可以被throw关键字操作。
并且查阅异常子类源码,发现每个异常中都调用了父类的构造方法,把异常描述信息传递给了父类,让父类帮我们进行异常信息的封装。
格式:
Class 异常名 extends Exception{ //或继承RuntimeException
public 异常名(){
}
public 异常名(String s){
super(s);
}
}
/*
* 自定义异常
* 继承Exception,或者继承RuntimeException
* 构造方法中,super将异常信息,传递给父类
*/
public class FuShuException extends RuntimeException{
public FuShuException(String s){
super(s);
}
public FuShuException(){}
}
public class ExceptionDemo {
public static void main(String[] args) {
int avg = getAvg(50,60,-70,80);
System.out.println(avg);
}
/*
* 传递成绩,计算成绩的平均数
* 成绩没有负数,需要抛出异常,停止运算
*/
public static int getAvg(int...source){
int sum = 0 ;
for(int s : source){
if( s < 0){
throw new FuShuException("成绩错误 "+s);
}
sum = sum + s;
}
return sum/source.length;
}
}
第三章 总结
异常:就是程序中出现的不正常的现象(错误与异常)
异常的继承体系:
Throwable: 它是所有错误与异常的超类(祖宗类)
|- Error 错误,修改java源代码
|- Exception 编译期异常, javac.exe进行编译的时候报错
|- RuntimeException 运行期异常, java出现运行过程中出现的问题
异常处理的两种方式:
1. 出现问题,自己解决 try…catch…finally
try{
可能出现异常的代码
} catch(异常类名 对象名){
异常处理代码
} finally {
异常操作中一定要执行的代码
}
2. 出现问题,别人解决 throws
格式:
修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2,...{}
public void method() throws Exception{}
异常分类
异常的根类是Throwable,其下有两个子类:Error与Exception,平常所说的异常指Exception。
- 严重错误Error,无法通过处理的错误
- 编译时异常Exception,编译时无法编译通过。如日期格式化异常
- 运行时异常RuntimeException,是Exception的子类,运行时可能会报错,可以不处理。如空指针异常
异常基本操作
1. 创建异常对象
2. 抛出异常
3. 处理异常:
- 捕获处理,将异常获取,使用try/catch做分支处理
try{
需要检测的异常;
} catch(异常对象) {
通常我们只使用一个方法:printStackTrace打印异常信息
}
- 声明抛出处理,出现异常后不处理,声明抛出给调用者处理。
- 方法声明上加throws 异常类名
注意:异常的处理,指处理异常的一种可能性,即有了异常处理的代码,不一定会产生异常。如果没有产生异常,则代码正常执行,如果产生了异常,则中断当前执行代码,执行异常处理代码。
异常注意事项
多异常处理
捕获处理:
1. 多个异常可以分别处理
2. 多个异常一次捕获多次处理
3. 多个异常一次捕获,采用同一种方式处理
声明抛出异常:
声明上使用,一次声明多个异常
运行时异常被抛出可以不处理。即不捕获也不声明抛出。
如果父类抛出了多个异常,子类覆盖父类方法时,只能抛出相同的异常或者是他的子集。
父类方法没有抛出异常,子类覆盖父类该方法时也不可抛出异常。此时子类产生该异常,只能捕获处理,不能声明抛出。
当多异常处理时,捕获处理,前边的类不能是后边类的父类。
自定义异常
如果Java没有提供你需要的异常,则可以自定义异常类。
定义方法:编译时异常继承Exception,运行时异常继承RuntimeException。