1.异常的概念
package cn.jxufe.java.chapter08.demo01; public class Test01ArithmeticException { public static void main(String[] args) { // TODO Auto-generated method stub division(30, 3); division(30, 0); } public static void division(int a, int b) { System.out.println("计算除法"); System.out.println("结果。。。" + a / b); } }
2.异常类
3.异常和错误的区别
异常：指程序在编译、运行期间发生了某种异常(XxxException)，我们可以对异常进行具体的处理。若不处理异常，程序将会结束运行。
错误：指程序在运行期间发生了某种错误(XxxError)，Error错误通常没有具体的处理方式，程序将会结束运行。Error错误的发生往往都是系统级别的问题，都是jvm所在系统发生的，并反馈给jvm的。我们无法针对处理，只能修正代码。
package cn.jxufe.java.chapter08.demo01; public class Test02ExceptionAndError { /* * Throwable * Exception 异常 感冒,阑尾炎 * 将异常处理掉,可以继续执行 * RuntimeException * Error 非典,艾滋,癌 * 必须修改程序 */ public static void main(String[] args) { int[] arr = new int[999999999];//错误，没有那么大的堆内存 System.out.println(arr[3]); } }
4.异常对象的产生和处理流程
5.抛出异常throw和throws
在编写程序时，我们必须要考虑程序出现问题的情况。比如，在定义方法时，方法需要接受参数。那么，当调用方法使用接受到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。
在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。那么，抛出一个异常具体如何操作呢？
- 1,创建一个异常对象。封装一些提示信息(信息可以自己编写)。
- 2,需要将这个异常对象告知给调用者。怎么告知呢？怎么将这个异常对象传递到调用者处呢？通过关键字throw就可以完成。throw 异常对象；
throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。
使用格式：
throw new 异常类名(参数);
例如： throw new NullPointerException("要访问的arr数组不存在"); throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");
声明：将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理（稍后讲解该方式），那么必须通过throws进行声明，让调用者去处理。
声明异常格式：
修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2… { }
package cn.jxufe.java.chapter08.demo01; public class Test03Throw { public static void main(String[] args) throws Exception { // TODO Auto-generated method stub int[] arr = {}; int temp = getArray(arr); } public static int getArray(int[] arr) throws Exception { // 对方法参数进行合法性的判断,进行判断是不是null if (arr == null) { // 抛出异常的形式,告诉调用者 // 关键字 throw throw new Exception("数组不存在"); } // 对数组进行判断,判断数组中,是不是有元素 if (arr.length == 0) { // 抛出异常的形式,告诉调用者,数组没有元素 throw new Exception("数组中没有元素"); } int i = arr[arr.length - 1]; return 2 * i; } }
6.try-catch-finally捕获异常
捕获异常格式： try { //需要被检测的语句。 } catch(异常类 变量) { //参数。 //异常的处理语句。 } finally { //一定会被执行的语句。 }
try：该代码块中编写可能产生异常的代码。
catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。
finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。
package cn.jxufe.java.chapter08.demo01; public class Test04TryCatchFinally { public static void main(String[] args) { // TODO Auto-generated method stub int[] arr = null; try { int i = getArray(arr); System.out.println(i); } catch (NullPointerException ex) { System.out.println("###" + ex); } catch (ArrayIndexOutOfBoundsException ex) { System.out.println("!!!!!!" + ex); } System.out.println("Game Over"); } /* * 定义方法,抛出异常 * 调用者使用try catch */ public static int getArray(int[] arr) throws NullPointerException, ArrayIndexOutOfBoundsException { // 对数组判空 if (arr == null) { // 手动抛出异常,抛出空指针异常 throw new NullPointerException("数组不存在"); } // 对数组的索引进行判断 if (arr.length < 3) { // 手动抛出异常,抛出数组的索引越界异常 throw new ArrayIndexOutOfBoundsException("数组没有3索引"); } return arr[3] + 1; } }
7.多个异常处理的细节
package cn.jxufe.java.chapter08.demo01; /* * 多catch写在一起 * 细节: * catch小括号中,写的是异常类的类名 * 有没有顺序的概念,有 * * 平级异常: 抛出的异常类之间,没有继承关系,没有顺序 * NullPointerException extends RuntimeException * NoSuchElementException extends RuntimeException * ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException extends RuntimeException * * 上下级关系的异常 * NullPointerException extends RuntimeException extends Exception * 越高级的父类,写在下面 */ public class Test05Catch { public static void main(String[] args) { // TODO Auto-generated method stub try { } catch (NullPointerException ex) { } catch (Exception ex) { } } public static void function(int a) throws NullPointerException, Exception { if (a == 0) { throw new NullPointerException(); } if (a == 1) { throw new Exception(); } } }
8.运行异常
package cn.jxufe.java.chapter08.demo01; import java.util.Scanner; /* * 异常分为编译异常和运行时期异常 * 编译异常: 调用了抛出异常的方法,不处理编译失败 (try throws) * 运行异常: 抛出的异常是RuntimeException类,或者是他的子类 * * 运行异常的特点: * 方法内部抛出的异常是运行异常, new XXXException * 方法的声明上,不需要throws语句,调用者,不需要处理 * 设计原因: * 运行异常,不能发生,但是如果发生了,程序人员停止程序修改源代码 * * 运行异常: 一旦发生,不要处理,请你修改源代码, 运行异常一旦发生,后面的代码没有执行的意义 */ public class Test06QuotientWtihException { public static void main(String[] args) { // TODO Auto-generated method stub Scanner input = new Scanner(System.in); System.out.println("enter two integers: "); int number1 = input.nextInt(); int number2 = input.nextInt(); try { int result = quotient(number1, number2); System.out.println(number1 + " / " + number2 + " is " + result); } catch (ArithmeticException e) { // TODO: handle exception System.out.println(e+"不能除以0"); } } public static int quotient(int number1, int number2) {//不用声明异常 if (number2 == 0) throw new ArithmeticException("Divisor cannot be zero");//ctrl+T查看继承关系：运行异常，不用声明异常 return number1 / number2; } }
运行异常的案例
package cn.jxufe.java.chapter08.demo01; public class Test07RuntimeException { public static void main(String[] args) { // TODO Auto-generated method stub double d = 0; try { d = getArea(-1); } catch (Exception e) { // TODO Auto-generated catch block } System.out.println(d); } /* * 定义方法,计算圆形的面积 * 传递参数0,或者负数,计算的时候没有问题 * 但是,违反了真实情况 * 参数小于=0, 停止程序,不要在计算了 */ public static double getArea(double r) throws Exception{ if(r <= 0) throw new Exception("圆形不存在"); return r*r*Math.PI; } }
这个例子说明，有些参数有问题，导致后面的程序无法计算了，那么就应该用RuntimeException。
package cn.jxufe.java.chapter08.demo01; public class Test07RuntimeException { public static void main(String[] args) { // TODO Auto-generated method stub double d = getArea(-1); System.out.println(d); } /* * 定义方法,计算圆形的面积 * 传递参数0,或者负数,计算的时候没有问题 * 但是,违反了真实情况 * 参数小于=0, 停止程序,不要在计算了 */ public static double getArea(double r) { if (r <= 0) throw new RuntimeException("圆形不存在"); return r * r * Math.PI; } }
9.使用异常的好处
package cn.jxufe.java.chapter08.demo01; import java.util.InputMismatchException; import java.util.Scanner; public class Test08MismatchException { public static void main(String[] args) { // TODO Auto-generated method stub Scanner input = new Scanner(System.in); boolean continueInput = true; System.out.println("enter an integer:"); do { try { int number = input.nextInt(); System.out.println("the number entered is " + number); continueInput = false; } catch (InputMismatchException e) { // TODO: handle exception System.out.println("try again : an integer is required "); input.nextLine(); //输入不合法可以连续输入 } } while (continueInput); System.out.println("输入完成。。。"); } }
10.从异常中获取信息
package cn.jxufe.java.chapter08.demo01; import com.sun.management.jmx.Trace; public class Test09Exception { public static void main(String[] args) { // TODO Auto-generated method stub try { System.out.print(sum(new int[] {1,2,3,4,5})); } catch (Exception e) { // TODO: handle exception e.printStackTrace(); System.out.println(" "+ e.getMessage()); System.out.println(" " + e.toString()); System.out.println(" Trace Info Obtained from getStackTrace"); StackTraceElement[] stackTraceElements = e.getStackTrace(); for (int i = 0; i < stackTraceElements.length; i++) { System.out.println("method " + stackTraceElements[i].getMethodName()); System.out.println("(" + stackTraceElements[i].getClassName()+":"); System.out.println(stackTraceElements[i].getLineNumber()+")"); } } } public static int sum(int[] list) { int result = 0; for (int i = 0; i <= list.length; i++) { //有一个<=的异常 result += list[i]; } return result; } }
11.异常在方法重写中的细节
- 子类覆盖父类方法时，如果父类的方法声明异常，子类只能声明父类异常或者该异常的子类，或者不声明。
例如： class Fu { public void method () throws RuntimeException { } } class Zi extends Fu { public void method() throws RuntimeException { } //抛出父类一样的异常 //public void method() throws NullPointerException{ } //抛出父类子异常 }
- 当父类方法声明多个异常时，子类覆盖时只能声明多个异常的子集。
例如： class Fu { public void method () throws NullPointerException, ClassCastException{ } } class Zi extends Fu { public void method()throws NullPointerException, ClassCastException { } public void method() throws NullPointerException{ } //抛出父类异常中的一部分 public void method() throws ClassCastException { } //抛出父类异常中的一部分 }
- 当被覆盖的方法没有异常声明时，子类覆盖时无法声明异常的。
例如： class Fu { public void method (){ } } class Zi extends Fu { public void method() throws Exception { }//错误的方式 }
举例：父类中会存在下列这种情况，接口也有这种情况
问题：接口中没有声明异常，而实现的子类覆盖方法时发生了异常，怎么办？
答：无法进行throws声明，只能catch的捕获。万一问题处理不了呢？catch中继续throw抛出，但是只能将异常转换成RuntimeException子类抛出。
interface Inter { public abstract void method(); } class Zi implements Inter { public void method(){ //无法声明 throws Exception int[] arr = null; if (arr == null) { //只能捕获处理 try{ throw new Exception(“哥们，你定义的数组arr是空的!”); } catch(Exception e){ System.out.println(“父方法中没有异常抛出，子类中不能抛出Exception异常”); //我们把异常对象e，采用RuntimeException异常方式抛出 throw new RuntimeException(e); } } } }
12.自定义异常
通过阅读异常源代码：发现java中所有的异常类，都是继承Throwable，或者继承Throwable的子类。这样该异常才可以被throw抛出。
说明这个异常体系具备一个特有的特性：可抛性：即可以被throw关键字操作。
并且查阅异常子类源码，发现每个异常中都调用了父类的构造方法，把异常描述信息传递给了父类，让父类帮我们进行异常信息的封装。
例如NullPointerException异常类源代码： public class NullPointerException extends RuntimeException { public NullPointerException() { super();//调用父类构造方法 } public NullPointerException(String s) { super(s);//调用父类具有异常信息的构造方法 } }
package cn.jxufe.java.chapter08.demo01; public class Test10OurClassException { public static void main(String[] args) { // TODO Auto-generated method stub int avg = getAvg(50, 60, -70, 80); System.out.println(avg); } /* * 传递成绩,计算成绩的平均数 * 成绩没有负数,需要抛出异常,停止运算 */ public static int getAvg(int... source) { int sum = 0; for (int s : source) { if (s < 0) { throw new FuShuException("成绩错误 " + s); } sum = sum + s; } return sum / source.length; } } /* * 自定义异常 * 继承Exception,或者继承RuntimeException * 构造方法中,super将异常信息,传递给父类 */ class FuShuException extends RuntimeException { public FuShuException(String s) { super(s); } public FuShuException() { } }
