1.异常:是在运行时期发生的不正常情况.
1.2 在java中用类的形式对不正常情况进行了描述和封装对象.
描述不正常的情况的类,就称为异常类.
以前正常流程代码和问题处理代码相结合.
现在将正常流程代码和问题处理代码分离,提高阅读性.
其实异常就是java通过面向对象的思想将问题封装成了对象.
用异常类对其进行描述.
不同的问题用不同的类进行具体的描述.比如角标越界,空指针等等.
2.1 问题很多,意味着描述的类也很多.
将其共性进行向上抽取,形成了异常体系.
2.2 最终问题(不正常情况)就分成了两大类.
Throwable:无论是error还是exception问题,问题发生就应该可以抛出,让调用者知道并处理.
该体系的特点就在于Throwable及其说有子类都具有可抛性.
2.3 可抛性到底是什么呢?怎么体现可抛?
其实就是通过两个关键字来体现的.throw ,throws ,
凡是可以被这两个关键字所操作的类和对象都具备可抛性.
|--1.一般不可处理的.Error
特点:是由JVM抛出的严重性问题.
这种问题发生一般不针对性处理,直接修改程序.
|--2.可以处理的.Exception
该体系的特点:
子类的后缀名都是用其父类名作为后缀,阅读性强.
2.4 例子
class Test
{
int method(int[] arr, int index)
{
if(arr == null)
{
throw new NullPointerException("兄弟,数组的引用不能为空!");
}
if(index < 0)
{
throw new ArrayIndexOutOfBoundsException("数组下标为负数,兄弟,你真疯了!");
}
if(index >=arr.length)
{
throw new ArrayIndexOutOfBoundsException("数组下标越界,兄弟,你疯了么?");
}
return arr[index];
}
}
class ExceptionDemo
{
public static void main(String[] args)
{
int[] arr = new int[3];
Test t = new Test();
arr = null;
t.method(arr,3);
System.out.println(arr[4]);
}
}
3.自定义异常
对于角标是整数越界,可以用角标越界表示;
对于负数为角标的情况,准备用负数角标异常来表示.
负数角标这种异常在java中没有定义.
那就按照java异常的创造思想,面向对象,
将负数角标进行自定义,并封装成对象.
这种自定义的问题描述为自定义异常.
注意:
如果让一个类成为异常类,必须要继承异常体系,
因为只有成为异常体系的子类才有资格具备可抛性.
才可以被两个关键字所操作,throw,throws
3.2异常的分类:
1.编译时被检测异常:只要是Exception和其子类都是,除了特殊子类RuntimeException体系.
这种问题一旦出现,希望在编译时就进行检测,让这种问题有对应的处理方式.
这样的问题都可以针对性的处理.
2.编译时不检测异常(运行时异常):就是Exception中的RuntimeException和其子类.
这种问题的发生,无法让功能继续,运算无法进行,更多是因为调用的原因导致的或者引发了内部状态的改变导致的.
那么这种问题一般不处理,直接编译通过,在运行时,让调用者调用时的程序强制停止,让调用者对代码进行修正.
所以自定义异常时,要么继承Exception,要么继承RuntimeException
3.3 throw 和 throws的区别
1.throws 使用在函数上,用于声明.
抛出的是异常类,可以抛出多个,用逗号隔开.
2.throw 使用在函数内.
抛出的是异常对象.
3.4 自定义异常举例
class Person
{
private String name ;
Person(String name)
{
this.name = name;
}
String getName()
{
return this.name;
}
}
class Student extends Person
{
Student(String name)
{
super(name);//父类中有名字的方法,子类只用拿来用即可
}
}
class FuShuIndexException extends RuntimeException
{
FuShuIndexException(){}
FuShuIndexException(String msg)
{
super(msg);
}
}
class Test
{
void method(int[] arr, int index) //throws FuShuIndexException
{
if(arr == null)
{
throw new NullPointerException("兄弟,数组的引用不能为空!");
}
if(index < 0)
{
//throw new ArrayIndexOutOfBoundsException("数组下标为负数,兄弟,你真疯了!");
throw new FuShuIndexException("数组下标为负数,兄弟,你真疯了!");
}
if(index >=arr.length)
{
throw new ArrayIndexOutOfBoundsException("数组下标越界,兄弟,你疯了么?");
}
}
}
class ExceptionDemo2
{
public static void main(String[] args)// throws FuShuIndexException
{
Student s = new Student("张三");
System.out.println(s);
int[] arr = new int[3];
Test t = new Test();
t.method(arr,1);
System.out.println(arr[1]);
}
}
4.1 异常处理的捕捉形式:
这是可以对异常进行针对性处理的方式.
具体格式是:
try
{
//需要被检测异常的代码块.
}
catch(异常类 变量)//该变量用于接收发生异常对象.
{
//处理异常的代码
}
finally
{
//一定会被执行的代码
}
4.2 什么时候try什么时候throws
内部可以解决的问题就用try catch;
解决不了就抛出去让调用者处理.
4.3 异常处理原则:
1.
函数内容如果抛出需要检测的异常,那么函数上必须要声明.
必须在内容内使用trycatch捕捉,狗杂编译失败.
2.
如果调用了声明异常的函数,要么try,catch要么throws,否则编译失败.
3.什么时候用catch,什么时候throws呢?
功能内容可以解决,用catch.
解决不了,用throws告诉调用者,由调用者解决.
4.
一个功能如果抛出多个异常,那么调用时,必须有对应多个catch进行针对性的处理
内部有几个需要检测的异常,就抛出几个异常,抛出几个,就catch几个.
4.4 例子
class FuShuIndexException extends Exception//RuntimeException
{
FuShuIndexException(){}
FuShuIndexException(String msg)
{
super(msg);
}
}
class Test
{
public int method(int[] arr, int index) throws FuShuIndexException, NullPointerException, ArrayIndexOutOfBoundsException
{
if(arr == null)
{
throw new NullPointerException("兄弟,数组的引用不能为空!");
}
if(index < 0)
{
//throw new ArrayIndexOutOfBoundsException("数组下标为负数,兄弟,你真疯了!");
throw new FuShuIndexException("数组下标为负数,兄弟,你真疯了!");
}
if(index >=arr.length)
{
throw new ArrayIndexOutOfBoundsException("数组下标越界,兄弟,你疯了么?");
}
return arr[index];
}
}
class ExceptionDemo3
{
public static void main(String[] args)// throws FuShuIndexException
{
int[] arr = new int[3];
Test t = new Test();
try
{
int num = t.method(null,-3);
System.out.println("num: "+num);
}
catch(FuShuIndexException e)
{
// System.out.println("下标异常!!!");
// System.out.println("Message: "+e.getMessage());
//System.out.println(e.toString());
e.printStackTrace();//JVM默认的异常处理机制就是调用异常对象的这个方法.
}
catch(NullPointerException e)
{
e.printStackTrace();
}
catch(ArrayIndexOutOfBoundsException e)
{
e.printStackTrace();
}
catch(Exception e)//多catch的父类catch放在最后.
{
return;
// System.exit(0);//退出JVM
}
finally//通常关闭(释放)资源
{
}
System.out.println("over");
}
}
/*
try catch finally 代码块组合特点:
1. try catch finally
2. try catch (多个)当没有必要资源需要释放时,可以不用定义finally
3.try finally 异常无法直接catch处理,但是资源需要关闭.
void show() throws Exception
{
try
{
//开始资源
throw new Exception();
}
finally
{
//关闭资源
}
}
5.1 应用举例
毕老师用电脑上课
对象 老师 电脑
电脑 要能运行
老师 有名字 有一台电脑 要讲课
电脑可能出现蓝屏 冒烟 等状态.要处理这些异常的情况
蓝屏 电脑可以重启进行处理.
冒烟 要送给维修部门.
*/
class LanPingException extends Exception
{
LanPingException(String msg)
{
super(msg);
}
}
class MaoYanException extends Exception
{
MaoYanException(String msg)
{
super(msg);
}
}
class NoPlanException extends Exception
{
NoPlanException(String msg)
{
super(msg);
}
}
class Computer
{
private int state = 2;//0代表电脑正常运行
public void run() throws LanPingException,MaoYanException
{
//if for等语句要在函数体内才可以运行
if(state == 1)
{
throw new LanPingException("电脑蓝屏啦!!!");
}
if(state == 2)
{
throw new MaoYanException("电脑冒烟啦!!!");
}
System.out.println("电脑运行....");
}
public void restart()
{
state = 0;
System.out.println("电脑重启.....");
}
}
class Teacher
{
private String name;
private Computer cpt;
Teacher(String name)
{
this.name = name;
cpt = new Computer();
}
public void prelect() throws NoPlanException
{
try
{ cpt.run();
System.out.println(this.name+"讲课");
}
catch(LanPingException e)
{
System.out.println(e.toString());
cpt.restart();
this.prelect();
}
catch(MaoYanException e)
{
System.out.println(e.toString());
practice();
//可以对电脑进行维修.
throw new NoPlanException("课时进度无法完成, 原因:"+e.getMessage());
}
}
public void practice()
{
System.out.println("大家自由练习!!!");
}
}
class ExceptionDemo4
{
public static void main(String[] args)
{
Teacher t = new Teacher("毕老师");
try
{
t.prelect();
}
catch(NoPlanException e)
{
System.out.println(e.toString()+"......");
System.out.println("换人");
}
}
}
5.2 异常的转换
简单的说 就是把我们所不了解的异常转换为我们所了解认识的异常.
拿上面的例子来说 (设定一个老师绑定一台电脑)电脑烧坏是一个异常,但对于公司来说是陌生的异常他们没有处理的办法, 电脑烧坏也就是说老师不能讲课了,对于公司来说他们可以处理的是老师不能讲课的异常,他们可以换老师来讲课,也就说把电脑烧坏转化为老师不能讲课的异常,抛出这个异常让公司知道才能处理这个异常.
class NoAddException extends Exception
{
NoAddException(String msg)
{
super(msg);
}
}
void addData(Data d)
{
链接数据库
try{
添加数据,出现异常
throw SQLException();
}catch(SQLException e){
//处理代码
throw new NoAddException();
}
finally{
关闭数据库
}
}
5.3 异常的注意事项:
1:子类在覆盖父类方法时,父类的方法如果抛出了异常.
那么该子类的方法只能抛出父类的异常或者该异常的子类.
2:如果父类抛出多个异常,那么子类只能抛出父类异常的子集.
简单的说:子类覆盖父类只能抛出父类的异常或者子类或者子集.
注意:如果父类的方法没有抛出异常,那么子类覆盖时绝对不能抛,只能try.