参考文献

1. https://www.bilibili.com/video/BV1Kb411W75N?p=371

1. 异常概述与异常体系结构

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

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

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

  • Error: Java虚拟机无法解决的严重问题。如: JVM系统内部错误、资源耗尽等严重情况。比如: StackOverflowError和OOM。一般不编写针对性的代码进行处理。
  • Exception:其它因编程错误或偶然的外在因素导致的一般性问题,可以使用针对性的代码进行处理。例如:
    • 空指针访问
    • 试图读取不存在的文件
    • 网络连接中断
    • 数组角标越界

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

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

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

• 在Java中，每个异常都是一个对象，它是Throwable类或其它子类的实例。

1.1 运行时异常

• 是指编译器不要求强制处置的异常。一般是指编程时的逻辑错误，是程序员应该积极避免其出现的异常。java.lang.RuntimeException类及它的子类都是运行时异常。
• 对于这类异常，可以不作处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响。

1.2 编译时异常

• 是指编译器要求必须处置的异常。即程序在运行时由于外界因素造成的一般性异常。编译器要求Java程序必须捕获或声明所有编译时异常。
• 对于这类异常，如果程序不处理，可能会带来意想不到的结果。

2. 常见异常

  java.lang.Throwable
 * 		|----java.lang.Error:一般不编写针对性的代码进行处理
 * 		|----java.lang.Exception:可以进行异常处理
 * 			|----编译时异常(checked)
 * 				|----IOEXception
 * 					|----FileNotFoundException
 * 				|----ClassNotFoundException
 * 			|----运行时异常(unchecked)
 * 				|----NullPointerException
 * 				|----ArrayIndexOutOfBoundsException
 * 				|----ClassCaseException
 * 				|----NumberFormatException
 * 				|----InputMismatchException
 * 				|----ArithmaticException

• ArraylndexOutOfBoundsException
  
• NullPointerException
  
• ArithmeticException

• ClassCastException

3. 异常处理机制一: try-catch-finally

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

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

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

  • “抛”：程序在征程执行过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象,并将此对象抛出。一旦抛出对象以后，其后的代码就不再执行。
  • ”抓“：可以理解为异常的处理方式：① try-catch-finally ② throws

• Java程序的执行过程中如出现异常,会生成一个异常类对象,该异常对象将被提交给Java运行时系统,这个过程称为抛出(throw)异常。

• 异常对象的生成
  由虚拟机自动生成:程序运行过程中,虚拟机检测到程序发生了问题,如果在当前代码中没有找到相应的处理程序,就会在后台自动创建一个对应异常类的实例对象并抛出—自动抛出
  由开发人员手动创建: Exception exception = new ClassCastException();—创建好的异常对象不抛出对程序没有任何影响,和创建一个普通对象一样

3.1 异常的抛出机制

• 如果一个方法内抛出异常,该异常对象会被抛给调用者方法中处
  理。如果异常没有在调用者方法中处理,它继续被抛给这个调用
  方法的上层方法。这个过程将一直继续下去,直到异常被处理。
  这一过程称为捕获(catch)异常。
• 如果一个异常回到main()方法,并且main()也不处理,则程序运
  行终止。程序员通常只能处理Exception,而对Error无能为力。

3.2 try-catch-finally机制

• try

  捕获异常的第一步是用try{…}语句块选定捕获异常的范围，将可能出现异常的代码放在try语句块中。

• catch(Exceptiontype e)
  在catch语句块中是对异常对象进行处理的代码。每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。

  

• 捕获异常的有关信息

  • 与其它对象一样，可以访问一个异常对象的成员变量或调用它的方法。
    • getMessage()获取异常信息，返回字符串
    • printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。
      

• finally

  • 捕获异常的最后一步是通过finally语句为异常处理提供一个统一的出口，使得在控制流转到程序的其它部分以前，能够对程序的状态作统一的管理。
  • 不论在try代码块中是否发生了异常事件，catch语句是否执行，catch语句是否有异常，catch语句中是否有return，finally块中的语句都会被执行。
  • finally语句和catch语句是可选的

• 说明

    1.finally是可选的。
    
    2.使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象的类型，去catch中进行匹配。
    
    3.一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理。一旦处理完成，就跳出当前的 try-catch结构（在没有写finally的情况）。继续执行其后的代码。
    
    4.catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓。 
    catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类的上面。否则，报错
    
    5.常用的异常对象处理的方式： ① String  getMessage()    ② printStackTrace()
    
    6.在try结构中声明的变量，再出了try结构以后，就不能再被调用
    
    7.try-catch-finally结构可以嵌套  
    	  
    体会1：使用try-catch-finally处理编译时异常，使得程序在编译时就不再报错，但是运行时仍可能报错。相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。
    	      
    体会2：开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了。针对于编译时异常，我们说一定要考虑异常的处理。
  

3.3 不捕获异常时的情况

• 前面使用的异常都是RuntimeException类或是它的子类,这些类的异常的特
  点是:即使没有使用try和catch捕获, Java自己也能捕获,并且编译通过
  (但运行时会发生异常使得程序运行终止)。

• 如果抛出的异常是IOException等类型的非运行时异常,则必须捕获,否则编译错误。也就是说,我们必须处理编译时异常,将异常进行捕捉,转化为运行时异常。

  package pers.chh3213.exception20220101;
  
  import java.io.*;
  public class IOExp {
  	public static void main(String[] args) {
  	try {
  		FileInputStream in = new FileInputStream("atguigushk.txt");
  		int b;
  		b = in.read();
  		while (b!=-1) {
  			System.out.print((char) b);
  			b = in.read();
  		}
  		in.close();
  	}catch (IOException e) {
  		System.out.println(e);
  	} finally {
  	System.out.println(" It's ok!");
  	}
  	}
  }
  
  

3.5 try中有return时的情况

• 如果在try中return的情况下，程序会先把try中将要return的值先存到一个本地变量中。接下来去执行finally语句，最后返回的是存在本地变量中的值.
• 还有一点要注意的，当try和finally里都有return时，会忽略try的return，而使用finally的return。

4. 异常处理机制二: throws

• 声明抛出异常是Java中处理异常的第二种方式

  • 如果一个方法(中的语句执行时)可能生成某种异常，但是并不能确定如何处理这种异常，则此方法应显示地声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理。

• 在方法声明中用throws语句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。
  

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

• 关于异常对象的产生:① 系统自动生成的异常对象 ② 手动生成一个异常对象，并抛出(throw)

• 体会：try-catch-finally:真正的将异常给处理掉了。throws的方式只是将异常抛给了方法的调用者。 并没有真正将异常处理掉。

  package pers.chh3213.exception20220101;
  
  import java.io.*;
  public class ThrowsTest {
  	public static void main(String[] args) {
  	ThrowsTest t = new ThrowsTest();
  	try {
  		t.readFile();
  	} catch (IOException e) {
  		e.printStackTrace();
  		}
  	}
  	public void readFile()throws IOException{
  		FileInputStream in = new FileInputStream ("atguigushk.txt");
  		int b;
  		b = in.read();
  		while (b !=-1) {
  			System.out.print((char) b);
  			b= in.read();
  		}
  	in.close();
  	}
  }
  

  

4.1 重写方法声明抛出异常的原则

• 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型。在多态的情况下,对methodA()方法的调用-异常的捕获按父类声明的异常处理。
  
• 如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，意味着如果子类重写的方法中有异常，必须使用try-catch-finally方式处理。
• 执行的方法a中，先后又调用了另外的几个方法，这几个方法是递进关系执行的。则建议这几个方法使用throws的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理。

5. 手动抛出异常: throw

• Java异常类对象除在程序执行过程中出现异常时由系统自动生成并抛出，也可根据需要使用人工创建并抛出。

  • 首先要生成异常类对象，然后通过throw语句实现抛出操作(提交给Java运行环境)

    IOException e = new IOException();
    throw e;
    

  • 可以抛出的异常必须是Throwable或其子类的实例。下面的语句在编译时将会产生语法错误

    throw new String("want to throw");
    

• 示例

package pers.chh3213.exception20220101;

public class StudentTest {
	public static void main(String[] args) {
		try {
			Student s = new Student();
//		s.regist(1001);
			s.regist(-1001);
			System.out.println(s);
		} catch (Exception e) {
//			e.printStackTrace();
			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("您输入的数据非法！");
			
		}
	}

	@Override
	public String toString() {
		return "Student [id=" + id + "]";
	}
	
}

6. 用户自定义异常类

• 一般地，用户自定义异常类都是RuntimeException的子类。
• 自定义异常类通常需要编写几个重载的构造器。
• 自定义异常需要提供serialVersionUID
• 自定义的异常通过throw抛出。
• 自定义异常最重要的是异常类的名字，当异常出现时，可以根据名字判断异常类型。

6.1 如何自定义异常类

• 用户自己的异常类必须继承现有的异常类RuntimeException 、Exception

• 提供全局常量：serialVersionUID

• 提供重载的构造器

• 示例

  package pers.chh3213.exception20220101;
  
  class MyException extends Exception {
  	static final long serialversionUID = 13465653435L;
  	private int idnumber;
  	public MyException(String message, int id) {
  		super (message);
  		this.idnumber = id;
  	}
  	public int getId(){
  		return idnumber;
  	}
  }
  
  public class MyExpTest {
  	public void regist(int num) throws MyException {
  		if (num <0)
  		throw new MyException("人数为负值,不合理", 3);
  		else
  		System.out.println("登记人数" +num);
  	}
  	public void manager() {
  		try {
  			regist(-1);
  		} catch (MyException e) {
  			System.out.println("登记失败,出错种类" + e.getId());
  		}
  		finally {
  			System.out.println("本次登记操作结束");
  		}
  		
  	}
  	public static void main(String args[]) {
  		MyExpTest t = new MyExpTest();
  		t. manager();
  	}
  }
  

6.2 练习

• 练习1：以下代码输出结果为

  package pers.chh3213.exception20220101;
  
  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();
  		} catch (Exception e) {
  			// TODO: handle exception
  			System.out.println(e.getMessage());
  		}
  		methodB();
  	}
  }
  

    输出为：
    进入方法A
    用A方法的finally
    制造异常
    进入方法B
    调用B方法的finally
  

• 练习2

  package pers.chh3213.exception20220101;
  import java.util.*;
  public class EcmDef {
  	public static void main(String[] args) {
  		try {
  			int i = Integer.parseInt(args[0]);
  			int j = Integer.parseInt(args[0]);
  			
  			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;
  	}
  }
  class EcDef extends Exception {
  
  	static final long serialVersionUID = -33875164229948L;
  
  	public EcDef() {
  		
  	}
  
  	public EcDef(String msg) {
  		super(msg);
  	}
  }
  
  
  
  

7. 总结

8. 练习

• 运行时异常与一般异常有何异同

  答：异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

• Java中的异常处理机制的简单原理和应用

  答：当JAVA程序违反了JAVA的语义规则时，JAVA虚拟机就会将发生的错误表示为一个异常。 违反语义规则包括2种情况。一种是JAVA类库内置的语义检查。例如数组下标越界,会引发IndexOutOfBoundsException;访问null的对象时会引发NullPointerException。另一种情况就是JAVA允许程序员扩展这种语义检查，程序员可以创建自己的异常，并自由选择在何时用throw关键字引发异常。所有的异常都是java.lang.Thowable的子类。

• 垃圾回收的优点和原理。并考虑2种回收机制

  答：Java语言中一个显著的特点就是引入了垃圾回收机制，使c++程序员最头疼的内存管理的问题迎刃而解，它使得Java程序员在编写程序的时候不再需要考虑内存管理。由于有个垃圾回收机制，Java中的对象不再有"作用域"的概念，只有对象的引用才有"作用域"。
  垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。

• JAVA语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义？在try块中可以抛出异常吗？

  答：Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java中，每个异常都是一个对象，它是Throwable类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。一般情况下是用try来执行一段程序，如果出现异常，系统会抛出（throws）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理。
  用try来指定一块预防所有"异常"的程序。紧跟在try程序后面，应包含一个catch子句来指定你想要捕捉的"异常"的类型。
  throw语句用来明确地抛出一个"异常"。
  throws用来标明一个成员函数可能抛出的各种"异常"。
  Finally为确保一段代码不管发生什么"异常"都被执行一段代码。
  可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部写另一个try语句保护其他代码。每当遇到一个try语句，"异常"的框架就放到堆栈上面，直到所有的try语句都完成。如果下一级的try语句没有对某种"异常"进行处理，堆栈就会展开，直到遇到有处理这种"异常"的try语句。

• try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?

  答：会执行，在return前执行

• 以下程序输出结果为：

  package pers.chh3213.exception20220101;
  
  public class Demo2 {
  	public static void main(String[] args) {
  		int test = test(3,5);
  		System.out.println(test);
  	}
  	
  	public static int test(int x, int y){
  		int result = x;
  		try{
  			if(x<0 || y<0){
  				return 0;
  			}
  			result = x + y;
  			System.out.println(result);//8
  			return result;
  		}finally{
  			result = x - y;
  			System.out.println(result);//-2
  			System.out.println("HAHHA");
  		}
  	}
  
  }
  
  

    输出为：
    8
    -2
    HAHHA
    8
  

  解析：

  • 如果在try中return的情况下，先把try中将要return的值先存到一个本地变量中，即本例中的result=8将会被保存下来。接下来去执行finally语句，最后返回的是存在本地变量中的值，即返回result=8.
  • 还有一点要注意的，如果在finally里也用了return语句，比如return result。那么程序返回值会是-2。因为规范规定了，当try和finally里都有return时，会忽略try的return，而使用finally的return。

• 空指针异常

  空指针就是空引用，java空指针异常就是引用本身为空，却调用了方法，这个时候就会出现空指针异常。可以理解，成员变量和方法是属于对象的（除去静态），在对象中才存在相对应的成员变量和方法，然后通过对象去调用这些成员变量和方法。对于空指针来说，它不指向任何对象，也就没有所谓的成员变量和方法，这个时候用它去调用某些属性和方法，当然会出现空指针异常。

最后

以上就是机智战斗机为你收集整理的【尚硅谷_java基础】八、异常处理参考文献1. 异常概述与异常体系结构2. 常见异常3. 异常处理机制一: try-catch-finally4. 异常处理机制二: throws5. 手动抛出异常: throw6. 用户自定义异常类7. 总结8. 练习的全部内容，希望文章能够帮你解决【尚硅谷_java基础】八、异常处理参考文献1. 异常概述与异常体系结构2. 常见异常3. 异常处理机制一: try-catch-finally4. 异常处理机制二: throws5. 手动抛出异常: throw6. 用户自定义异常类7. 总结8. 练习所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。