异常处理-蒲公英云

1.异常概述
异常的类型：Error（致命的）,Exception（非致命的）以及必检和免检异常。
异常就是一种对象，表示阻止正常进行程序执行的错误或者情况。
异常是从方法中抛出的。方法的调用者可以捕获以及处理该异常。
一个简单的例子：

package exception;

import java.util.Scanner;

public class QuotientWithIf {
public static void main(String [] args) {
Scanner input = new Scanner(System.in);
System.out.println(“输入两个数:”);
int num1 = input.nextInt();
int num2 = input.nextInt();
System.out.println(num1 + “/” + num2 + “ is “ + (num1/num2));
}

}
结果：

在这里插入图片描述

出现了异常错误，除数不能为零。
修改如下：
package exception;

import java.util.Scanner;

public class QuotientWithIf {
public static void main(String [] args) {
Scanner input = new Scanner(System.in);
System.out.println(“输入两个数:”);
int num1 = input.nextInt();
int num2 = input.nextInt();
if(num2!= 0) {
System.out.println(num1 + “/” + num2 + “ is “ + (num1/num2));
}
System.out.println(“除数不能为零”);
}

}

结果：
在这里插入图片描述
但是仍然存在问题，不应该让方法来终止程序，应该由调用者决定是否终止程序。也就是尽量不使用main方法终止，main方法只调用。如下：
package exception;

import java.util.Scanner;

public class QuotientWithIf {
public static int quotient(int num1 ,int num2) {
if(num2==0) {
System.out.println(“除数不能为零”);
System.exit(1);
}
return num1/num2;
}
public static void main(String [] args) {
Scanner input = new Scanner(System.in);
System.out.println(“输入两个数:”);
int num1 = input.nextInt();
int num2 = input.nextInt();
int result = quotient(num1,num2);
System.out.println(num1 + “/” + num2 + “ is “ + result)；
}

}
结果：

在这里插入图片描述

这种防止异常的方法由人为的判断，调用对象无法得知是否发生异常
Java可以让一个方法抛出一个异常，该异常可以被调用者捕获和处理。
如下：
package exception;

import java.util.Scanner;

public class QuotientWithIf {
public static int quotient(int num1 ,int num2) {
if(num2==0) {
throw new ArithmeticException(“除数不能为零”);

}
    return num1/num2;
}
public static void main(String [] args) {
    Scanner input = new Scanner(System.in);
    System.out.println("输入两个数:");
    int num1  = input.nextInt();
    int num2 = input.nextInt();
    try {
        int result = quotient(num1,num2);
        System.out.println(num1  + "/" +  num2  +  " is "  +  result);
    }
    catch(ArithmeticException ex){
        System.out.println("除数不能为零");
    }
}

}

结果：

在这里插入图片描述
上面代码中的 throw new ArithmeticException();
throw语句的执行就是抛出一个异常。异常就是一个从异常类中创建的对象。
当异常被抛出的时候，正常的执行流程就被打断。抛出异常就是将异常从一个地方传递到另一个地方。
throw 语句类似方法的调用，但不同调用方法的是，它调用的是catch块，从某种意义上讲，catch就像带参数的方法定义，这些参数匹配抛出的值的类型。但是，不像方法，在执行完catch快之后，程序控制不返回到throw语句，而是执行到catch块后的下一条语句。

使用异常处理的优点：
使方法抛出一个异常给它的调用者，并由调用者处理该异常。如果没有该能力，那么被调用的方法就必须自己处理异常或者终止该程序。被调用的方法在不知道出错的情况下该做什么，这是库方法的一般情况。库方法可以检查除错误，但是只有调用者才知道出现错误时需要做些什么。异常处理最根本的优势就是将检测错误从处理错误中分离出来。

很多库方法都会抛出异常，一个简单的例子。
package exception;

import java.util.InputMismatchException;
import java.util.Scanner;

public class InputException {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
boolean continueInput = true;
do {
try {
System.out.println(“Enter an integer number:”);
int number =input.nextInt();
System.out.println(“The integer number is” + number);
continueInput = false;

}
        catch(InputMismatchException ex) {
            System.out.println("Try again.(Incorrect input: an integer is required");
            input.nextLine();
        }
    }
    while(continueInput);
}

}
结果：
Enter an integer number:
5.5
Try again.(Incorrect input: an integer is required
Enter an integer number:

5
The integer number is5

2.异常类型
异常是对象，而对象的采用都是用类来定义。异常的根类是java.lang.Throwable.
Throwable:
在这里插入图片描述
系统错误（error)是由虚拟机抛出的，用error类表示。Error类描述的是内部系统错误，很少发生。如果发生除了通知用户以及尽量稳妥的终止程序，几乎什么都不能做。
异常（Exception)使用Exception类来表示，它描述的是程序和外部环境所引起的错误，这些错误能够被捕获和处理
运行时异常（runtime exception)是用RuntimeException类表示的，它描述的是程序设计错误，例如，错误的类型转换，访问一个越界数组或者数值错误，运行时异常通常是由Java虚拟机抛出的。

3.异常的三种操作
（1）声明异常
在Java中当前执行的语句一定属于某个方法，Java解释器调用mian方法开始执行一个程序。每个方法都必须声明它可能抛出的必检异常的类型。
任何代码都可能发生系统错误和运行时错误，因此，Java不要求在方法中显示声明Error和RuntimeException,但是方法抛出的其他异常都必须在方法头中显示声明，这样方法的调用者会被告知有异常
如：
public void myMethod() throws IOException{}
关键字throws表明myMethod方法可能会抛出异常

（2）抛出异常
检测到错误的程序可以创建一个合适的异常类型的实例并抛出它。
如
IllegalArgumentException ex = new IllegalArgumentException(“Wrong Argument”);
throws ex;
注意，声明异常的关键字是throws ,抛出异常的关键字是throw

(3)异常的捕获
当抛出一个异常时，可以在try-catch块中捕获异常
如：
try{
satatements;
}
catch(Exception exVar1{
handle foe Ecception;
}

4.从异常中获取信息

在这里插入图片描述
上个图为虚拟机里的Trrowable类库方法。

package exception;
public class TestException {
    private static int sum(int [] list) {
        int result = 0;
        for(int i=0;i<list.length;i++) {
            result +=list[i];
        }
        return result;
    }
    public static void main(String[] args) {
        try {
            System.out.println(sum(new int[]{1,2,3,4,5}));
        }
        catch(Exception ex) {
            ex.printStackTrace();
            System.out.println("\n" + ex.getMessage());
            System.out.println("\n" + ex.toString());
            System.out.println("\nTrace InfoObtained from getStackTrace");
            StackTraceElement[] traceElements = ex.getStackTrace();
            for(int i=0;i<traceElements.length;i++) {
                System.out.println("method" + traceElements[i].getMethodName());
                System.out.println("(" + traceElements[i].getClassName() + ":");
                System.out.println(traceElements[i].getLineNumber() + ")");
            }
        }
    }
}

结果：
在这里插入图片描述
一个声明，抛出和不捕获异常的例子

package exception;
public class CircleWithException {
    private double radius;
    private static int numberOfObjects  =0;
    public double getRadius() {
        return radius;
    }
    public void setRadius(double newradius)throws IllegalArgumentException {
        if(newradius>=0) {
            radius = newradius;
        }
        else {
            throw new IllegalArgumentException("Radius cannot be negative");
        }
    }
    public static int getNumberOfObjects() {
        return numberOfObjects;
    }
    public CircleWithException() {
        this(1.0);
    }
    public CircleWithException(double newRadius) {
        // TODO Auto-generated constructor stub
        setRadius(newRadius);
        numberOfObjects++;
    }
    public double findArea() {
        return radius * radius* 3.14159;
    }
}
package exception;
public class TestCircleWithException {
    public static void main(String [] args) {
        try {
            CircleWithException c1 =new CircleWithException(5);
            CircleWithException c2 =new CircleWithException(-5);
            CircleWithException c3 =new CircleWithException(0);
        }
        catch(IllegalArgumentException ex) {
            System.out.println(ex);
        }
        System.out.println("Number of objects created:" + CircleWithException.getNumberOfObjects());
    }
}

结果：
在这里插入图片描述

5.finally子句
无论异常是否发生，finally子句都会被执行。
有时候，不论异常是否出现或者是否被捕获，都希望执行某些代码。所以用finally子句来达到这个目的。语法如下：
try{
statements;
}
catch(TheException ex){
handing ex;
}
finally{
finallyStatements;
}
注意事项：
***在使用try-catch块时，当处理不可预料处理的错误状况时应该使用它。不要用try-catch块处理简单的，可预料的情况。***比如：
try{
System.out.println(refVar.toString());
}
catch(NullPointerException ex){
System.out.println(“refVar id null”);
}