Java异常处理

目录

• Java异常处理
  • • 一、异常概述与异常体系结构
      • 1.1 Java 引入异常的原因：
      • 1.2 异常的概念：
      • 1.3 Java中的异常事件的分类：
    • 二、常见异常
    • 三、Java 异常处理机制：
      • 3.1 简介：
      • 3.2 Java 异常处理机制之一：try-catch-finally
      • 3.3 Java 异常处理机制之二：throws + 异常类型
    • 四、手动抛出异常（throw）
    • 五、用户自定义异常类

一、异常概述与异常体系结构

1.1 Java 引入异常的原因：

在进行项目开发的过程中，即使程序员把代码写得完美， 在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠代码能够避免的，比如：客户输入数据的格式，读取文件是否存在，网络是否始终保持通畅等等。

1.2 异常的概念：

在Java语言中，将程序执行中发生的不正常情况称为“异常” 。（开发过程中的语法错误和逻辑错误不是异常）

1.3 Java中的异常事件的分类：

• Error：Java 虚拟机无法解决的严重问题。

例如：JVM系统内部错误、资源 耗尽等严重情况。比如：StackOverflowError 和 OOM。一般不编写针对性的代码进行处理。

• Exception（狭义的异常，Java中所讲的异常处理即处理 Exception）：其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。

例如：空指针访问；试图读取不存在的文件；网络连接中断；数组角标越界。

• 对于这些错误，一般有两种解决方法：

  一是遇到错误就终止程序的运行。

  另一种方法是由程序员在编写程序时，就考虑到错误的检测、错误消息的提示，以及错误的处理。捕获错误最理想的是在编译期间，但有的错误只有在运行时才会发生。 所以捕获的异常也分为：编译时异常和运行时异常。

  比如：除数为0，数组下标越界等。

1.运行时异常：

是指编译器不要求强制处置的异常。一般是指编程时的逻辑错误，是程序员应该积极避免其出现的异常。java.lang.RuntimeException 类及它的子类都是运行时异常。

对于这类异常，可以不作处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响。

2.编译时异常：是指编译器要求必须处置的异常。即程序在运行时由于外界因素造成的一 般性异常。编译器要求 Java 程序必须捕获或声明所有编译时异常。

对于这类异常，如果程序不处理，可能会带来意想不到的结果。

• 所有的异常类是从 java.lang.Exception 类继承的子类。

  Exception 类是 Throwable 类的子类。除了Exception类外，Throwable 还有一个子类Error 。

二、常见异常

public class ExceptionTest {
	
	//******************以下是编译时异常***************************
	@Test
	public void test7(){
//		File file = new File(\"hello.txt\");
//		FileInputStream fis = new FileInputStream(file);
//		
//		int data = fis.read();
//		while(data != -1){
//			System.out.print((char)data);
//			data = fis.read();
//		}
//		
//		fis.close();
		
	}
	
	//******************以下是运行时异常***************************
	//ArithmeticException
	@Test
	public void test6(){
		int a = 10;
		int b = 0;
		System.out.println(a / b);
	}
	
	//InputMismatchException
	@Test
	public void test5(){
		Scanner scanner = new Scanner(System.in);
		int score = scanner.nextInt();
		System.out.println(score);
		
		scanner.close();
	}
	
	//NumberFormatException
	@Test
	public void test4(){
		
		String str = \"123\";
		str = \"abc\";
		int num = Integer.parseInt(str);
		
		
		
	}
	
	//ClassCastException
	@Test
	public void test3(){
		Object obj = new Date();
		String str = (String)obj;
	}
	
	//IndexOutOfBoundsException
	@Test
	public void test2(){
		//ArrayIndexOutOfBoundsException
//		int[] arr = new int[10];
//		System.out.println(arr[10]);
		//StringIndexOutOfBoundsException
		String str = \"abc\";
		System.out.println(str.charAt(3));
	}
	
	//NullPointerException
	@Test
	public void test1(){
		
		String str = \"abc\";
		str = null;
		System.out.println(str.charAt(0));
		
	}
}

三、Java 异常处理机制：

3.1 简介：

1. Java 提供的是异常处理的抓抛模型。

   过程一：\"抛\"：

   Java 程序的执行过程中如出现异常，会生成一个异常类对象，该异常对象将被提交给 Java 运行时系统，这个过程称为抛出（throw）异常。一旦抛出对象以后，其后的代码就不再执行。

   过程二：\"抓\"：

   可以理解为异常的处理方式：① try-catch-finally ② throws

2. 异常对象的生成：

   • 由虚拟机自动生成：程序运行过程中，虚拟机检测到程序发生了问题，如果在当前代码中没有找到相应的处理程序，就会在后台自动创建一个对应异常类的实例 对象并抛出——自动抛出

   • 由开发人员手动创建：Exception exception = new ClassCastException();——创建好的异常对象不抛出对程序没有任何影响，和创建一个普通对象一样。

3. 如果一个方法内抛出异常，该异常对象会被抛给调用者方法中处理。如果异常没有在调用者方法中处理，它继续被抛给这个调用方法的上层方法。这个过程将一直继续下去，直到异常被处理。 这一过程称为捕获(catch)异常。

   如果一个异常回到 main() 方法，并且 main() 也不处理，则程序运行终止。

3.2 Java 异常处理机制之一：try-catch-finally

1. 语法格式：

	try{
 		//	可能出现异常的代码
	}catch(异常类型1 变量名1){
 		//	处理异常的方式1
	}catch(异常类型2 变量名2){
		//	处理异常的方式2
	}catch(异常类型3 变量名3){
 		//	处理异常的方式3
	}
	....//	注意：省略号表示其他catch语句，而不是所有语句
	finally{
		//	一定会执行的代码（finally可选）
	}

2. 说明：

   （1）finally 是可选的。

   （2）使用 try 将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象的类型，去catch中进行匹配。且 try 里出现异常语句后的语句不再执行。

   （3）一旦 try 中的异常对象匹配到某一个 catch 时，就进入 catch 中进行异常的处理。一旦处理完成，就跳出当前的 try-catch 结构（在没有写finally的情况），继续执行其后的代码。

   （4）catch 中的异常类型如果没有子父类关系，则声明顺序无所谓。

   ​ catch 中的异常类型如果满足子父类关系，则要求子类一定声明在父类的提前声明。否则会报错。

   （5）常用的异常对象处理的方式：

   ​ ① String getMessage()

   ​ ② printStackTrace()

   （6）在 try 结构中声明的变量，再出了 try 结构以后，就不能再被调用.

   （7）try-catch-finally 结构可以嵌套。

   （8）try-catch-finally 结构一定是连在一起的。比如 try{} 、catch{}、finally{} 之间不能有其他的语句。

   （9）finally中声明的是一定会被执行的代码。即使catch中又出现异常了，try中有return语句，catch中有return语句等情况。

   （10）像数据库连接、输入输出流、网络编程Socket等资源，JVM是不能自动的回收的，我们需要自己手动的进行资源的释放。此时的资源释放，就需要声明在finally中。

3. 例子1：

public class FinallyTest {
	
	@Test
	public void test(){
		FileInputStream fis = null;
		try {
			File file = new File(\"hello.txt\");
			fis = new FileInputStream(file);
			
			int data = fis.read();
			while(data != -1){
				System.out.print((char)data);
				data = fis.read();
			}
			
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{	// try-catch-fianlly里可以嵌套使用
			try {
				if(fis != null)
					fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
	
	@Test
	public void testMethod(){
		int num = method();
		System.out.println(num);
	}
	
	public int method(){
		
		try{
			int[] arr = new int[10];
			System.out.println(arr[10]);
			return 1;
		}catch(ArrayIndexOutOfBoundsException e){
			e.printStackTrace();
			return 2;
		}finally{
			System.out.println(\"一定会被执行\");
			return 3;	// 当没有此语句是num输出为 2，当有此语句时输出为 3。
		}	
	}
	
}

体会：

使用try-catch-finally处理编译时异常，是得程序在编译时就不再报错，但是运行时仍可能报错。相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。

开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了。针对于编译时异常，我们说一定要考虑异常的处理。

例子2：

public class ReturnExceptionDemo {
	
    static void methodA() {
		try {
			System.out.println(\"进入方法A\");
			throw new RuntimeException(\"制造异常\");	// 创建了一个异常对象，但没被捕获和输出
		}finally {
			System.out.println(\"调用A方法的finally\");
		}
	}
    
	static void methodB() {
		try {
			System.out.println(\"进入方法B\");
			return;
		} finally {
			System.out.println(\"调用B方法的finally\");
		}
	}
    
	public static void main(String[] args) {
		try {
			methodA();		// 输出：进入方法A && 调用A方法的finally
		} catch (Exception e) {
			System.out.println(e.getMessage());	// 输出：制造异常
        }
        	methodB();	// 输出：进入方法B && 调用B方法的finally
        }
}

/*	运行结果：
进入方法A
用A方法的finally
制造异常
进入方法B
调用B方法的finally
*/

3.3 Java 异常处理机制之二：throws + 异常类型

1. 语法格式：

public void method() throws 异常类型{
		
}

2. 说明：

（1） \"throws + 异常类型\"写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足 throws 后异常类型时，就会被抛出。异常代码后续的代码，就不再执行！

（2）try-catch-finally：真正的将异常给处理掉了。

​ throws的方式只是将异常抛给了方法的调用者。并没有真正将异常处理掉。

（3）开发中如何选择使用 try-catch-finally 还是使用 throws ？

• 如果父类中被重写的方法没有 throws 方式处理异常，则子类重写的方法也不能使用 throws，意味着如果子类重写的方法中有异常，必须使用 try-catch-finally 方式处理。

• 执行的方法 a 中，先后又调用了另外的几个方法，这几个方法是递进关系执行的。我们建议这几个方法使用 throws 的方式进行处理。而执行的方法 a 可以考虑使用 try-catch-finally 方式进行处理。

四、手动抛出异常（throw）

注意：throw 后没有 s。

public class StudentTest {
	
	public static void main(String[] args) {
		try {
			Student s = new Student();
			s.regist(-1001);
			System.out.println(s);
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
	}
}


class Student{
	
	private int id;
	
	public void regist(int id) throws Exception {
		if(id > 0){
			this.id = id;
		}else{
//			System.out.println(\"您输入的数据非法！\");
			//	手动抛出异常对象
			throw new RuntimeException(\"您输入的数据非法！\");
//			或者 throw new Exception(\"您输入的数据非法！\");

		}	
	}
}

简述 throw 和 throws 的区别：

throw：表示抛出一个异常类的对象，生成异常对象的过程。声明在方法体内。

throws：属于异常处理的一种方式，声明在方法声明处。

五、用户自定义异常类

如何自定义异常类？

1. 继承于现有的异常结构：RuntimeException、Exception。

2. 提供全局常量：serialVersionUID。（序列化版本号，用来唯一识别自定义异常类）。

3. 提供几个重载的构造器。

4. 自定义异常最重要的是异常类的名字，当异常出现时，可以根据名字判断异常类型。

例子：

//自定义异常类
public class EcDef extends Exception {

	static final long serialVersionUID = -33875164229948L;	// 序列化版本号

	public EcDef() {	// 重载的构造器
	}

	public EcDef(String msg) {	// 重载的构造器
		super(msg);
	}
}
------------------------------------------------------------------------------------------------------------
public class EcmDef {
	public static void main(String[] args) {
		try{
			int i = Integer.parseInt(args[0]);
			int j = Integer.parseInt(args[1]);
			
			int result = ecm(i,j);
			
			System.out.println(result);
		}catch(NumberFormatException e){
			System.out.println(\"数据类型不一致\");
		}catch(ArrayIndexOutOfBoundsException e){
			System.out.println(\"缺少命令行参数\");
		}catch(ArithmeticException e){
			System.out.println(\"分母不能为0\");
		}catch(EcDef e){
			System.out.println(e.getMessage());
		}
		
	}
	
	public static int ecm(int i,int j) throws EcDef{
		if(i < 0 || j < 0){
			throw new EcDef(\"分子或分母不能负数\");
		}
		return i / j;
	}
}

来源：https://www.cnblogs.com/xiaozhao01/p/16534641.html
本站部分图文来源于网络，如有侵权请联系删除。