JAVA 面试知识点 3 --异常处理(Exception Handling)

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/weixin_43681425/article/details/84147396

java里的异常处理(Exception)

Exception 是在程序执行过程中发生的一些不希望发生的事情,这些事情如果不被好好处理,就会导致奇怪的结果或者是程序终结。Exception Handler是那些当异常发生时处理这些异常的代码。所以这里只讲三个事儿:

1. 什么是异常(Exception)

Exception 是在程序执行过程中发生的一些不希望发生的事情,这些事情如果不被好好处理,就会导致奇怪的结果或者是程序终结。Exception Hander是那些当异常发生时处理这些异常的代码。java和javascript都用try/catch来处理异常。

1.1 Exceptions in java

exception在java里也是个object。
来个图先

Exception hierarchy
图片来源: http://voyager.deanza.edu/~hso/cis35a/lecture/java13/intro/hier.html
它爸爸是Throwable(面试会考,敲黑板)。它还有个兄弟叫Error

error and exception的不同:

An Error is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch.

The class Exception and its subclasses are a form of Throwable that indicates conditions that a reasonable application might want to catch.

1.2 checked 和 unchecked的异常

  • Checked exception 是编译的时候就要求被handle的。编译的时候会检测Checked exception如果发生了有没有被handler(有没有加handler)所以也被称为compile-time exception。如果一个class是 Exception的孩子但不是 RuntimeException的孩子,那么它就是checked,写代码的时候被要求加handler 。如果用IDE, 会在写代码时要求handle这类异常。
    • 例如: CloneNotSupportedException, IOException, SQLException,
      InterruptedException, FileNotFoundException
  • Unchecked exception 也被称为runtime exception因为它发生在程序执行时。我们可以添加handler去处理这类异常,也可以不加handler不处理这类异常。如果一个class是 RuntimeException的子孙,那它就是一个unchecked exception。
    • 例如: IllegalMonitorStateException,
      ConcurrentModificationException, NullPointerException,
      IndexOutOfBoundException, NumberFormatException

1.3 error和unchecked exception的不同

虽然都发生在runtime,但是error不被建议去handle。 大部分情况下即使是加了catch也无法修复。而RuntimeException可以去handle。

2. 如何处理异常 (how to handle exception)

有一些方法在声明的时候就声明扔出一个exception。如果这个exception是checked exception,则调用这个方法的时候就必须handle它。
checked exception就像一个炸弹,如果说方法A的某处扔出一个炸弹,或者从别处接到一个炸弹(调用了另一个扔出exception的方法), 有两种解决方案:

  • 自己把它拆了( try-catch-finally)。 这样的话调用方法A的方法不用担心这个炸弹(异常)了
  • 继续丢出去, 谁调用方法A谁来处理(在A的method declaration的时候加上throws.)

如果采用第一种方案,当方法B调用方法A的时候,方法A已经把炸弹拆了,方法B不用担心任何事情
如果采用第二种方法,方法B调用方法A的时候知道同时要接到一个炸弹,于是它有两种解决方案,拆了,或者继续throws。

2.1 如何拆炸弹 用try-catch-finally

try-catch:

一个常见的数组越界exception。是个unchecked的exception,因为编译时没有要求handle,所以是个常见的新手 runtime异常。(不要求被handle,但是如果想handle也是可以的。)

import java.io.*;
public class ExceptionTest1 {
   public static void main(String args[]) {
      try {
         int a[] = new int[2];
         System.out.println(a[3]); //数组越界访问
      } catch (ArrayIndexOutOfBoundsException e) {
         System.out.println(e);//虽然没有做有意义的事情,但是阻止了程序死在半截。
      }
      System.out.println("run successfully");
   }
}

一个try可以跟着好几个catch, 为了分开处理不同的错误:

try {
   //doing something
} catch (Exception1 e) {
	// handle the first type exception
    System.out.println("Exception1 happened")
} catch (Exception2 f){
	// handle the first type exception
    System.out.println("Exception2 happened")
}

一个exception发生之后,如果是Exception1类型的,就会被第一个handle,如果不是Exception1类型的就会接着往下找catch,如果是Exception2类型的,就会被第二个catch块handle。
如果Exception1和Exception2是父子关系,则儿子要先被检测,因为如果爸爸先被检测,就永远也到不了儿子那个catch块了。

finally block:

finally block 是无论如何也会发生的一个block。 catch里的代码如果不发生异常就不会被执行,但是finally里面的代码无论如何都会执行。(除非是在try或者catch里面用System.exit(1)结束jvm。)通常用来关闭文件。

      try {
         //doing something
      } catch (Exception e) {
      	//handle the exception
      }finally {
         //一定会被执行的代码。
      }
   }
}

另外, try-finally也是合法的。

2.2 如何继续甩锅 throws exception

throws关键词

//m1抛出了一个异常
void m1 throws FileNotFoundException(){
	//大概是想读一些文件,又不想考虑如果文件找不到咋整。(甩锅)
}
//m2调用了m1,相当于从m1手里接到了这个异常,自己不处理,继续往外甩。
void m2 throws FileNotFoundException(){
	m1();//想用m1方法,m1声明如果想用我就要考虑文件找不到的情况。
	//但是m2依然不想考虑文件找不到咋整。
}

来看个综合的例子:

下面代码由于接到了exception没有正确handle而产生编译错误:

import java.io.File;
import java.io.FileReader;
//会有编译错误
public class ReadFileTest {
   public static void main(String args[]) {
      getFile();
   }
   public static void getFile(){
   	   File file = new File("file.txt");
       FileReader fr = new FileReader(file);//error: unreported exception FileNotFoundException; must be caught or declared to be thrown
   }
}

因为FileReader的constructor throws了一个异常

public FileReader(String fileName) throws FileNotFoundException

所以当getFile方法调用FileReader的时候必须handle这个异常。

下面是一个例子用上面两种方法处理异常:

import java.io.File;
import java.io.FileReader;
import java.io.FileNotFoundException;
public class ReadFileTest {
   public static void main(String args[]) {
   		getFile1();
   		System.out.println("=============");
        try{
           // 因为getFile2又把exception甩出来了,所以main方法得处理它。
           getFile2();
        }catch(FileNotFoundException e){
           System.out.println("Exception handled in main");
        }
      
   }
   //getFile1选择了自己处理,不麻烦调用它的方法
   public static void getFile1() {
		try{
   	   		File file = new File("file.txt");
       		FileReader fr = new FileReader(file);
       	}catch(FileNotFoundException e){
       		System.out.println("Exception handled in getfile1");
       }
   }
   //getFile2选择了不处理,继续throws
   public static void getFile2() throws FileNotFoundException{
   	   File file = new File("file.txt");
       FileReader fr = new FileReader(file);
   }
}

运行结果:

Exception handled in getfile1
=============
Exception handled in main

一般来讲,所有的exception到了main方法这里都应该已经被解决了。如果,main方法也不负责任的往外扔。。。

import java.io.File;
import java.io.FileReader;
import java.io.FileNotFoundException;
public class ReadFileTest {
   public static void main(String args[]) throws FileNotFoundException{
   		getFile1();
   		System.out.println("=============");
        getFile2();
      
   }
   public static void getFile1() {
		try{
   	   		File file = new File("file.txt");
       		FileReader fr = new FileReader(file);
       	}catch(FileNotFoundException e){
       		System.out.println("Exception handled in getfile1");
       }
   }
   public static void getFile2() throws FileNotFoundException{
   	   File file = new File("file.txt");
       FileReader fr = new FileReader(file);
   }
}

这样做是可以的。。。在没有文件的情况下(触发exception)运行结果:

Exception handled in getfile1
=============
Exception in thread "main" java.io.FileNotFoundException: file.txt (No such file or directory)
	at java.io.FileInputStream.open0(Native Method)
	at java.io.FileInputStream.open(FileInputStream.java:195)
	at java.io.FileInputStream.<init>(FileInputStream.java:138)
	at java.io.FileReader.<init>(FileReader.java:72)
	at ReadFileTest.getFile2(ReadFileTest.java:21)
	at ReadFileTest.main(ReadFileTest.java:8)

3.如何应用custom的exception

3.1 如何创建一个custom的exception类

extends exception和它的孩子们呀

1. class New1Exception extends Exception { } // 创建一个checked exception
2. class NewException extends IOExcpetion { } // 创建一个跟IO相关的exception
3. class NewException extends RuntimeException { } // 创建一 UnChecked exception

来个例子(就是这么简单):

import java.io.*;
class MyException extends Exception 
{ 
    public MyException(String s) 
    { 
        super("a MyException happens: " + s); 
        //还可以做一些其他的事
    } 
} 

3.2 如何甩出(throw)一个custom的exception

throw 和throws

throw是在方法或者代码块里面,用来扔炸弹 抛出异常。
throws是在方法声明的时候,说明这个方法抛出了异常。

用刚才的MyException写个例子:

import java.io.*;
public class Main 
{ 
    public static void main(String args[]) 
    { 
        try { 
            throwTest();
        } catch (MyException e) { 
            System.out.println("Caught something"); 
            System.out.println(e.getMessage()); 
        } 
        //throwTest2是一个正常的方法,扔的exception被自己handle了。
        throwTest2();
        //另用一个block测试test3,
        //如果写在同一个block,throwTest()抛出异常后,throwTest3()不会被执行
        try { 
            throwTest3();
        } catch (MyException e) { 
            System.out.println("Caught something"); 
            System.out.println(e.getMessage()); 
        } 
    } 
    // 自己不handle,扔出来之后继续在方法声明里告诉调用自己的方法需要handle
    public static void throwTest() throws MyException {
        throw new MyException("something"); 
    }
    //自己handle了,变成一个正常的方法
    public static void throwTest2() {
        try {
            throw new MyException("somethingElse"); 
        } catch (MyException e) {
            System.out.println("Caught somethingElse"); 
            System.out.println(e.getMessage()); 
        } 
    }
    //自己handle了,在catch里继续往外扔。
    public static void throwTest3() throws MyException{
        try {
            throw new MyException("somethingElse2"); 
        } catch (MyException e) {
           //一个非常不负责任的catch,但是是合法的。
           throw e;
        }
    }
}  

输出:

Caught something
a MyException happens: something
Caught somethingElse
a MyException happens: somethingElse
Caught something
a MyException happens: somethingElse2
展开阅读全文

没有更多推荐了,返回首页