java基础篇——异常处理简述
异常处理简述
一 引言
1. 异常就是程序在运行时出现不正常情况；
2. 异常就是java对不正常情况进行描述后的对象的体现；
3. java中的异常分为两种情况，分别是：
严重的问题 ： java通过Error类进行描述；
非严重的问题：java通过Exception类进行描述；
4.两者的共性都是出现异常；
5.Error 和 Exception 是类Throwable 的子类
二 异常的处理
java提供了特有的语句进行处理
try
{
需要被检测的代码
}
catch(异常类 变量)
{
} finally{
}
例：
class Demo
{
int div(int number,int number1)
{
return number/number1 ;
}
}
class Test{
public static void main(String[] args)
{
Demo d = new Demo();
try {
int x = d.div(4,0)
System.out.println(x)
}
catch(Exception e)
{
System.out.println("输入的数据不合适");
}
finally
{
}
}
}
上述这个程序在执行时，会输出语句“输入的数据不合适”， 也就是说，当被检测代码出现异常时，这个异常信息会被catch拿到，然后处理
如果将int x = d.div(4,0)改成int x = d.div(4,1),则程序会正常执行，输出结果为 4
如果将catch代码块中改为下列输出语句，会出现相应的输出信息
catch(Exception e)
{
System.out.println("输入的数据不合适");
System.out.println(e.toString());
System.out.println(e.printStackTrace（）);
}
那么我们会有以下结论：
jvm默认的异常处理机制，就是在调用printStackTrace()方法；
其输出信息包括：异常名称，异常信息，异常出现的位置；
那么出现上述所列的异常也是不是不可能的，那么我们应该如何处理呢？
这里采用的方法是：
在定义类Demo的div方法时候，抛出一个异常信息，以使程序员在调用该方法时注意到；
class Demo
{
int div(int number,int number1)throws Exception
{
return number/number1 ;
}
}
那么既然我们采用这样的方式定义了这个功能，在对象调用该方法时，有两种处理方式：
第一种是：使用java提供的异常处理机制处理
class Test
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{
int x = d.div(4,0)
System.out.println(x)
}
catch(Exception e)
{
System.out.println("输入的数据不合适");
}
finally
{
}
}
}
在建立catch方法块中的信息时，一般不简单写一句输出语句，建议处理方式是将异常处理信息储存在一个文件中，供使用者查看；
第二种是: 在方法上将这个异常抛出，交给jvm处理
class Test
{
public static void main(String[] args)throws Exception
{
Demo d = new Demo();
int x = d.div(4,0)
}
}
*** 声明异常时，建议声明更为具体的异常，这样处理时可以更具体，可以查看API文档，查看Exception的子类来声明；
*** 一个方法可以声明多个异常，在调用该方法时候，有几个异常就对应有几个catch代码块，当然也不可以定义多余的代码块；
例如————
class Demo
{
int div(int number,int number1)throws AritheneticException,ArrayIndexOutOfBoundsExcepton
{
int[ ] arr = new int[number];
return number/number1 ;
System.out.println(arr[4]);
}
}
定义方法的时候 抛出两个异常信息；那么在调用方法中时，应该有两个cabch代码块进行异常处理；
class Test
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{
int x = d.div(4,0)
System.out.println(x)
}
catch(AritheneticException e)
{
System.out.println("输入的数据不合适");
}
catch(ArrayIndexOutOfBoundsExcepton e)
{
System.out.println("角标越界了");
}
finally
{
}
}
}
*** 如果在catch代码块中异常出现继承关系时候，父类的异常代码块放在最下面；
对于catch代码块中的处理信息：
catch(AritheneticException e)
{
System.out.println("输入的数据不合适");
}
catch(ArrayIndexOutOfBoundsExcepton e)
{
System.out.println("角标越界了");
}
与代码块
catch(Excepton e)
{
System.out.println("角标越界了");
}
两者的区别在于，后者无针对性，前者有针对性；
三 自定义异常
在项目中，会出现特有的异常，而这些异常未被java 所描述并封装成对象，所以对这些特有的问题可以按照java的对问题的封装的思想，将特有的问题进行自定义封装；
例如————
认为在除法过程中，除负数也是异常的，设计程序
首先自定义一个异常类：
class FuShuException extends Exception
{
FuShuException()
{
System.out.println("出现除数为负数的情况了");
}
FuShuException(String msg)
{
super(msg);
}
}
这里定义异常信息使用到了关键字super，是通过它将异常信息传给了父类，然后通过父类方法定义
使用该异常类处理信息
这里不能抛出该类异常信息，因数jvm不认识这个异常
class Demo
{
int div(int number,int number1)
{
if(number1<=0)
{
throw new FuShuException("除数无效");
}
return number/number1 ;
}
}
那么在调用该类方法时候，可以使用：
class Test
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{
int x = d.div(4,-1)
System.out.println(x)
}
catch(FuShuException e)
{
System.out.println(e.toString());
}
finally
{
}
}
}
四 自定义异常小节
*** 必须是自定义类继承Exception类
*** 异常类中有一个特点，因为异常类和异常对象都被抛出，他们都具备可抛性，这个可抛性是Throwable这个体系中独有的，所以要继承Exception类，只有这个体系中的类才可以被throw 和 throws
五 throw 和 throws的区别
1.throw 使用在函数内，throws使用在函数上；
2.throws后面跟着异常类，可以跟多个，用逗号隔开，
throw 后面跟着异常对象，只有一个；
六 RuntimeException 类
是Exception的一个子类
如果在函数内抛出该异常，函数上可以不声明，编译通过，但是运行会停止，
如果在函数上，调用者可以不进行处理，编译也可以通过，但是运行会停止，
之所以不在函数上声明，是因为不需要让调用者处理，当该异常发生时候，程序会发生停止，因为运行的时候，出现了无法继续运算的情况，希望程序停止后，程序员对代码进行修正；
例子————
class FuShuException extends RuntimeException
{
FuShuException()
{
System.out.println("出现除数为负数的情况了");
}
FuShuException(String msg)
{
super(msg);
}
}
在调用该方法时候，不需要声明；
class Demo
{
int div(int number,int number1)
{
if(number1<=0)
{
throw new FuShuException("除数无效");
}
return number/number1 ;
}
}
class Test
{
public static void main(String[] args)
{
Demo d = new Demo();
int x = d.div(4,-1)
System.out.println(x)
}
}
}
这个程序在编译时过会通，但是在运行时会停止。
七 异常分类
1.编译时被检测的异常
2.运行进行被检测的异常
八 异常中的finally模块
正常执行种异常处理后，finally方法块的代码一定会执行，常使用他关闭资源
如果在catch块中写入return
<span style="font-size:14px;">catch(Exception e)
{
System.out.println(e.toString());
return ；
}
finally
{
}</span>
执行语句catch后会继续执行finally方法块
九 异常处理常见的格式
第一种
try{
} catch(FuShuException e){
} finally{
}
第二种
try{ } catch(FuShuException e)
{ }
第三种
try
{ }
finally
{ }
十 异常处理在子类覆盖中的体现
1.子类在覆盖父类时，如果父类的方法抛出异常，那么子类的林秀炳方法只能抛出父类的异常或者该异常的子类
2.如果父类中抛出多个异常，那么子类在覆盖方法时，只能抛出父类的子类；
3 .如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出，如果子类方法发生了异常，就必须要进行try处理，绝对不可以抛出；
十一： 例题
问题，有一个和长方形，都可以获得面积，对于面积，如果出现非法数值，视为是面积出现问题
class Rec implement Shape
{
private double wid,len;
Rec(double wid,double len)
{
if(wid<=0||len<=0)
throw new NoValueException("数据不合格");
else
{
this . wid = wid ;
this . len = len ;
}
}
public void getArea()
{
System.out.println(wid*len);
}
}
class Test{
public static void main(String[] args){
Rec r = new Rec(4,5);
r. getArea();
}
}
七 异常分类
七 异常分类