Java throws

发表于 | 更新于 | 评论数： | 阅读次数：

写在开头

 异常是导致程序中断运行的一种指令流，如果不对异常进行正确的处理，则可能导致程序的中断执行，造成不必要的损失
 所以在程序的设计中必须要考虑各种异常的发生，并正确的做好相应的处理，这样才能保证程序正常的执行。
 今天我们说一下Java:异常处理

概述和分类

异常: Java代码在运行的过程中,出现了问题或者出现了错误
异常封装成异常类,代码出现了问题,创建一个异常类,告诉用户代码的问题出在什么地方,异常出现的原因(也是一个提醒)

异常的分类:
Throwable
Error : 错误, 代码发生了很严重的问题,解决方式,只能修改代码,Error的情况尽量避免
Exception: 异常,代码发生了错误,错误不严重,可以进行捕获或者是声明以及处理
RuntimeException : 运行时异常,不需要代码进行任何的处理,等着将错误显现出来
例如: NullPointerException ArrayIndexOutOfBoundsException
编译异常: 如果出现,代码必须要进行声明或者解决异常

所有的异常都是Exception的子类

Error错误发生的代码:

Exception异常发生的代码:

1
2
3
4
5
6
7
8
9
10
11
12
13

public class ErrorDemo {

	public static void main(String[] args) {
		
		// 1. 定义一个错误的代码  Error,只能改代码
		int[] i = new int[1024*1024*1024];
		
		// 2. Exception
		int[] i1 = {1,2,3,6,7};
		System.out.println(i1[10]);
	}
}

JVM默认的默认的异常处理机制

  1. 发生了一个异常,先检测一下,自己方法本身是否有处理这个异常
  2. 如果没有异常的处理方案,将这个异常抛给方法的调用者
  3. 如果所有的方法都没有处理这个异常,异常就到了JVM这里
  4. JVM接收到异常
    1) 将异常信息以红色字体打印到控制台上
    2) 代码停止运行

throws关键字抛出异常

throw: 表示抛出一个异常
语法格式:

throw new 异常的类名(可以写异常信息);

使用方式:

  1. throw 关键字写在方法的内部
  2. throw new Exception 或者 new Exception的子类
  3. throw抛出异常后,方法不能再继续执行了
  4. 方法内部,通过throw关键字抛出异常后,需要对这个异常进行解决(RuntimeException本身以及其子类异常除外)
    1) 异常的声明,自己不处理,等别人处理
    2) 进行异常的处理, try…catch

throw关键字的使用场景(实际工作中):

  1. 做输入项的校验,如果输入项不合法(不符合验证规则),交易就应该停止
    举例:
    if( !“QQ”.equals(name) ){
    throw new Exception(“用户名输入错误”);
    }
  2. 除了输入项之外,后台的逻辑中,需要终止代码的情况分支,也是通过throw来控制的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class ThrowExceptionDemo {

	public static void main(String[] args) {
		//int[] arr = {1,2,3};
		int[] arr = null;
		getArr(arr,3);
	}
	
	public static void getArr(int[] arr,int index) {
      // 如果数组为null,抛出空指针异常
		if(arr == null) {
			throw new NullPointerException("传入的数组不能为空");
		}
		
		// 对数组的指定索引元素取值,先判断这个索引存在才能进行取值
		if(index >= arr.length) {
	// 抛出异常,做控制,如果索引不存在,不能取值,throw执行后,方法不能继续执行
			throw new ArrayIndexOutOfBoundsException(index);
		}
		
		int a = arr[index];
		System.out.println(a);
	}
}

throws 关键字声明异常

throws: 在方法上面进行异常的声明,只做声明,不做处理,等着方法的调用者处理

语法格式:
修饰符 返回值类型 方法名(参数列表) throws 异常类名, 异常类名…{

}

使用说明:

  1. throws写在方法的声明上
  2. throws 后面的异常必须是Exception或者是Exception的子类
  3. 方法内部,抛出了多个异常,方法的声明上就需要将多个异常都声明出来,异常之间通过逗号分隔
  4. 如果多个异常之间具有子父类的继承关系,可以直接声明一个父类的异常即可
  5. 如果方法上有throws异常的声明,方法在被调用时,调用者必须要处理这个异常
    1) 如果声明的异常时RuntimeException 异常,那么不需要处理
    2) 如果声明的编译异常, 调用者必须进行处理
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

import java.io.FileNotFoundException;
import java.io.IOException;

public class ThrowsExceptionDemo {

	 // getFile方法的调用者main必须要处理方法声明的异常 FileNotFoundException和IOException
	// 任何方法都没有处理异常,都只是进行了异常的声明(只是抛出异常给调用者,自己不处理),所以最终到了JVM去处理
	public static void main(String[] args) throws FileNotFoundException,IOException{
		String fileName = "c:\\b.txt";
		getFile(fileName);
		getFileName(fileName);

	}
	
	// 异常的第一种处理方式: 在方法上声明异常,使用throws 关键字
	// FileNotFoundException : 编译异常,一定需要声明或者处理,本方法做的是异常的声明处理
	//方法内部,抛出了多个异常,方法的声明上就需要将多个异常都声明出来,异常之间通过逗号分隔
	public static void getFile(String fileName) throws FileNotFoundException,IOException{
		// 如果文件与 c:\\a.txt不匹配,就抛出"文件不存在异常"
		if(! "c:\\a.txt".equals(fileName)) {
			throw new FileNotFoundException("文件不存在");
		}
		
		// 如果fileName不是以excel为结尾,那么就抛出一个IOException,编译异常,必须声明或者处理
		if(!fileName.endsWith("excel")) {
			
			throw new IOException("文件格式不正确");
		}
		System.out.println("777777777");
	}
	
	// 4.如果多个异常之间具有子父类的继承关系,可以直接声明一个父类的异常即可
	// FileNotFoundException 就是 IOException下面的一个子类异常
	// IOException  io = new FileNotFoundException(String s);
	public static void getFileName(String fileName) throws IOException{
		// 如果文件与 c:\\a.txt不匹配,就抛出"文件不存在异常"
		if(! "c:\\a.txt".equals(fileName)) {

			throw new FileNotFoundException("文件不存在");
		}
		
		// 如果fileName不是以excel为结尾,那么就抛出一个IOException,编译异常,必须声明或者处理
		if(!fileName.endsWith("excel")) {
			
			throw new IOException("文件格式不正确");
		}
		
		System.out.println("777777777");
	}
}

异常的处理

try…catch 捕捉已成

try…catch: 异常的处理
语法结构:
try{ // 用于检测异常
// 可能会发生异常的代码
}catch(异常类 变量){// 用于捕获异常
// 如果发生了异常,针对异常的处理方式
}

说明:

  1. try中没有发生异常,catch不执行的,代码继续运行
  2. try检测出异常,进入到catch进行异常的捕获,但是先匹配catch中的异常是否与抛出的异常一致
    1) 一致,执行catch中的语句逻辑,代码从try…catch语句之后继续执行
    2) 不一致,catch中的语句不执行,JVM默认的处理机制
  3. try…catch中的变量作用域一定要注意,try中定义的变量,在catch中不能使用的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

public class TryCatchDemo {

	public static void main(String[] args) {
		int[] arr = {1,2,3};
		
		try {
			// 有可能会发生异常的代码
			int x = getArr(arr,5);
// 没有执行,getArr方法发生异常,直接跳转到catch中执行捕获逻辑
			System.out.println(x);
			
		}catch(ArrayIndexOutOfBoundsException ex) {
			System.out.println(ex);
		}
		System.out.println("Hello");
	}
	
	public static int getArr(int[] arr,int index) throws ArrayIndexOutOfBoundsException{
		
		if( index >= arr.length) {
			
	throw new ArrayIndexOutOfBoundsException(index+"索引在数组中不存在");
			
		}
		 int a = arr[index];
		 System.out.println(a);// 没有执行,throw抛出异常后,方法不再执行
		 return a; 
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
//多catch

/*说明:
1. try后面可以接多个catch,多个catch之间平等的存在
2. catch只能执行到其中的一个,一旦catch执行完毕,异常就处理完毕
3. try中抛出多少异常,catch就要捕获多少异常
4. catch捕获的多个异常类之间如果有继承关系,要求,子类要先进行捕获,父类后进行捕获*/

public class TryCatchDemo {

	public static void main(String[] args) {
		//int[] arr = {1,2,3};
		int[] arr = null;	
		int x = 0;
		try {
			// 有可能会发生异常的代码
			x = getArr(arr,5);
			System.out.println(x);
			
			// try中的方法抛出什么异常,catch就捕获什么异常
		}
		/*catch(Exception e) { // Exception e =  new NullPointerException("数组不能为null");
			
			e.printStackTrace();
		}*/
		
		catch(ArrayIndexOutOfBoundsException ex) {
			// 2.java.lang.ArrayIndexOutOfBoundsException: 5索引在数组中不存在
			//System.out.println(ex.toString());
			//System.out.println(ex.getMessage());//5索引在数组中不存在
			ex.printStackTrace();// 打印结果最详细,推荐使用
			System.out.println(x);
		}catch(NullPointerException ex) {// NullPointerException ex = new NullPointerException("数组不能为null");
			
			ex.printStackTrace();
			System.out.println("null执行了");
		}catch(Exception e) { // Exception e =  new NullPointerException("数组不能为null");
			
			e.printStackTrace();
			System.out.println("Exception执行了");
		}
		
		System.out.println("Hello");
	}
	
	public static int getArr(int[] arr,int index) 
throws ArrayIndexOutOfBoundsException,NullPointerException,Exception{
		
		if(arr == null) {
			
			throw new NullPointerException("数组不能为null");
		}
		
		if( index >= arr.length) {
			
			throw new ArrayIndexOutOfBoundsException(index+"索引在数组中不存在");
			
		}
		
		 int a = arr[index];
		 System.out.println(a);
		 return a;
		 
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/*try...catch...finally
语法格式:

try{// 检测异常

}catch(){// 捕获异常

}...finally{// 一定会被执行到的代码,除了在finally之前JVM关闭

}

说明: 
1. 无论try执行了还是catch执行了,执行完毕,都要去执行finally中的代码
2. 如果try或者catch中有return语句,在执行return之前,先执行finally中的代码
*/
public class TryCatchFinally {

	public static void main(String[] args) {
		int[] arr = {1,2,3};
		try {
			getArr(arr,2);
			return;
		} catch (Exception e) {//Exception e =  new ArrayIndexOutOfBoundsException(index+"索引在数组中不存在");
			e.printStackTrace();
		}finally {// 一定会被执行,上述代码,try在进行return之前,先执行finally中的代码,再执行return
			
			System.out.println("我是finally");
		}
		System.out.println("异常处理完毕");
	}
	// 方法里面有多个异常,可以直接抛出Exception异常
	public static int getArr(int[] arr,int index) 
			throws Exception{
		
		
		if(arr == null) {
			
			throw new NullPointerException("数组不能为null");
		}
		
		if( index >= arr.length) {
			
	throw new ArrayIndexOutOfBoundsException(index+"索引在数组中不存在");
			
		}
		
		 int a = arr[index];
		 System.out.println(a);
		 return a;	 
	}
}

晚安

 今天就到这里了，明天见，加油！

-------------本文结束感谢您的阅读-------------
0%