第九章(异常处理)

在程序设计和运行的过程中，发生错误是不可避免的。为此，Java 提供了异常处理机制来帮助程序员检查可能出现的错误，保证程序的可读性和可维护性。Java 中将异常封装到一个类中，出现错误时就会抛出异常。本章将讲解 Java 的异常处理机制。

               本章的知识架构及重难点如下：

异常处理
异常概述	异常的抛出和捕捉	java常见的异常类	自定义异常	在方法中抛出异常	运行时异常	异常的使用原则
	抛出异常		在方法中通过throw关键字抛出异常对象	throws关键字	RuntimeException异常的种类
	捕捉异常：异常捕捉结构由try，catch，finally3部分组成			throw关键字

一.异常概述

【1】0可以作为除数么？

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

结果如下

程序运行的结果报告发生了算数异常ArithmeticException(根据给出的错误提示可知，发生错误是因为在算术表达式“3/0”中，0作为除数出现)。系统不再执行下去，提前结束。这种情况就是所说的异常有许多异常的例子，如数组溢出等。Java 语言是一门面向对象的编程语言，因此异常在 Java 语言也是作为类的实例的形式出现的。当某一方法中发生错误时，这个方法会创建一个对象，并且把它专递给正在运行的系统。这个对象就是异常对象。通过异常处理机制，可以将非正常情况下的处理代马与程序的主逻辑分离，即在编写代码主流程的同时在其他地方处理异常。

自定义异常：

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

结果如下

 

二.异常的抛出与捕捉

1.抛出异常

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

【2】控制台输出“lili年龄是：20L”

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

结果如下

本实例报出的是 NumberFormatException (字符转换为数字)异常。提信息“lii 年龄是”已经输出，可知该句代码之前并没有异常，而变量 age 没有输出，可知程序在执行类型转换代码时已经终止。

自定义异常：

public class Thundering {//创建类
	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("数字格式异常");
	}finally {
		System.out.println("程序结束");
	}

}
}

结果如下

 

2.捕捉异常

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

语法如下：

try{

        //程序代码块

}

catch(Exceptiontype1 e){

        //对Exceptiontype1的处理

}

catch(Exceptiontype2 e){

        //对Exceptiontype2的处理

}......

finally{

        //程序代码块

}

1.  try-catch 语句块

【3】捕获例2中主方法抛出的异常

public class Take {//创建类
	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");//输出信息
	}
}

结果如下

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

2.finally语句块

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

1.在finally 语句块中发生了异常。

2.在前面的代码中使用了 System.exit0退出程序。

3.程序所在的线程死亡。

4.关闭CPU。

三.java常见的异常类

四.自定义异常

使用java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户只需继承Exception类即可自定义异常类。在程序中使用自定义异常类，大部分可分为以下几个步骤：

1.创建自定义异常类

2.在方法中通过throw关键字抛出异常对象

3.如果在当前抛出异常的方法中处理异常，可以使用try-catch语句块捕获并处理，否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。

【4】如何创建自定义异常

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

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

【5】自定义异常的抛出和捕捉

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("大于100，无法计算");
			throw new MyException("大于100，无法计算");//错误信息
		}
		return(num1 + num2)/2;//将参数的平均值返回
	}
	public static void main(String[] args) {//主方法
		try {//try语句块处理可能出现异常的代码
			int result = avg(132,56);//调用avg()方法
			System.out.println(result);//将avg()方法的返回值输出
		}catch(MyException e) {
			System.out.println(e);//输出异常信息
		}
	}
}

结果如下

五.在方法中抛出异常

若某个方法可能会发生异常，但不想在当前方法中处理这个异常，则可以使用throws、throw关键字在方法中抛出异常。

1.使用throws关键字抛出异常

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

【6】指明异常起源于何处

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关键字将异常抛给上一级后，如果不想处理该异常，可以继续向上抛出，但最终要有能处理该异常的代码。

2.使用throw关键字抛出异常

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

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

【7】创建自定义异常

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

【8】使用throw关键字捕捉自定义异常

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) {//处理ArithmeticException异常
			System.out.println("除数不能为0");//输出提示信息
		}catch(Exception e) {//处理其他异常
			System.out.println("程序发生了其他的异常");//输出提示信息
		}
	}

}

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

六.运行时异常

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

java异常类结构

Java 中提供了常见的 RuntimeException 异常，这些异常可通过 ty-catch 语句捕获，如图所示：

 RuntimeException 异常的种类

七.异常的使用原则

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

1.在当前方法声明中使用 y-catch 语句捕获异常。

2.一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类。

3.如果父类抛出多个异常，则覆盖方法必须抛出那些异常的一个子集，不能抛出新异常。