JAVA 异常处理
异常处理格式
在Java 中使用 try....catch 进行异常的处理
try{
可能出现异常的语句
}catch(异常类 异常对象){
异常处理
}catch(异常类 异常对象){
异常处理
}catch(异常类 异常对象){
异常处理
}。。。
finally{
异常的出口;
}
package org.exceptiondemo;
public class ExceptionDemo02 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int i = 10;
int j = 0;
System.out.println("******* 计算开始 *******");
try{
System.out.println("计算结果："+i/j);
}catch(ArithmeticException e){
System.out.println("出现了数学异常："+e);
}
System.out.println("******* 计算结束 *******");
}
}
package org.exceptiondemo;
public class ExceptionDemo01{
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int i = 10;
int j = 0;
System.out.println("******* 计算开始 *******");
try{
System.out.println("计算结果："+i/j);
}catch(ArithmeticException e){
System.out.println("异常原因："+e);
}finally{
System.out.println("不管是否有异常，我都执行");
}
System.out.println("******* 计算结束 *******");
}
}
package org.exceptiondemo;
public class ExceptionDemo02{
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int i = 0 ;
int j = 0;
System.out.println("******* 计算开始 *******");
try{
i = Integer.parseInt(args[0]);
j = Integer.parseInt(args[1]);
System.out.println("计算结果："+i/j);
}catch(ArithmeticException e){
System.out.println("出现了数据学异常："+e);
}catch(NumberFormatException e){
System.out.println("输入的不是数字："+e);
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("输入的参数个数不对："+e);
}finally{
System.out.println("不管是否有异常，我都执行");
}
System.out.println("******* 计算结束 *******");
}
}
那么寻于本程序来讲，实际上还是有可能出现其他异常的。
异常处理流程
1. 对于java 来讲，每当程序中出现了异常，实际上都是产生了一个异常类的实例化对象
这种处理格式实际上非常类似于方法传参，只要参数类型匹配了，则就可以使用此catch进行处理
实际上异常处理的最大父类：Throwable，但是一般开发中不会使用此种方式处理，因为其下有两个子类
Error： Error 一般表示JVM错误，与程序无关
Exception：一般指的是程序中的错误，所以一般开发中如果要想进行程序的处理，其本上是使用此类表示.
一般来讲在程序捕获的时候不要出现Throwable,因为表示的范围太大了
package org.exceptiondemo;
public class ExceptionDemo02{
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int i = 0 ;
int j = 0;
System.out.println("******* 计算开始 *******");
try{
i = Integer.parseInt(args[0]);
j = Integer.parseInt(args[1]);
System.out.println("计算结果："+i/j);
}catch(ArithmeticException e){
System.out.println("出现了数据学异常："+e);
}catch(NumberFormatException e){
System.out.println("输入的不是数字："+e);
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("输入的参数个数不对："+e);
}catch(Exception e){
System.out.println("其它异常："+e);
}finally{
System.out.println("不管是否有异常，我都执行");
}
System.out.println("******* 计算结束 *******");
}
}
但是，在异常捕获的时候，有一个注意：捕获更细的异常需要放在捕获更粗的异常之前
package org.exceptiondemo;
public class ExceptionDemo02{
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int i = 0 ;
int j = 0;
System.out.println("******* 计算开始 *******");
try{
i = Integer.parseInt(args[0]);
j = Integer.parseInt(args[1]);
System.out.println("计算结果："+i/j);
}catch(Exception e){
System.out.println("出现了数据学异常："+e);
}finally{
System.out.println("不管是否有异常，我都执行");
}
System.out.println("******* 计算结束 *******");
}
}
throws 关键字
在程序的方法声明处可以使用throws 关键字，使用此关键字的最大好处：在方法中不处理任何的异常，而交给被调用处处理。
package org.exceptiondemo;
class Math{
public int div(int i,int j)throws Exception{
int temp = i/j;
return temp;
}
}
public class ExceptionDemo03 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Math mt = new Math();
try{
mt.div(10, 0);
}catch(Exception e){
System.out.println("异常："+e);
//e.printStackTrace(); 异常明细
}
}
}
package org.exceptiondemo;
class Math{
public int div(int i,int j)throws Exception{
int temp = i/j;
return temp;
}
}
public class ExceptionDemo03 {
/**
* @param args
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
Math mt = new Math();
mt.div(10, 0);
}
}
如果在主方法处使用了throws 关键字的话，则所有的异常交给最大的头：JVM进行处理
throw 关键字
在程序中可以使用throw 关键字人为抛出一个异常
在异常的处理中，实际上每次产生异常的时候都是产生了一个异常类的实例化对象。那么此时，也可以通过抛出异常对象的方式完成。
package org.exceptiondemo;
public class ExceptionDemo04 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
try{
throw new Exception("抛着玩"); //人为抛出
}catch(Exception e){
e.printStackTrace();
}
}
}
异常的标准格式
进入方法执行计算前要有输出
此方法执行完之后也要有输出
如果有异常，则交给被调用处处理
package org.exceptiondemo;
class Math1{
public int div(int i,int j)throws Exception{
int temp = 0;
System.out.println("计算前显示-------------");
try{
temp = i/j;
}catch(Exception e){
throw e;
}finally{
System.out.println("计算后显示-------------");
}
return temp;
}
}
public class ExceptionDemo05 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Math1 mt = new Math1();
try{
System.out.println(mt.div(10,0));
}catch(Exception e){
e.printStackTrace();
}
}
}
自定义异常
一个类只要继承了Exception则就表示一个自定义异常，当发现系统中提供的异常不够的时候就可以这样做
package org.exceptiondemo;
class MyException extends Exception{
public MyException (String msg){
super(msg);
}
}
public class MyExceptionDemo01 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
try{
throw new MyException("自定义异常");
}catch(Exception e){
e.printStackTrace();
}
}
}