JAVA 面试知识点 3 --异常处理（Exception Handling）

最新推荐文章于 2024-06-05 10:00:47 发布

一朵小呆毛

最新推荐文章于 2024-06-05 10:00:47 发布

阅读量1.1w

点赞数 8

分类专栏： java 面试文章标签： java 异常处理 exception thorw&amp;&amp;throws try

本文链接：https://blog.csdn.net/weixin_43681425/article/details/84147396

版权

java 同时被 2 个专栏收录

7 篇文章 0 订阅

订阅专栏

面试

7 篇文章 0 订阅

订阅专栏

java里的异常处理（Exception）

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

1. 什么是异常（Exception）
2. 如何处理异常（how to handle exception）
- 2.1 try-catch-finally
- 2. 2. throws exception
3.如何创建一个custom的exception类
- 3.1 如何创建一个custom的exception类
- 3.2 如何扔throw一个custom的exception

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

一朵小呆毛

关注

8
点赞
踩
44

收藏

觉得还不错? 一键收藏
2
评论
JAVA 面试知识点 3 --异常处理（Exception Handling）

异常（Exception）什么是 ExceptionException 是在程序执行过程中发生的一些不希望发生的事情，这些事情如果不被好好处理，就会导致奇怪的结果或者是程序终结。Exception Hander是那些当异常发生时处理这些异常的代码。java和javascript都用try／catch来处理异常。1. Exceptions in javaexception在java里也是个o...
复制链接

扫一扫