异常
异常:是在运行时期发生的不正常情况。在java中用类的形式对不正常情况进行了描述和封装对象。描述不正常的情况的类,就称为异常类。
以前正常流程代码和问题处理代码相结合,现在将正常流程代码和问题处理代码分离。提高阅读性.
其实异常就是java通过面向对象的思想将问题封装成了对象.用异常类对其进行描述。不同的问题用不同的类进行具体的描述。 比如角标越界。空指针等等。
问题很多,意味着描述的类也很多,将其共性进行向上抽取,形成了异常体系。
throwable体系的特点:
子类的后缀名都是用其父类名作为后缀,阅读性很强。
throw new arrayIndexOutofBondsException(“自定义抛出显示内容”)
对于角标是整数不存在,可以用角标越界表示,对于负数为角标的情况,准备用负数角标异常来表示。
负数角标这种异常在java中并没有定义过。那就按照java异常的创建思想,面向对象,将负数角标进行自定义描述。并封装成对象。
这种自定义的问题描述成为自定义异常。
注意:如果让一个类称为异常类,必须要继承异常体系,因为只有称为异常体系的子类才有资格具备可抛性。才可以被两个关键字所操作,throws throw
thorwable类所有异常和错误的超类,有两个子类error和exception,分别表示错误和异常。其中异常类Exception又分为运行时异常(RuntimeException)和检查异常(Checked Exception)。
两者的区别:Error和Exception
Error是程序无法处理的错误,比如OutOfMemoryError、ThreadDeath等。这些异常发生时,java虚拟机(JVM)一般会选择线程终止。
Exception是程序本身可以处理的异常,这种异常分两大类:运行时异常和非运行时异常。程序中应当尽可能去处理这些异常。
运行时异常和非运行时异常
运行时异常都是RuntimeException类及其子类异常,如NullPointerException、IndexOutOfBoundsException等,这些异常是不检查异常,程序中可以选择捕获处理,也可以不处理。这些异常一般是有程序逻辑错误引起的,程序应该从逻辑角度尽可能避免这类异常的发生。
非运行时异常是RuntimeException以外的异常,类型上属于Exception类及其子类。从程序角度讲是必须进行处理的异常,如果不处理,程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常,一般情况下自定义检查异常。
throws 和throw的区别。
throws使用在函数上。抛出的是异常类,可以抛出多个,用逗号隔开。
throw使用在函数内。抛出的是异常对象。
class FuShuIndexException extends Exception //自定义异常类必须继承异常体系才具有可抛性
{
FuShuIndexException()
{}
FuShuIndexException(String msg)
{
super(msg);
}
}
class Demo
{
public int method(int[] arr,int index)//throws NullPointerException//FuShuIndexException//声明抛出
{ //如果函数内发生异常,需要在函数内进行声明
if(arr==null)
throw new NullPointerException("数组的引用不能为空!");
if(index>=arr.length)
{
throw new ArrayIndexOutOfBoundsException("数组角标越界:"+index);
}
if(index<0)
{
throw new FuShuIndexException("角标为负!!");
}
return arr[index];
}
}
class ExceptionDemo3
{
public static void main(String[] args) //throws FuShuIndexException
{
int[] arr = new int[3];
Demo d = new Demo();
int num = d.method(null,-30);// 调用了声明异常的函数 需要抛出或者捕捉
System.out.println("num="+num);
System.out.println("over");
}
}
异常的处理
可以对异常进行针对性处理,无catch,不处理。能处理就try catch,不能处理就抛
如果try没有检测到异常,catch就不会运行
<span style="font-size:14px;"><strong>try
{
需要被检测的代码;//将被检测到的一场对象抛给catch
}
catch(异常类 变量) //该变量用于接收发生异常的对象
{
处理异常的代码;(处理方式)
}
finally
{
一定会执行的语句;
}</strong></span>
<strong><span style="font-size:18px;">使用示例</span></strong>
class FushuIndexException extends Exception
{
FushuIndexException(String msg)
{
super(msg);
}
}
class Demo
{
public int method (int[] arr,int index) throws FushuIndexException //此处声明抛出,交由catch处理
{
if (index<0)
{
throw new FushuIndexException("角标不能为负");
}
return arr[index];
}
}
class ExceptionDemo1
{
public static void main(String[] args) //throws FushuIndexException 此处不需要再抛出,因为给catch处理了
{
int[] arr= new int[3];
Demo d=new Demo();
try
{
int num=d.method(arr,-10);
System.out.println("num="+num);
}
catch (FushuIndexException e)//异常类,要做针对性处理,不建议使用Exception
{
System.out.println("Message"+e.getMessage());//返回此异常对象的字符消息(异常信息)
System.out.println("String"+e.toString());//异常名称:异常信息
e.printStackTrace();//jvm默认异常处理机制 打印此异常对象的 异常名称 异常信息 异常位置
System.out.println("负数角标异常");
} //log for java
System.out.println("over");
}
}
对捕获的异常对象进行常见方法操作
String getMessage(); 异常名称
toString() 异常名称: 异常信息
e.printStackTrace() 异常名称 信息 位置
其实jvm默认的异常处理机制,就是在调用printStackTrace方法。打印异常的堆栈的跟踪信息。
多catch
catch是用于给异常对象针对性处理,多catch最多只会执行一个,所以在定义参数列表的异常范围必须是从小到大,否则编译器会报错,例如(Exception e)是所有异常的根类,父类必须放在最后面
异常处理的原则:
1.函数中如果抛出了需要检测的异常,必须声明或捕捉,否则编译失败
2.如果调用到了声明异常的函数,必须throws或者try catch ,否则编译失败
3.能解决就catch,不能解决就用throws告诉调用者,由调用者解决
4.一个功能抛出了几个异常,调用时就必须对应多个catch针对性处理
finally{}
一定会执行的语句,除非退出虚拟机System.exit(0);
作用:关闭资源
try catch finally 代码块组合特点
try catch 当没有必要资源释放时,可以不用定义finally
try finally 异常无法直接catch处理,,但是资源需要被关闭
连接数据库示例
<span style="font-size:12px;"><strong>try{
添加数据,出现异常SQLException();
}
catch(SQLException e){
//处理代码
throw new NoAddException();
}
finally{
关闭数据库
}</strong></span>
异常的应用
异常转换和封装
能解决就解决,不能解决就抛出由调用者解决,多层调用要分清
练习:毕老师讲课
/*毕老师讲课
异常类
电脑 类
teacher类
主类
*/
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;
public void run() throws LanPingException,MaoYanException
{
if (state==1)
throw new LanPingException("蓝屏");
if (state==2)
throw new MaoYanException("冒烟");
System.out.println("正常运行");
}
public void resert()
{
state =0;
System.out.println("重启");
}
}
class Teacher
{
private String name;
private Computer comp;<strong>//类类型的参数</strong>
Teacher(String name)
{
this.name=name;
comp =new Computer();
}
void tea() throws NoPlanException
{
try
{
comp.run();
System.out.println(name+"讲课");
}
catch (LanPingException e)
{
System.out.println(e.toString());//<strong>toString()方法返回异常名称和异常信息</strong>
comp.resert();
tea();
}
catch(MaoYanException e)
{
System.out.println(e.toString());
test();
throw new NoPlanException("课程无法完成");
}
}
public void test()
{
System.out.println("自己练习");
}
}
class ExceptionTest1
{
public static void main(String[] args)
{
Teacher t = new Teacher("毕老师");
try
{
t.tea();
}
catch (NoPlanException e)
{
System.out.println("换人");
}
}
}
继承中异常的 注意事项
子类覆盖父类只能throws抛出父类的异常或者该异常的子类、子集,不能抛出父类异常以外的异常
如果父类方法没有抛出异常,那么子类覆盖时绝对不能抛,只能try
interface Inter
{
void function();
}
class D implements Inter
{
public void function()//throws Exception
{}
}
class A extends Exception
{
}
class B extends A
{
}
class C extends Exception
{
}
Exception
|--A
|--B
|--C
class Fu
{
void show()throws A
{}
}
class Test
{
void method(Fu f)//Fu f = new Zi();
{
try
{
f.show();
}
catch (A a)
{
}
}
}
class Zi extends Fu
{
void show()throws A,B//可以抛AB不能抛C,可以不抛
{
}
}
class
{
public static void main(String[] args)
{
Test t = new Test();
t.show(new Zi());
}
}
【个人小结】:
[1]可以直接手动throw系统(Exception体系)的异常对象,自定义输出的内容以提高阅读性
要注意是new一个异常对象!如果抛出已经存在的异常对象时可以不用new新对象
[2]如果自定义异常时必须定义异常类继承Exception或者RuntimeException
Exception需要在出现异常的函数上throws声明或者catch,如果继承了RuntimeException则不需要在函数上声明或者catch
[3]throws意味着问题的隐藏,throw的执行是把异常交给调用者或着系统来处理,抛出异常后同一区域后面的语句就执行不到了;catch就是在处理异常,所以catch后不需要在该函上声明throws该异常类了
[4]自定义异常类时需要用super()来明确调用父类Exception 中哪一个构造函数,一般是String类的构造函数
异常体系要做重点掌握,开发中会经常遇到