Java基础6：异常处理

异常概述

• 异常：在Java语言中，将程序执行中发生的不正常情况称为“异常”(开发过程中的语法错误和逻辑错误不是异常)
• Java程序在执行过程中所发生的异常事件可分为两类：
  • Error：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverflowError（栈溢出）和OOM（堆溢出）。一般不编写针对性的代码进行处理。
  • Exception: 其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。如：空指针、数组越界等
• 异常又分为运行时异常和编译时异常
  • 运行时异常： 是指编译器不要求强制处置的异常。一般是指编程时的逻辑错误，是程序员应该积极避免其出现的异常。均是RuntimeException的子类
  • 编译时异常： 是指编译器要求必须处置的异常。即程序在运行时由于外界因素造成的一般性异常。编译器要求Java程序必须捕获或声明所有编译时异常。对于这类异常，如果程序不处理，可能会带来意想不到的结果。

运行时异常与编译时异常

常见异常

• 运行时异常
  • InputMismatchException，输入类型不匹配

    Scanner in = new Scanner(System.in);
    double score = in.nextDouble();
    //此时输入的不是double或不能被自动类型提升为double，则会报InputMismatchException
    System.out.println(score);
    

  • ArithmeticException，运算异常

    int a = 10;
    int b = 0;
    int c = a / b;
    

  • ArrayIndexOutOfBoundsException，数组越界异常

    int[] a = new int[5];
    System.out.println(a[6]);
    

  • NullPointerException，空指针异常

    int[][] a = new int[5][];
    System.out.println(a[4][1]);
    

  • ClassCastException，类型转换异常

    Object obj = new Date();
    Order order;
    order = (Order) obj;
    System.out.println(order);
    

• 编译时异常
  • IOExeption，对于文件处理是必须要做异常处理
  • ClassNotFoundException，类找不到

Java异常处理

• Java异常处理：Java采用的异常处理机制，是将异常处理的程序代码集中在一起，与正常的程序代码分开，使得程序简洁、优雅，并易于维护。
• Java提供的是异常处理的抓抛模型。
  • Java程序的执行过程中如出现异常，会生成一个异常类对象，该异常对象将被提交给Java运行时系统，这个过程称为抛出(throw)异常。
  • 如果一个方法内抛出异常，该异常对象会被抛给调用者方法中处理。如果异常没有在调用者方法中处理，它继续被抛给这个调用方法的上层方法。这个过程将一直继续下去，直到异常被处理。这一过程称为捕获(catch)异常。
  • 如果一个异常回到main()方法，并且main()也不处理，则程序运行终止。（异常对象也可以手动创建，但此时只是一个正常的对象，对象不抛出对程序没有任何影响）
  • 程序员通常只能处理Exception，而对Error无能为力。
• Java异常处理方式：1.try-catch-finally；2.throws + 异常类型

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

• 语法

  try{
  ...... //可能产生异常的代码
  }
  catch( ExceptionName1 e ){
  ...... //当产生ExceptionName1型异常时的处置措施
  }
  catch( ExceptionName2 e ){
  ...... //当产生ExceptionName2型异常时的处置措施
  }
  finally{
  ...... //无论是否发生异常，都无条件执行的语句，可选结构
  }
  

• try-catch-finally结构使用说明
  • 当try中代码出现异常，会生成一个该异常的对象，之后于catch中的异常类型进行匹配，如果没有相匹配的，仍旧向上抛出，如果有则执行catch中的语句，（没有finally的话）之后便会直接跳出try-catch结构（try中没有执行完的语句不会再执行），执行结构外的语句
  • 如果结构中多个catch，则子类异常类型必须放在父类异常类型的前面，否则会编译报错，如果这写异常类型没有子父类关系，则它们的相对位置无所谓
  • 常用异常处理方式：1.String getMessage()，返回报错原因字符串；2.printStackTrace，直接打印运行时所有报错了的类，这种方法打印的信息包括了getMessage()
  • 在try结构中声明的变量，出了try结构后不能被调用，相当于方法体内声明的变量，在方法体外不能调用
  • 使用try-catch-finally处理编译时异常时，并不能保证程序在运行时不再报错 ，如文件流的读取等操作，try-catch只能保证编译时不报错
  • 运行时异常比较常见，对于此类异常，往往不用try-catch进行处理，try-catch结构更多的是针对不用try-catch就报错的编译时异常进行处理
  • try-catch-finally结构可以嵌套使用，即catch、finally中可能出现的异常也可以用另一个try-catch-finally结构
• finally使用说明
  • finally结构是可选的
  • finally中的语句是一定会被执行的，即使catch没有匹配异常对象或catch中出现异常、try、catch中有return语句，finally中的语句一定会执行
  • 当try、catch、finally中都有return语句时，以final的return为准
  • finally一般用来手动释放资源。诸如数据库连接、输出输入流、网络编程Socket等资源，JVM无法自动回收，我们需要手动释放资源，这种代码一般都放在finally中

异常处理机制之二：throws

• 语法：public void method() throws Excepiton{}
• 使用
  • 如果一个方法(中的语句执行时)可能生成某种异常，但是并不能确定如何处理这种异常，则此方法应显示地声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理。
  • 在方法声明中用throws语句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。
  • 带有throws的方法中的代码出现异常时，会在代码异常处生成异常对象，如果匹配上throws后的异常类型时，就会抛出，方法体内异常代码后的代码不再执行
  • throws并没有解决异常，只是将异常抛给了方法的调用者，try-catch真正地解决了异常
  • 重写方法时，重写方法不能抛出比被重写方法范围更大的异常类型，否则编译错误

    public class ExceptionTest {
    	public static void main(String[] args) {
    		SuperClass superClass = new SubClass();
    		//在多态情况下，编译时我们以父类中定义的属性、方法来使用，如果允许重写的
    		//方法抛出异常范围更大，那么对于针对父类编写的异常范围则没有意义，因为很
    		//有可能会抛出无法匹配的异常
    		try {
    			superClass.method();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    }
    class SuperClass{
    	public void method() throws IOException {
    		
    	}
    }
    class SubClass extends SuperClass{
    	public void method() throws FileNotFoundException {
    		
    	}
    }
    

• 两种异常处理方式的选择
  • 父类中被重写的方法没有使用throws的话，子类重写方法也不能用throws，即异常处理只能由try-catch-finally
  • 在执行方法A中，连续调用了几个可能产生异常的方法，这几个方法还有层层递进的关系，那么对于这几个方法可以用throws的方法处理，在A方法中再使用try-catch-finally方式集中处理

手动抛出异常

• 语法：throw 异常对象，如throw new RuntimeException()
• 使用
  • 对于某些特定的业务场景，虽然程序不会报错，但不符合需求，如：用户输入年龄，不能输入负数，输入负数虽然不会让程序报错，但不符合我们需求，此时，我们可以手动抛出一个异常
  • 抛出异常不选择Error，往往选择两个Exception和RuntimeException
  • 对于RuntimeException，可以仅仅只是抛出，而不做任何处理，因为它是运行时异常，程序编译时不要求解决；而对于Exception，其中包含编译时异常，就必须要有相应的解决代码，否则编译不通过

  public class ExceptionTest {
  	public static void main(String[] args) {
  		Student student = new Student();
  		try {
  			student.regist(-1);
  		} catch (Exception e) {
  			System.out.println(e.getMessage());
  			//输出 年龄不能为负
  		}
  	}
  }
  
  class Student{
  	private int age;
  	//代码中手动抛出了异常，但没有解决，所以方法上也要抛出异常
  	public void regist(int id) throws Exception {
  		if (age > 0) {
  			this.age = age;
  		}else {
  			throw new Exception("年龄不能为负");
  		}
  	}
  }
  

自定义异常类

• 如何自定义异常类
  1. 继承于现有的异常结构，一般是Excption(当作编译时异常)、RuntimeException(运行时异常)
  2. 提供全局常量：serialVersionUID，序列号，以此表示异常类型的唯一
  3. 提供重载的构造器，根据需求即可
  4. 异常类型的名字最好有意义，看到名字能够知道是什么异常

public class MyNumberException extends Exception{
	static final long serialVersionUID = -3387516997894229948L;
	
    public MyNumberException() {
        super();
    }

    public MyNumberException(String message) {
        super(message);
    }
}