太简单了！这套Java异常处理的总结，80%的人都没看过

上一篇是分享的是《Java类与类之间的关系、Java内部类》，这篇分享的是《Java异常简介与Java异常处理》。

Java异常简介

1.类型转换异常：ClassCastException

2.算术异常： ArithmeticException

在java中, 把一些不正常现象进行了抽象, 形成了一些异常类型。

在Throwable类的getMessage()/printStackTrace()这两个方法,所有的异常都有。

编译时异常,也称受检异常是指在编译前必须进行预处理, 并不是说这个异常在编译阶段发生,所有的异常都是在运行阶段才可能发生. 就像楼道中必须有灭火器与消防栓, 如果没有这些设备, 就没有安全证, 没有这个安全证,企业就不能生产. 企业必须有火灾的预处理措施, 火灾现在并没有发生。

编译阶段进行语法检查, Java的语法有很多条, 其中一种语法是: 对于受检异常必须进行预处理。

package com.wkcto.chapter02.demo01;

/**

 * 运行时异常都是RuntimeException类的子类 

 * 	不需要进行预处理, 

 * 	通过规范的代码进行规避

 *

 */

public class Test01 {

	public static void main(String[] args) {

		int x = 10;

		int y = 2;

//		divide(x, y); 		//10/2=5

//		divide(10, 0);		//这一行产生了异常,导致了程序中断, 程序不再继续向下执行		

		divide22(x, y);

		divide22(10, 0);		

		System.out.println("main....end...");

	}	

	//定义方法,计算两个整数的商, 没有判断除数为0的情况

	public static void divide( int num1, int num2) {

		int result = num1/num2;

		System.out.println( num1 + "/" + num2 + "=" + result);

	}

	//定义方法,计算两个整数的商, 通过判断除数为0避免出现算术异常

	public static void divide22( int num1, int num2) {

		if ( num2 == 0  ) {

			System.out.println("除数不能为0");

			return ;			//结束方法的执行

		}

		int result = num1/num2;

		System.out.println( num1 + "/" + num2 + "=" + result);

	}

}
复制代码

package com.wkcto.chapter02.demo01;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

/**

 * 演示编译时异常

 * 		受检异常, 受控异常

 *

 */

public class Test02 {

	public static void main(String[] args) {

		

		//读取d:/abc.txt文件中的内容, 使用了FileInputStream类

		

		FileInputStream fis = new FileInputStream("d:/abc.txt");

		//SUN在定义FileInputStream构造方法时, 通过 throws关键字声明了FileNotFoundException异常,

		//这个异常就是受检异常, 即在定义方法时, 通过throws声明的异常

		//受检异常在编译前必须进行预处理, 否则编译语法报错

	}

}
复制代码

Java异常处理

● throws抛出处理

try…catch捕获处理

语法:

try{

对可能产生异常的代码进行检视

try代码块中的某条语句一旦产生了异常,程序就立即跳转到catch子句执行, try代码块后面的代码不再执行

try代码块中, 可能会有多条语句有受检异常需要预处理, 可以通过多个catch子句分别捕获

}catch( 异常类型1 e1){

捕获异常类型1的异常, 捕获了异常,在开发阶段, 一般的预处理方式就是把异常打印到屏幕上, 程序员可以根据异常信息进行程序调试

e1.printStackTrace(); //每个异常都有这个方法

}catch( 异常类型2 e2){

如果catch子句捕获的异常有继承关系, 如果想单独对异常进行预处理, 应该先捕获子异常, 再捕获父异常, 或者直接捕获一个父异常

}finally{

finally子句不管是否有异常产生,总是会执行

经常在finally子句中释放系统资源

}

package com.wkcto.chapter02.demo01;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

/**

 * 演示异常的捕获处理

 * 		如果没有捕获异常, 系统会中断,  对产生 的异常进行捕获处理后, 程序不会中断 ,会继续向下执行

 * 异常处理的作用:

 * 		提高程序的健壮性, 鲁棒性(Robust)

 * 

 *

 */

public class Test03 {

	public static void main(String[] args) {

		

		try{

			FileInputStream fis = new FileInputStream("d:/abc.txt");  //构造方法有受检异常FileNotFoundException需要预处理

			System.out.println("在当前程序与指定的文件之间建立了流通道, ");

			

			fis.read();		//read()方法有受检异常IOException需要预处理

			System.out.println("从文件中读取了一个字节");

			

			fis.close();	//close()方法有受检异常IOException需要预处理

			System.out.println("文件读取完后,需要关闭流通道");

		}catch (FileNotFoundException e) {

			// 捕获文件未找到异常

			e.printStackTrace(); 		//开发时,一般把异常打印到屏幕上

			//捕获了产生的异常, 程序没有中断, 还继续向下执行

		}catch (IOException e) {

			// 捕获IOException异常

			// FileNotFoundException 继承了 IOException, 如果需要单独处理, 应该先捕获子异常 ,再捕获父异常

			// 或者, 不需要单独处理时, 直接捕获父异常即可

		}

		

		System.out.println("main...end....");

	}

}
复制代码

finally子句总是会执行

package com.wkcto.chapter02.demo01;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

/**

 * finally子句

 * 	不管是否产生异常, finally子句总是会执行, 经常用来释放系统资源

 *

 */

public class Test04 {

	public static void main(String[] args) {

		

		FileInputStream fis = null; 

		try{			//try代码块,对可能产生异常的代码进行检视

			 fis = new FileInputStream("d:/abc.txt");  //构造方法有受检异常FileNotFoundException需要预处理

			System.out.println("在当前程序与指定的文件之间建立了流通道, ");

			

			fis.read();		//read()方法有受检异常IOException需要预处理

			System.out.println("从文件中读取了一个字节");			

						//	通过catch子句捕获产生的异常

		}catch (FileNotFoundException e) {

			// 捕获文件未找到异常

			e.printStackTrace(); 		//开发时,一般把异常打印到屏幕上

			//捕获了产生的异常, 程序没有中断, 还继续向下执行

		}catch (IOException e) {

			// 捕获IOException异常

			// FileNotFoundException 继承了 IOException, 如果需要单独处理, 应该先捕获子异常 ,再捕获父异常

			// 或者, 不需要单独处理时, 直接捕获父异常即可

		}finally {

			System.out.println("finally子句,不管是否产生异常,总是会执行, 经常在finally子句中释放系统资源");

			//可以在finally子句中关闭流通道

			if ( fis != null ) {

				try {

					fis.close();		//close()方法有受检异常IOException需要预处理

				} catch (IOException e) {

					e.printStackTrace();

				}	

				System.out.println("文件读取完后,需要关闭流通道");				

			}

		}

		

		System.out.println("main...end....");

	}

}	

复制代码

package com.wkcto.chapter02.demo01;

/**

 * finally总是会执行

 * 	1)try/catch/finally子句都不能单独使用, 可以try..catch.., 也可以try...finally, 也可以try...catch..finally

 * 	2)final/finalize/finally的区别

 *

 */

public class Test05 {

	public static void main(String[] args) {

		int num = mm(10);

		System.out.println( num ); 			//10

	}

	public static int mm( int xx ) { 		//xx = 10

		try {

			return xx;

		} finally {

			xx++;

		}

		/*

		 * 程序执行到return xx;语句时, 并没有立即执行return语句, 而是把xx变量的值保存起来

		 * 然后执行finally子句, xx的值加1变为了 11

		 * 最后再执行return语句, 返回的不是xx变量现在的值, 而保存的值10给返回了

		 */

	}

}

复制代码

throws抛出处理

package com.wkcto.chapter02.demo01;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

/**

 * throws抛出处理

 *

 */

public class Test06 {

	

	//在定义main()方法时,可以抛出异常, main的异常抛出给JVM

	//JVM默认的处理方式: 中断程序, 打印异常信息

//	public static void main(String[] args) throws FileNotFoundException {

	public static void main(String[] args)  {

		System.out.println("main方法中调用m1()方法");

		try {

			m1();		//抛出m1()抛出的异常, 这个异常不会继续上抛了, 程序也不会中断,继续向下执行

		} catch (FileNotFoundException e) {

			e.printStackTrace();

		}

		

		System.out.println("main方法结束....");

	}

	//如果m1()方法 在定义时通过throws声明了一个异常, 就是受检异常, 在调用m1()方法时也需要对该异常进行预处理

	//谁调用m1()方法, 谁负责处理该异常

	private static void m1() throws FileNotFoundException {

		System.out.println("m1方法开始执行, 调用了m2()方法 ");

		m2();   //在调用m2()方法, 需要对m2()的受检异常进行预处理

		System.out.println("m1方法结束 ......");

	}

	//在定义方法时, 如果方法体中的某条语句有受检异常需要预处理, 可以捕获处理, 还可以抛出处理

	//在方法的定义位置通过throws关键字声明抛出异常, 在m2()定义时通过throws声明的异常 就是受检异常

	//谁调用m2()方法, 谁负责处理该异常

	private static void m2() throws FileNotFoundException {

		System.out.println("m2方法调用 FileInputStream类的构造方法");

		FileInputStream fis = new FileInputStream("d:/abc.txt");  	//构造方法有受检异常需要预处理

		System.out.println("m2.结束");

	}

}
复制代码

异常处理可以进行捕获,也可以抛出, 如何选择?

● 在定义方法时, 如果方法体中某条语句有受检异常需要预处理, 可以选择捕获处理,也可以选择抛出处理。

● 在调用方法时, 如果被调用的方法有受检异常需要预处理, 一般情况下是进行捕获处理。

● 定义方法时,抛出的异常,是抛出给调用者, 通过抛出异常,提醒方法的调用者,可能有异常发生, 调用者需要对这个异常进行预处理

● 在定义方法时, 如果方法体中通过throw语句抛出了一个异常对象, 所在的方法应该通过throws声明该异常

上面就是《Java异常简介与Java异常处理》的分享，接下来为大家梳理《Java方法覆盖中的异常处理、Java异常在开发中的应用与Java数组的定义》。

也欢迎大家交流探讨，该文章若有不正确的地方，希望大家多多包涵。

你们的支持就是我最大的动力，如果对大家有帮忙给个赞哦~~~