• JAVA基础（十四）

    异常概述与异常体系结构

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

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

    Java程序在执行过程中所发生的异常事件可分为两类

            Error：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverflowError和OOM。一般不编写针对性的代码进行处理。

    1. package com.xxx.java;
    2.  
    3. public class ErrorTest {
    4. 	public static void main(String[] args) {
    5. 		//栈溢出java.lang.StackOverflowError
    6. //		main(args);
    7. 		
    8. 		
    9. 		//堆溢出java.lang.OutOfMemoryError
    10. //		Integer[] arr = new Integer[1024*1024*1024];
    11. 		
    12. 		
    13. 	}
    14. }

            Exception: 其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如：

                    空指针访问

                    试图读取不存在的文件

                    网络连接中断

                    数组角标越界

    对于这些错误，一般有两种解决方法：一是遇到错误就终止程序 的运行。另一种方法是由程序员在编写程序时，就考虑到错误的检测、错误消息的提示，以及错误的处理。

    捕获错误最理想的是在编译期间，但有的错误只有在运行时才会发生。 比如：除数为0，数组下标越界等

            分类：编译时异常和运行时异常

    异常的体系结构

    java.lang.Throwable

            -----java.lang.Error:一般不编写针对性代码进行处理

            -----java.lang.Exception：可以进行异常的处理

                    -----编译时异常(checked)

                            -----IOException

                                    -----FileNotFoundException

                            -----ClassNotFoundException

                    -----运行时异常(unchecked)

                            -----NullPointerException

                            -----ArrayIndexOutOfBoundException

                            -----ClassCastException

                            -----NumberFormatException

                            -----InputMismatchException

                            -----ArithmaticException

    1. package com.xxx.java;
    2.  
    3. import java.io.File;
    4. import java.io.FileInputStream;
    5. import java.util.Date;
    6. import java.util.Scanner;
    7.  
    8. import org.junit.Test;
    9.  
    10. public class ExceptionTest {
    11.  
    12. 	
    13. //	运行时异常
    14. 	// NullPointerException
    15. 	@Test
    16. 	public void test1() {
    17. //		int[] arr = null;
    18. //		System.out.println(arr[2]);
    19.  
    20. //		String str = null;
    21. //		System.out.println(str.charAt(0));
    22. 	}
    23.  
    24. 	// IndexOutOfBoundException
    25. 	@Test
    26. 	public void test2() {
    27. 		// ArrayIndexOutOfBoundException
    28. //		int[] arr = new int[2];
    29. //		System.out.println(arr[2]);
    30. 		// StringIndexOutOfBoundException
    31. //		String str = "abc";
    32. //		System.out.println(str.charAt(3));
    33. 	}
    34.  
    35. 	// ClassCastException
    36. 	@Test
    37. 	public void test3() {
    38. //		Object obj = new Date();
    39. //		String str = (String)obj;
    40. 	}
    41.  
    42. 	// NumberFormatException
    43. 	@Test
    44. 	public void test4() {
    45. 		String str = "abc";
    46. 		int num = Integer.parseInt(str);
    47. 	}
    48. 	
    49. 	//InputMismatchException
    50. 	@Test
    51. 	public void test5() {
    52. 		Scanner scanner = new Scanner(System.in);
    53. 		//输入类型不匹配时
    54. 		int score = scanner.nextInt();
    55. 		System.out.println(score);
    56. 	}
    57. 	
    58. 	//ArithmaticException
    59. 	@Test
    60. 	public void test6() {
    61. 		int a = 10;
    62. 		int b = 0;
    63. 		System.out.println(a / b);
    64. 	}
    65. 	
    66. 	//	编译时异常
    67. 	@Test
    68. 	public void test7() {
    69. 		File file = new File("hello.txt");
    70. 		FileInputStream fis = new FileInputStream(file);
    71. 		
    72. 		int data = fis.read();
    73. 		while(data != -1) {
    74. 			System.out.print((char)data);
    75. 			data = fis.read();
    76. 		}
    77. 		
    78. 		fis.close();
    79. 	}
    80. }

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

    在编写程序时，经常要在可能出现错误的地方加上检测的代码， 如进行x/y运算时，要检测分母为0，数据为空，输入的不是数据 而是字符等。过多的if-else分支会导致程序的代码加长、臃肿， 可读性差。因此采用异常处理机制。

    JAVA异常处理

    Java采用的异常处理机制，是将异常处理的程序代码集中在一起， 与正常的程序代码分开，使得程序简洁、优雅，并易于维护。

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

    过程一：“抛”：程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象，并将此对象抛出

    一旦抛出对象以后，其后的代码就不在执行。

    过程二：“抓”，可以理解为异常的处理方式：

    ①try-catch-finaly

    1.     try{
    2. 		//可能出现异常的代码
    3. 	}catch(异常类型1 变量名1) {
    4. 		//处理异常1的方式
    5. 	}catch(异常类型2 变量名2) {
    6. 		//处理异常2的方式
    7. 	}catch(异常类型3 变量名3) {
    8. 		//处理异常3的方式
    9. 	}
    10. 	......
    11. 	finally {
    12. 		//一定会执行的代码
    13. 	}

     注意

             1、finally是可选的

             2、使用try将可能出现异常的代码包裹起来，一旦出现异常，就会生成一个对应异常类的对象，根据此对象的类型，去catch中进行匹配

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

            4、catch中的异常类型如果没有子父关系，则谁声明在上面，谁声明在下面无所谓。

            catch中的异常类型如果存在子父关系，则要求子类一定声明在父类的上面。否则编译出错

            5、常用的异常对象处理的方式：①String        getMessage()        ②printStackTrace

            6、在try结构中定义的变量不可以在外面使用。

    体会：使用try-catch-finally处理编译时异常，使得程序在编译时就不再报错，但是运行时仍可能报错。

            相对于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现

    快速对代码使用try-catch包裹

    鼠标左键选中需要调试的代码——右键——Surround With——Try/catch Block 

    1. package com.xxx.java;
    2.  
    3. import java.io.File;
    4. import java.io.FileInputStream;
    5. import java.io.FileNotFoundException;
    6. import java.io.IOException;
    7.  
    8. import org.junit.Test;
    9.  
    10. public class ExceptionTest1 {
    11. 	@Test
    12. 	public void test1() {
    13. 		String str = "123";
    14. 		str = "abc";
    15. 		try {
    16. 			int num = Integer.parseInt(str);
    17. 			System.out.println("前面有异常，我不会执行");
    18. 		}catch (NullPointerException e) {
    19. 			System.out.println("出现空指针异常了");
    20. 		} catch (NumberFormatException e) {
    21. 			System.out.println("出现数字转换异常了");
    22. 			System.out.println(e.getMessage());
    23. 			e.printStackTrace();
    24. 		} catch (Exception e) {	//该结构若放在上方将报错，因为另外两个异常将不可达
    25. 			System.out.println("出现异常了");
    26. 		}
    27. 		
    28. 	}
    29. 	
    30. 	@Test
    31. 	public void test2() {
    32. 		try {
    33. 			File file = new File("hello.txt");
    34. 			FileInputStream fis = new FileInputStream(file);
    35. 			
    36. 			int data = fis.read();
    37. 			while(data != -1) {
    38. 				System.out.print((char)data);
    39. 				data = fis.read();
    40. 			}
    41. 			
    42. 			fis.close();
    43. 		} catch (FileNotFoundException e) {
    44. 				e.printStackTrace();
    45. 		}catch (IOException e) {
    46. 			
    47. 		}
    48. 	}
    49. }

    finally的使用

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

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

    try-catch总结

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

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

    1. package com.xxx.java;
    2.  
    3. import java.io.File;
    4. import java.io.FileInputStream;
    5. import java.io.FileNotFoundException;
    6. import java.io.IOException;
    7.  
    8. import org.junit.Test;
    9.  
    10. public class ExceptionTest1 {
    11. 	@Test
    12. 	public void test1() {
    13. 		String str = "123";
    14. 		str = "abc";
    15. 		try {
    16. 			int num = Integer.parseInt(str);
    17. 			System.out.println("前面有异常，我不会执行");
    18. 		}catch (NullPointerException e) {
    19. 			System.out.println("出现空指针异常了");
    20. 		} catch (NumberFormatException e) {
    21. 			System.out.println("出现数字转换异常了");
    22. 			System.out.println(e.getMessage());
    23. 			e.printStackTrace();
    24. 		} catch (Exception e) {	//该结构若放在上方将报错，因为另外两个异常将不可达
    25. 			System.out.println("出现异常了");
    26. 		}
    27. 		
    28. 	}
    29. 	
    30. 	@Test
    31. 	public void test2() {
    32. 		try {
    33. 			File file = new File("hello.txt");
    34. 			FileInputStream fis = new FileInputStream(file);
    35. 			
    36. 			int data = fis.read();
    37. 			while(data != -1) {
    38. 				System.out.print((char)data);
    39. 				data = fis.read();
    40. 			}
    41. 			
    42. 			fis.close();
    43. 		} catch (FileNotFoundException e) {
    44. 				e.printStackTrace();
    45. 		}catch (IOException e) {    //IO是FileNotFound的父类
    46. 			
    47. 		}
    48. 	}
    49. }

    ②throws

    “throw” + 异常类型写在方法的声明处，指明此方法执行时，可能会抛出的异常类型。

    一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后的异常类型时，就会被抛出。异常代码后续的代码就不在执行

    1. package com.xxx.java;
    2.  
    3. import java.io.File;
    4. import java.io.FileInputStream;
    5. import java.io.FileNotFoundException;
    6. import java.io.IOException;
    7.  
    8. public class ExceptionTest2 {
    9. 	public static void main(String[] args) throws IOException{
    10. 		try {
    11. 			method2();
    12. 		} catch (IOException e) {
    13. 			e.printStackTrace();
    14. 		}
    15. 		method3();
    16. 	}
    17. 	
    18. 	public static void method3() {
    19. 		try {
    20. 			method2();
    21. 		} catch (IOException e) {
    22. 			e.printStackTrace();
    23. 		}
    24. 	}
    25. 	
    26. 	public static void method2() throws IOException{
    27. 		method1();
    28. 	}
    29. 	
    30. 	public static void method1() throws FileNotFoundException,IOException{
    31. 		File file = new File("hello1.txt");
    32. 		FileInputStream fis = new FileInputStream(file);
    33.  
    34. 		int data = fis.read();
    35. 		while (data != -1) {
    36. 			System.out.print((char) data);
    37. 			data = fis.read();
    38. 		}
    39.  
    40. 		fis.close();
    41. 		System.out.println("不会执行");
    42. 	}
    43. }

    总结：

            try-catch-finally:真正的将异常给处理掉了

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

    方法重写的补充说明

    方法重写的规则：

            子类重写的方法抛出的异常类型不大于父类重写的方法抛出的异常类型

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

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

    1. package com.xxx.java;
    2.  
    3. import java.io.FileNotFoundException;
    4. import java.io.IOException;
    5.  
    6. public class OverrideTest {
    7. 	public static void main(String[] args) {
    8. 		display(new SubClass());	//若子类异常大于父类，display方法将无法处理该异常
    9. 	}
    10.  
    11. 	public static void display(SuperClass s) {
    12. 		try {
    13. 			s.method();
    14. 		} catch (IOException e) {
    15. 			e.printStackTrace();
    16. 		}
    17. 	}
    18. }
    19.  
    20. class SuperClass {
    21. 	public void method() throws IOException {
    22.  
    23. 	}
    24. }
    25.  
    26. class SubClass extends SuperClass{
    27. 	public void method() throws FileNotFoundException {
    28.  
    29. 	}
    30. }

    手动抛出异常

    关于异常对象的产生：

            ①        系统自动生成的异常对象

            ②        手动的生成一个异常对象，并抛出（throw）

    1. package com.xxx.java1;
    2.  
    3. import javax.management.RuntimeErrorException;
    4.  
    5. public class StudentTest {
    6. 	public static void main(String[] args) {
    7. 		Student s = new Student();
    8. 		try {
    9. 			s.regist(-1001);
    10. 		} catch (Exception e) {
    11. 			System.out.println(e.getMessage());
    12. 		}
    13. 	}
    14. }
    15.  
    16. class Student{
    17. 	private int id;
    18. 	
    19. 	public void regist(int id) throws Exception {
    20. 		if (id > 0) {
    21. 			this.id = id;
    22. 		}else {
    23. 			//之前的做法
    24. 			//System.out.println("您输入的数据非法！");
    25.  
    26. 			//可以手动抛出运行时异常
    27. //			throw new RuntimeException("您输入的数据非法！");
    28. 			//或抛出异常在方法后添加throws，再在调用时try catch处理
    29. 			throw new Exception("您输入的数据非法！");
    30. 		}
    31. 	}
    32.  
    33. 	@Override
    34. 	public String toString() {
    35. 		return "Student [id=" + id + "]";
    36. 	}
    37. 	
    38. }

    用户自定义异常类

    如何自定义异常类

            继承与现有的异常结构：RuntimeException、Exception

            提供全局常量：serialVersionUID

            提供重载的构造器

    1. package com.xxx.java1;
    2.  
    3. public class MyException extends RuntimeException {
    4. 	static final long serialVersionUID = -7032397190745766939L;
    5.  
    6. 	public MyException() {
    7.  
    8. 	}
    9.  
    10. 	public MyException(String msg) {
    11. 		super(msg);
    12. 	}
    13. }

    练习：判断程序的输出结果

    1. package com.xxx.java1;
    2.  
    3. public class ReturnExceptionDemo {
    4. 	static void methodA() {
    5. 		try {
    6. 			System.out.println("进入方法A");        //①
    7. 			throw new RuntimeException("制造异常");    //③
    8. 		} finally {
    9. 			System.out.println("用A方法的finally");    //②
    10. 		}
    11. 	}
    12.  
    13. 	static void methodB() {
    14. 		try {
    15. 			System.out.println("进入方法B");    //④
    16. 			return;
    17. 		} finally {
    18. 			System.out.println("调用B方法的finally");    //⑤
    19. 		}
    20. 	}
    21.  
    22. 	public static void main(String[] args) {
    23. 		try {
    24. 			methodA();
    25. 		} catch (Exception e) {
    26. 			System.out.println(e.getMessage());
    27. 		}
    28. 		methodB();
    29. 	}
    30.  
    31. }

    练习2

    编写应用程序EcmDef.java，接收命令行的两个参数，要求不能输入负数，计算两数相除。

    对 数 据 类 型 不 一 致 (NumberFormatException) 、 缺 少 命 令 行 参 数 (ArrayIndexOutOfBoundsException、 除0(ArithmeticException)及输入负数(EcDef 自定义的异常)进行异常处理。

    提示：

    (1)在主类(EcmDef)中定义异常方法(ecm)完成两数相除功能。

    (2)在main()方法中使用异常处理语句进行异常处理。

    (3)在程序中，自定义对应输入负数的异常类(EcDef)。

    (4)运行时接受参数 java EcmDef 20 10 //args[0]=“20” args[1]=“10”

    (5)Interger类的static方法parseInt(String s)将s转换成对应的int值。

            如：int a=Interger.parseInt(“314”);      //a=314;

    1. package com.xxx.exer;
    2.  
    3. public class EcmDef {
    4. 	public static void main(String[] args) {
    5. 		try {
    6. 			int i = Integer.parseInt(args[0]);
    7. 			int j = Integer.parseInt(args[1]);
    8. 			
    9. 			int result = ecm(i,j);
    10. 			System.out.println(result);
    11. 		} catch (NumberFormatException e) {
    12. 			System.out.println("数据类型不一致");
    13. 		} catch (EcDef e) {
    14. 			System.out.println(e.getMessage());
    15. 		} catch (ArrayIndexOutOfBoundsException e) {
    16. 			System.out.println("缺少命令行参数");
    17. 		} catch (ArithmeticException e) {
    18. 			System.out.println("除数不能为0");
    19. 		}
    20. 	}
    21. 	
    22. 	public static int ecm(int i, int j) throws EcDef{
    23. 		if(i < 0 || j < 0) {
    24. 			throw new EcDef("分子或分母为负数");
    25. 		}
    26. 		return i / j;
    27. 	}
    28. }
  • 相关阅读:
    【奇想星球】重磅！我们的AIGC共创社区平台上线了！
    面霸的自我修养：Java线程专题
    自动化邮件通知：批处理脚本的通讯增强
    责任链模式
    Win10系统备份的方法和步骤
    数据库基础——4.select语句
    大数据打造六维车险评估体系，律商风险再出发
    做抖音小店这几点都没搞懂，难怪你的店铺始终没有销量！
    概率论_概率公式中的分号(；)、逗号(,)、竖线(|) 及其优先级
    PHP文件导入msql显示出错怎么回事
  • 原文地址：https://blog.csdn.net/m0_56413004/article/details/126192120