Java第九章 异常处理

异常概述

在Java中，这种在程序运行时可能出现的一些错误称为异常。异常是一个在程序执行期间发生的事件，它中断了正在执行的程序的正常指令流。

public class Baulk {//创建类Baulk
	public static void main(String[] args) {//主方法
		int result=3/0;//定义int型变量并赋值
		System.out.println(result);//将变量输出
	}
}

 

 程序运行的结果发生了算数异常

ArithmeticException（根据给出的错误提示可知，发生错误是因为在算数表达式“3/0”中，0作为除数出现）系统不在执行下去，提前结束。这种情况就是所说的异常。

public class Baulk {//创建类
 
	public static void main(String[] args) {//主方法
		try {
		int result=3/1;//定义int型变量并赋值
		System.out.println(result);//将变量输出
	
	}catch(ArithmeticException e) {
		System.out.println("出现算数异常");		
	}finally {
		System.out.println("程序结束");
	}
}
}

 

 

try：try语句块中包含可能出现异常的程序代码

catch：语句块用来获取异常信息

finally：程序代码块

异常的抛出与捕捉

在Java中的，如果某个方法抛出异常，既可以在当前方法中进行捕捉，而后处理该异常，也可以将异常向上抛出，交由方法调用者来处理。

抛出异常

异常抛出后，如果不做任何处理，程序就会被终止。例如，将一个字符串转换为整型。可以通过Integer类的 parseInt(方法来实现。但如果该字符串不是数字形式，parseInt)方法就会抛出异常，程序将在出现异常的位置终止，不再执行下面的语句。

public class Baulk {//创建类
 
	public static void main(String[] args) {//主方法
		
		String str="lili";//定义字符串
		System.out.println(str+"年龄是：");//输出的提示信息
		int age=Integer.parseInt("20L");//数据类型的转换
		System.out.println(age);//输出信息
}
	}

 

 

public class Baulk {//创建类
 
	public static void main(String[] args) {//主方法
		try {
		String str="lili";//定义字符串
		System.out.println(str+"年龄是：");//输出的提示信息
		int age=Integer.parseInt("20L");//数据类型的转换
		System.out.println(age);//输出信息
		}catch(NumberFormatException e) {
			System.out.println("出现数字格式异常");
		}catch(ArithmeticException e) {
			System.out.println("出现算数异常");
		
	}finally {
		System.out.println("程序结束");
	}
	}
	}

 

 

捕捉异常

Java语言的异常捕获结构由try、catch和finally3部分组成。其中，try语句存放的是可能发生异常的Java语句；catch语句块在try语句块之后，用来激发被捕获的异常；finally语句块是异常处理结构的最后执行部分，无论try语句块中的代码块如何退出，都将执行finally语句块。

try{
     //程序代码块
}
catch(Exceptiontype1 e){
     //对Exceptiontype1 的处理
}
catch(Exceptiontype2 e){
     //Exceptiontype2 的处理
}
…
finally{
      //程序代码块
}
  

通过异常处理器的语法可知，异常处理器大致分为try-catch语句块和finally语句块。

1.try-catch语句块

public class Baulk {//创建类
 
	public static void main(String[] args) {//主方法
		try {            //try语句块中包含可能出现异常的程序代码
		String str="lili";//定义字符串变量
		System.out.println(str+"年龄是：");//输出得信息
		int age=Integer.parseInt("20L");//数据类型的转换
		System.out.println(age);
		}catch(Exception e) {        //catch语句块用来获取异常信息
			e.printStackTrace();    //输出异常性质
	}
		System.out.println("program over");//输出信息
	}
	}

 

 

 由上看出程序仍然输出最后的提示信息，没有因为异常而终止。在上面代码中，将可能出现异常的代码用try-catch语句块进行处理，当try语句块中的语句发生异常时，程序就会跳转到catch语句块中执行，执行完catch语句块中的程序代码后，将继续执行catch语句块后的其他代码，而不会执行try语句块中发生异常语句后面的代码。由此可知，Java的异常处理是结构化的，不会因为一个异常影响整个程序的执行。

2.finally语句块

        完整的异常处理语句一定包含finally语句，无论程序中有无异常发生，并且无论之前的try-catch语句块是否顺利执行完毕，都会执行finally语句。但是，在以下4种特殊情况下，finally块不会被执行：

• 在finally语句块中发生了异常。
• 在前面的代码中使用了System.exit（）退出程序。
• 程序所在的线程死亡。
• 关闭CPU。

Java常见的异常类

在Java中，提供了一些异常类用来描述经常发生的异常。其中，有的需要程序员进行捕获处理或声明抛出，有的是由Java虚拟机自动进行捕获处理。

自定义异常

使用Java内置的异常类可以描述

1. 创建自定义异常类
2. 在方法中通过throw关键字抛出异常对象
3. 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句块捕获并处理，否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续继续下一步操作。
4. 在出现异常的方法的调用者中捕获并处理异常。

 创建自定义异常：

//创建异常
public class MyException extends Exception{//创建自定义异常，继承Exception类
    public MyException(String message) {//构造方法
        super(message);//父类构造方法
    }
}

字符串ErrorMessage是要输出的错误信息。若想抛出用户自定义的异常对象，要使用throw关键字

 自定义异常的抛出和捕捉：

带有int型参数的方法AVG（）

//使用异常
public class Tran {//创建类
	static int avg(int num1,int num2) throws MyException{//定义方法，抛出异常
		
		if (num1<0 ||num2<0) {                //判断方法中参数是否满足指定条件
			System.out.println("存在负数 ，无法计算");
			throw new MyException("存在负数 ，无法计算");//错误信息
		}
		if (num1>100 ||num2>100) {        //判断方法中参数是否满足指定条件
			System.out.println("大于一百 ，无法计算");//错误信息
		}
		return(num1+num2)/2;            //将参数的平均值返回
	}
	public static void main(String[] args) {    //主方法
		try {                //try语句块处理可能出现异常的代码
			int result=avg(-32,56);        //调用AVG（）方法
			System.out.println(result);    //将AVG（）方法的返回值输出
		}catch (MyException e) {    
			System.out.println(e);    //输出异常信息
		}
	}
 
}

 

 

在方法中抛出异常

使用throws关键字抛出异常

throws关键字通常被应用在声明方法时，用来指定方法可能抛出的异常。多个异常可使用逗号分隔。

 
public class Shoot {		//创建类
	static void pop()throws NegativeArraySizeException{
		//定义方法并抛出NegativeArraySizeException异常
		int []arr=new int[-3];//创建数组	
	}
	public static void main(String[] args) {//主方法
		try {			//try语句处理异常信息
			pop();			//调用pop（）方法
		}catch(NegativeArraySizeException e) {
			System.out.println("pop()方法抛出的异常");//输出异常信息
		}
 
	}
 
}

 

 

使用throws关键字将异常抛给上一级，如果不想处理该异常，可以继续向上抛出，但最终要有能够处理该异常的代码。

使用throw关键字抛出异常

        throw关键字通常用于方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即终止，它后面的语句都不执行。通过throw抛出异常后，如果想在上一级代码中捕获并处理异常，则需要在抛出异常的方法中使用throw关键字在方法的声明中指明要抛出的异常；如果要捕捉throw抛出的异常，则必须使用try-catch语句块。

        throw通常用来抛出用户自定义异常。

public class MyExceotion extends Exception{ //创建自定义异常类
 String message; //定义String类型变量
 public MyExceotion(String ErrorMessage) { //父类方法
  message = ErrorMessage;
 }
 public String getMessage() { //覆盖getMessage()方法
  return message;
 }
 
}

 

 
public class Captor { //创建类
 static int quotient(int x,int y)throws MyException{ //定义方法抛出异常
  if(y<0) { //判断参数是否小于0
   throw new MyException("除数不能是负数"); //异常信息
  }
  return x/y; //返回值
 }
 
 public static void main(String[] args) { //主方法
  try{ //try语句块包含可能发生异常的语句
   int result = quotient(3,-1); //调用方法quotient()
  }catch(MyException e) { //处理自定义异常
   System.out.println(e.getMessage()); //输出异常信息
  }catch(ArithmeticException e) { //处理ArithmeticExcption异常
   System.out.println("除数不能为0"); //输出提示信息
  }catch(Exception e) { //处理其他异常
   System.out.println("程序发生了其他的异常"); //输出提示信息
  }
 
 }
 
}

 

 上面的实例使用了多个catch语句来捕捉异常。如果调用quotient(3，-1)方法，将发生 MyException异常，程序跳转到catch (MyException e)语句块中执行；如果调用quotient(5.0)方法，会发生Arihmeti-cException异常，程序跳转到catch(ArithmeticException e)语句块中执行：如还有其他异常发生，将使用catch(Exception e)捕捉异常。由于Exception是所有异常类的父类，如果将catch(Exception e)语句块放在其他两个语句块的前面，后面的语句块将永远得不到执行，也就没有什么意义了，所以catch语句的顺序不可调换。

运行时异常

RuntimeException 异常是程序运行过程中抛出的异常。Java 类库的每个包中都定义了异常类,所有这些类都是 Throwable 类的子类。Throwable 类派生了两个子类，分别是 Exception 类和 Error类。Ero类及其子类用来描述 Java 运行系统中的内部错误以及资源耗尽的错误，这类错误比较严重。Exceptiot类称为非致命性类，可以通过捕提处理使程序继续执行。Exception 类又根据错误发生的原因分发RuntimeException 异常和除 RuntimeException 之外的异常。

Java 中提供了常见的 RuntimeException 异常，这些异常可通过 try-catch 语句捕获

异常的使用原则

Java 异常强制用户去考虑程序的强健性和安全性。异常处理不应用来控制程序的正常流程，其主要作用是捕获程序在运行时发生的异常并进行相应的处理。编写代码处理某个方法可能出现的异常时，可遵循以下几条原则:

• 在当前方法声明中使用try-catch 语句捕获异常。
• 一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类。
• 如果父类抛出多个异常，则覆盖方法必须抛出那些异常的一个子集，不能抛出新异常。