1,、异常-概述
异常:就是程序在运行时出现不正常情况。
异常由来:问题也是现实生活中一个具体的事物,
也可以通过java的类的形式进行描述,并封装成对象。
其实就是java对不正常情况进行描述后的对象体现,通过JVM异常处理机制。
对于问题的划分:两种:一种是严重的问题,一种非严重的问题。
对于严重的,java通过Error类进行描述。
对于Error一般不编写针对性的代码对其进行处理。
例:
class ExceptionDemo
{
public static void main(String[] args)
{
byte[] arr=new byte[1024*1024*190];
}
}
对于非严重的,java通过Exception类进行描述。
对于Exception可以使用针对性的处理方式进行处理。
例:
class Demo
{
int div(int a,int b)
{
return a/b;
}
}
class ExceptionDemo
{
public static void main(String[] args)
{
Demo d=new Demo();
int x=d.div(4,0);
System.out.println("x="+x);
System.out.println("over");
}
}
无论Error或者Exception都具有一些共性内容,
比如:不正常情况的信息,引发原因等。
Throwable(可抛,是所有异常的超类)
|--Error
|--Exception
Error类中的子类共性:末尾以Error结尾
Exception类中的子类共性:末尾以Exception结尾,疾病
2、异常-处理
java提供了特有的语句进行处理,针对Exception
try
{
需要被检测的代码;
}
catch(异常类 变量)
{
处理异常的代码:(处理方式)
}
finally
{
一定会执行的语句;
}
class Demo
{
int div(int a,int b)
{
return a/b;
}
}
class ExceptionDemo
{
public static void main(String[] args)
{
Demo d=new Demo();
try
{
int x=d.div(4,0);
System.out.println("x="+x);
}
catch(Exception e)//Exception e=new ArithmeticException();
{
System.out.println(e);
}
System.out.println("over");
}
}
对捕获到的异常对象进行常见方法操作。
e.getMessage();
e.toString();异常名称:异常信息
e.printStackTrace();
catch(Exception e)
{
System.out.println(e);
System.out.println(e.getMessage());
System.out.println(e.toString());
e.printStackTrace();//异常名称:异常信息,异常出现的位置。
//其实jvm默认的异常处理机制,就是在调用printStackTrace(),打印异常的堆栈跟踪信息。
}
3、异常-声明
throws Exception//在功能上通过throws的关键字声明了该功能有可能会出现问题。
class Demo
{
int div(int a,int b)throws Exception<span style="font-family:Microsoft YaHei;">//声明可能会出现问题</span>
{
return a/b;
}
}
class ExceptionDemo1
{
public static void main(String[] args)
{
Demo d=new Demo();
int x=d.div(4,1);
System.out.println(x);
System.out.println("over");
}
}
就是告诉你上面这个Demo类中的div方法可能会出现问题,要用try-catch()
4、多异常处理
对多异常处理,
1,声明异常时,声明更为具体的异常,这样处理的可以更具体。
函数发生异常,就立即结束。
2,对方声明几个异常,就对应有几个catch块。不要定义多余的catch块。
如果多个catch块中的异常出现继承关系,父类异常块在最下面。
建立在进行catch处理时,catch中一定要定义具体处理方式。
不要简单定义一句e.printStackTrace(),也不要简单就书写一条输出语句。
5、自定义异常
你们有发现,JAVA体系当中分为两大派,异常和错误。
异常有很多小弟,这些小弟的出现,是因为java将常见的问题进行封装。
比如算术异常,脚标异常进行封装。那么就有一个小问题,
因为项目中会出现特有的问题,而这些问题并未被java所描述并封装对象。
所以对于这些特有的问题可以按照java对问题封装的思想。
将特有的问题,进行自定义的异常封装。
需求:在本程序中,对于除数是-1,也视为是错误的是无法进行运算的。
那么就需要对这个问题进行自定义的描述。手动抛出。
当在函数内部出现了throw抛出异常对象,那么就必须要给对应的处理动作。
要么在内部try catch处理。
要么在函数上声明让调用者处理。
一般情况,在函数内出现异常,函数上需要声明。
class FuShuException extends Exception
{
}
class Demo
{
int div(int a,int b)throws FuShuException
{
if(b<0)
throw new FuShuException();//手动通过throw关键字抛出一个自定义异常对象。
return a/b;
}
}
class ExceptionDemo3
{
public static void main(String[] args)
{
Demo d=new Demo();
try
{
int x=d.div(4,-1);
System.out.println("x="+x);
}
catch(FuShuException e)
{
System.out.println(e.toString());
System.out.println("出现负数");
}
}
}
发现打印的结果中只有异常的名称,却没有异常的信息。
因为自定义的异常并未定义信息
如何定义异常信息呢?将以上文件修改
class FuShuException extends Exception
{
private String msg;
FuShuException(String msg)
{
this.msg=msg;
}
public String getMessage()
{
return msg;
}
}
class Demo
{
int div(int a,int b)throws FuShuException
{
if(b<0)
throw new FuShuException("出现了除数是负数的情况/by fushu");//手动通过throw关键字抛出一个自定义异常对象。
return a/b;
}
}
结果:
toString()调用getMessage()
简化:
class FuShuException extends Exception
{
FuShuException(String msg)
{
super(msg);
}
}
因为父类中已经把异常信息的操作都完成了,
所以子类只要在构造时,通过super语句将异常信息传递给父类,
那么就可以直接通过getMessage方法获取自定义异常信息。
抛出错误值:
class FuShuException extends Exception
{
private int value;
FuShuException(String msg,int value)
{
super(msg);
this.value=value;
}
public int getValue() //多定义了个getValue方法
{
return value;
}
}
class Demo
{
int div(int a,int b)throws FuShuException
{
if(b<0)
throw new FuShuException("出现了除数是负数的情况/by fushu",b);//手动通过throw关键字抛出一个自定义异常对象。
return a/b;
}
}
class ExceptionDemo3
{
public static void main(String[] args)
{
Demo d=new Demo();
try
{
int x=d.div(4,-3);
System.out.println("x="+x);
}
catch(FuShuException e)
{
System.out.println(e.toString());
//System.out.println("出现负数");
System.out.println("错误的负数是:"+e.getValue());//获取gerValue方法返回的值
}
}
}
自定义异常总结:
必须是自定义类继承Exception或Error或Throwable。
继承Exception原因:
异常体系有一个特点,异常类和异常对象都被抛出。
它们都具备可抛性,这个可抛性是Throwable这个体系中独有特点。
只有这个体系中的类和对象才可以被throws和throw
throws和throw的区别:
throws使用在函数上,
throw使用在函数内;
throws后面跟异常类。可以跟多个,用逗号隔开.
throw后面跟异常对象。