异常处理

待我称王封你为后i 2021-11-16 13:22 444阅读 0赞

***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));  
\}

\}  
结果：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMzIxMzM2_size_16_color_FFFFFF_t_70]

出现了异常错误，除数不能为零。  
修改如下：  
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(“除数不能为零”);  
\}

结果：  
![在这里插入图片描述][20190728135027115.png]  
但是仍然存在问题，不应该让方法来终止程序，应该由调用者决定是否终止程序。也就是尽量不使用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)；  
\}

\}  
结果：

![在这里插入图片描述][20190728135046550.png]

这种防止异常的方法由人为的判断，调用对象无法得知是否发生异常  
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("除数不能为零");
    	}
    		
    }

结果：

![在这里插入图片描述][20190728135101421.png]  
上面代码中的 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:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMzIxMzM2_size_16_color_FFFFFF_t_70 1]  
系统错误（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.从异常中获取信息***

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMzIxMzM2_size_16_color_FFFFFF_t_70 2]  
上个图为虚拟机里的Trrowable类库方法。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMzIxMzM2_size_16_color_FFFFFF_t_70 3]

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() + ")");
    			}
    		}
    	}
    
    }

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

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());
    		
    	}
    
    }

结果：  
![在这里插入图片描述][20190728142513245.png]

***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”);  
\}

应该用如下代码替换：  
***if(refVar ! =null)  
System.out.println(refVar.toString());  
else  
System.out.println(“refVar id null”);***

[System.in]: http://System.in
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMzIxMzM2_size_16_color_FFFFFF_t_70]: /images/20211116/2cd754a6dca9471496fc1a22c88f6bd7.png
[20190728135027115.png]: /images/20211116/bf8dbdad105740419176531b020701fb.png
[20190728135046550.png]: /images/20211116/fc8fa96ba8e840eeb3f108c0f5662b90.png
[20190728135101421.png]: /images/20211116/24812b60f9894707a096e9ff6145a562.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMzIxMzM2_size_16_color_FFFFFF_t_70 1]: /images/20211116/357f6a5854834739a6fde7c5c5f42e4e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMzIxMzM2_size_16_color_FFFFFF_t_70 2]: /images/20211116/f87a1016c8694280bcbbde9edada9c6f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMzIxMzM2_size_16_color_FFFFFF_t_70 3]: /images/20211116/004bc68b6014471188a782db2176f91d.png
[20190728140936135.png]: /images/20211116/0a610bbc5b0d4a339c4a5f93bdf9270d.png
[20190728142513245.png]: /images/20211116/deb73e67b7784ea1b3ef518b08d2d93e.png