面试Java异常面试题

Posted 逆流°只是风景-bjhxcc

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了面试Java异常面试题相关的知识，希望对你有一定的参考价值。

文章目录

Java异常架构与异常关键字

Java异常简介

Java异常是Java提供的一种识别及响应错误的一致性机制。

Java异常机制可以使程序中异常处理代码和正常业务代码分离，保证程序代码更加优雅，并提高程序健壮性。在有效使用异常的情况下，异常能清晰的回答what, where, why这3个问题：异常类型回答了“什么”被抛出，异常堆栈跟踪回答了“在哪”抛出，异常信息回答了“为什么”会抛出。

Java异常架构

1. Throwable

  • Throwable 是 Java 语言中所有错误与异常的超类。

  • Throwable 包含两个子类：Error（错误）和 Exception（异常），它们通常用于指示发生了异常情况。

  • Throwable 包含了其线程创建时线程执行堆栈的快照，它提供了 printStackTrace() 等接口用于获取堆栈跟踪数据等信息。

2. Error（错误）

  • 定义：Error 类及其子类。程序中无法处理的错误，表示运行应用程序中出现了严重的错误。

  • 特点：此类错误一般表示代码运行时 JVM 出现问题。通常有 Virtual MachineError（虚拟机运行错误）、NoClassDefFoundError（类定义错误）等。比如 OutOfMemoryError：内存不足错误；StackOverflowError：栈溢出错误。此类错误发生时，JVM 将终止线程。

  • 这些错误是不受检异常，非代码性错误。因此，当此类错误发生时，应用程序不应该去处理此类错误。按照Java惯例，我们是不应该实现任何新的Error子类的！

3. Exception（异常）

程序本身可以捕获并且可以处理的异常。Exception 这种异常又分为两类：运行时异常和编译时异常。

运行时异常

  • 定义：RuntimeException 类及其子类，表示 JVM 在运行期间可能出现的异常。

  • 特点：Java 编译器不会检查它。也就是说，当程序中可能出现这类异常时，倘若既"没有通过throws声明抛出它"，也"没有用try-catch语句捕获它"，还是会编译通过。比如NullPointerException空指针异常、ArrayIndexOutBoundException数组下标越界异常、ClassCastException类型转换异常、ArithmeticExecption算术异常。此类异常属于不受检异常，一般是由程序逻辑错误引起的，在程序中可以选择捕获处理，也可以不处理。虽然 Java 编译器不会检查运行时异常，但是我们也可以通过 throws 进行声明抛出，也可以通过 try-catch 对它进行捕获处理。如果产生运行时异常，则需要通过修改代码来进行避免。例如，若会发生除数为零的情况，则需要通过代码避免该情况的发生！

  • RuntimeException 异常会由 Java 虚拟机自动抛出并自动捕获（就算我们没写异常捕获语句运行时也会抛出错误！！），此类异常的出现绝大数情况是代码本身有问题应该从逻辑上去解决并改进代码。

编译时异常

  • 定义: Exception 中除 RuntimeException 及其子类之外的异常。

  • 特点: Java 编译器会检查它。如果程序中出现此类异常，比如 ClassNotFoundException（没有找到指定的类异常），IOException（IO流异常），要么通过throws进行声明抛出，要么通过try-catch进行捕获处理，否则不能通过编译。在程序中，通常不会自定义该类异常，而是直接使用系统提供的异常类。该异常我们必须手动在代码里添加捕获语句来处理该异常。

4. 受检异常与非受检异常

Java 的所有异常可以分为受检异常（checked exception）和非受检异常（unchecked exception）。

受检异常

编译器要求必须处理的异常。正确的程序在运行过程中，经常容易出现的、符合预期的异常情况。一旦发生此类异常，就必须采用某种方式进行处理。除 RuntimeException 及其子类外，其他的 Exception 异常都属于受检异常。编译器会检查此类异常，也就是说当编译器检查到应用中的某处可能会此类异常时，将会提示你处理本异常——要么使用try-catch捕获，要么使用方法签名中用 throws 关键字抛出，否则编译不通过。

非受检异常

编译器不会进行检查并且不要求必须处理的异常，也就说当程序中出现此类异常时，即使我们没有try-catch捕获它，也没有使用throws抛出该异常，编译也会正常通过。该类异常包括运行时异常（RuntimeException极其子类）和错误（Error）。

Java异常关键字

  • try – 用于监听。将要被监听的代码(可能抛出异常的代码)放在try语句块之内，当try语句块内发生异常时，异常就被抛出。
  • catch – 用于捕获异常。catch用来捕获try语句块中发生的异常。
  • finally – finally语句块总是会被执行。它主要用于回收在try块里打开的物力资源(如数据库连接、网络连接和磁盘文件)。只有finally块，执行完成之后，才会回来执行try或者catch块中的return或者throw语句，如果finally中使用了return或者throw等终止方法的语句，则就不会跳回执行，直接停止。
  • throw – 用于抛出异常。
  • throws – 用在方法签名中，用于声明该方法可能抛出的异常。

Java异常处理

  • Java 通过面向对象的方法进行异常处理，一旦方法抛出异常，系统自动根据该异常对象寻找合适异常处理器（Exception Handler）来处理该异常，把各种不同的异常进行分类，并提供了良好的接口。在 Java 中，每个异常都是一个对象，它是 Throwable 类或其子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并可以对其进行处理。Java 的异常处理是通过 5 个关键词来实现的：try、catch、throw、throws 和 finally。

  • 在Java应用中，异常的处理机制分为声明异常，抛出异常和捕获异常。

声明异常

通常，应该捕获那些知道如何处理的异常，将不知道如何处理的异常继续传递下去。传递异常可以在方法签名处使用 throws 关键字声明可能会抛出的异常。

注意

  • 非检查异常（Error、RuntimeException 或它们的子类）不可使用 throws 关键字来声明要抛出的异常。
  • 一个方法出现编译时异常，就需要 try-catch/ throws 处理，否则会导致编译错误。

抛出异常

  • 如果你觉得解决不了某些异常问题，且不需要调用者处理，那么你可以抛出异常。
  • throw关键字作用是在方法内部抛出一个Throwable类型的异常。任何Java代码都可以通过throw语句抛出异常。

捕获异常

程序通常在运行之前不报错，但是运行后可能会出现某些未知的错误，但是还不想直接抛出到上一级，那么就需要通过try…catch…的形式进行异常捕获，之后根据不同的异常情况来进行相应的处理。

如何选择异常类型

可以根据下图来选择是捕获异常，声明异常还是抛出异常

常见异常处理方式

直接抛出异常

通常，应该捕获那些知道如何处理的异常，将不知道如何处理的异常继续传递下去。传递异常可以在方法签名处使用 throws 关键字声明可能会抛出的异常。

private static void readFile(String filePath) throws IOException 
    File file = new File(filePath);
    String result;
    BufferedReader reader = new BufferedReader(new FileReader(file));
    while((result = reader.readLine())!=null) 
        System.out.println(result);
    
    reader.close();

封装异常再抛出

有时我们会从 catch 中抛出一个异常，目的是为了改变异常的类型。多用于在多系统集成时，当某个子系统故障，异常类型可能有多种，可以用统一的异常类型向外暴露，不需暴露太多内部异常细节。

private static void readFile(String filePath) throws MyException     
    try 
        // code
     catch (IOException e) 
        MyException ex = new MyException("read file failed.");
        ex.initCause(e);
        throw ex;

捕获异常

在一个 try-catch 语句块中可以捕获多个异常类型，并对不同类型的异常做出不同的处理

private static void readFile(String filePath) 
    try 
        // code
     catch (FileNotFoundException e) 
        // handle FileNotFoundException
     catch (IOException e)
        // handle IOException

同一个 catch 也可以捕获多种类型异常，用 | 隔开

private static void readFile(String filePath) 
    try 
        // code
     catch (FileNotFoundException | UnknownHostException e) 
        // handle FileNotFoundException or UnknownHostException
     catch (IOException e)
        // handle IOException

自定义异常

习惯上，定义一个异常类应包含两个构造函数，一个无参构造函数和一个带有详细描述信息的构造函数（Throwable 的 toString 方法会打印这些详细信息，调试时很有用）

public class MyException extends Exception 
    public MyException() 
    public MyException(String msg)
        super(msg);
    
    // ...

try-catch-finally

  • 当方法中发生异常，异常处之后的代码不会再执行，如果之前获取了一些本地资源需要释放，则需要在方法正常结束时和 catch 语句中都调用释放本地资源的代码，显得代码比较繁琐，finally 语句可以解决这个问题。
private static void readFile(String filePath) throws MyException 
    File file = new File(filePath);
    String result;
    BufferedReader reader = null;
    try 
        reader = new BufferedReader(new FileReader(file));
        while((result = reader.readLine())!=null) 
            System.out.println(result);
        
     catch (IOException e) 
        System.out.println("readFile method catch block.");
        MyException ex = new MyException("read file failed.");
        ex.initCause(e);
        throw ex;
     finally 
        System.out.println("readFile method finally block.");
        if (null != reader) 
            try 
                reader.close();
             catch (IOException e) 
                e.printStackTrace();

  • 调用该方法时，读取文件时若发生异常，代码会进入 catch 代码块，之后进入 finally 代码块；若读取文件时未发生异常，则会跳过 catch 代码块直接进入 finally 代码块。所以无论代码中是否发生异常，fianlly 中的代码都会执行。

  • 若 catch 代码块中包含 return 语句，finally 中的代码还会执行吗？将以上代码中的 catch 子句修改如下：

catch (IOException e) 
    System.out.println("readFile method catch block.");
    return;
  • 调用 readFile 方法，观察当 catch 子句中调用 return 语句时，finally 子句是否执行
readFile method catch block.
readFile method finally block.
  • 可见，即使 catch 中包含了 return 语句，finally 子句依然会执行。若 finally 中也包含 return 语句，finally 中的 return 会覆盖前面的 return.

try-with-resource

  • 上面例子中，finally 中的 close 方法也可能抛出 IOException, 从而覆盖了原始异常。JAVA 7 提供了更优雅的方式来实现资源的自动释放，自动释放的资源需要是实现了 AutoCloseable 接口的类。
private  static void tryWithResourceTest()
    try (Scanner scanner = new Scanner(new FileInputStream("c:/abc"),"UTF-8"))
        // code
     catch (IOException e)
        // handle exception
  • try 代码块退出时，会自动调用 scanner.close 方法，和把 scanner.close 方法放在 finally 代码块中不同的是，若 scanner.close 抛出异常，则会被抑制，抛出的仍然为原始异常。被抑制的异常会由 addSusppressed 方法添加到原来的异常，如果想要获取被抑制的异常列表，可以调用 getSuppressed 方法来获取。

Java异常常见面试题

1. Error 和 Exception 区别是什么？

  • Error 类型的错误通常为虚拟机相关错误，如系统崩溃，内存不足，堆栈溢出等，编译器不会对这类错误进行检测，JAVA 应用程序也不应对这类错误进行捕获，一旦这类错误发生，通常应用程序会被终止，仅靠应用程序本身无法恢复；
  • Exception 类的错误是可以在应用程序中进行捕获并处理的，通常遇到这种错误，应对其进行处理，使应用程序可以继续正常运行。

2. 运行时异常和一般异常(受检异常)区别是什么？

  • 运行时异常包括 RuntimeException 类及其子类，表示 JVM 在运行期间可能出现的异常。 Java 编译器不会检查运行时异常。
  • 受检异常是Exception 中除 RuntimeException 及其子类之外的异常。 Java 编译器会检查受检异常。
  • RuntimeException异常和受检异常之间的区别：是否强制要求调用者必须处理此异常，如果强制要求调用者必须进行处理，那么就使用受检异常，否则就选择非受检异常(RuntimeException)。一般来讲，如果没有特殊的要求，我们建议使用RuntimeException异常。

3. JVM 是如何处理异常的？

  • 在一个方法中如果发生异常，这个方法会创建一个异常对象，并转交给 JVM，该异常对象包含异常名称，异常描述以及异常发生时应用程序的状态。创建异常对象并转交给 JVM 的过程称为抛出异常。可能有一系列的方法调用，最终才进入抛出异常的方法，这一系列方法调用的有序列表叫做调用栈。
  • JVM 会顺着调用栈去查找看是否有可以处理异常的代码，如果有，则调用异常处理代码。当 JVM 发现可以处理异常的代码时，会把发生的异常传递给它。如果 JVM 没有找到可以处理该异常的代码块，JVM 就会将该异常转交给默认的异常处理器（默认处理器为 JVM 的一部分），默认异常处理器打印出异常信息并终止应用程序。

4. throw 和 throws 的区别是什么？

Java 中的异常处理除了包括捕获异常和处理异常之外，还包括声明异常和拋出异常，可以通过 throws 关键字在方法上声明该方法要拋出的异常，或者在方法内部通过 throw 拋出异常对象。

throws 关键字和 throw 关键字在使用上的几点区别如下：

  • throw 关键字用在方法内部，只能用于抛出一种异常，用来抛出方法或代码块中的异常，受查异常和非受查异常都可以被抛出。
  • throws 关键字用在方法声明上，可以抛出多个异常，用来标识该方法可能抛出的异常列表。一个方法用 throws 标识了可能抛出的异常列表，调用该方法的方法中必须包含可处理异常的代码，否则也要在方法签名中用 throws 关键字声明相应的异常。

5. final、finally、finalize 有什么区别？

  • final可以修饰类、变量、方法，修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修饰变量表示该变量是一个常量不能被重新赋值。
  • finally一般作用在try-catch代码块中，在处理异常的时候，通常我们将一定要执行的代码方法finally代码块中，表示不管是否出现异常，该代码块都会执行，一般用来存放一些关闭资源的代码。
  • finalize是一个方法，属于Object类的一个方法，而Object类是所有类的父类，Java 中允许使用 finalize()方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。

6. NoClassDefFoundError 和 ClassNotFoundException 区别？

  • NoClassDefFoundError 是一个 Error 类型的异常，是由 JVM 引起的，不应该尝试捕获这个异常。

  • 引起该异常的原因是 JVM 或 ClassLoader 尝试加载某类时在内存中找不到该类的定义，该动作发生在运行期间，即编译时该类存在，但是在运行时却找不到了，可能是变异后被删除了等原因导致；

  • ClassNotFoundException 是一个受查异常，需要显式地使用 try-catch 对其进行捕获和处理，或在方法签名中用 throws 关键字进行声明。当使用 Class.forName, ClassLoader.loadClass 或 ClassLoader.findSystemClass 动态加载类到内存的时候，通过传入的类路径参数没有找到该类，就会抛出该异常；另一种抛出该异常的可能原因是某个类已经由一个类加载器加载至内存中，另一个加载器又尝试去加载它。

7. try-catch-finally 中哪个部分可以省略？

  • 答：catch 可以省略

原因

  • 更为严格的说法其实是：try只适合处理运行时异常，try+catch适合处理运行时异常+普通异常。也就是说，如果你只用try去处理普通异常却不加以catch处理，编译是通不过的，因为编译器硬性规定，普通异常如果选择捕获，则必须用catch显示声明以便进一步处理。而运行时异常在编译时没有如此规定，所以catch可以省略，你加上catch编译器也觉得无可厚非。
  • 理论上，编译器看任何代码都不顺眼，都觉得可能有潜在的问题，所以你即使对所有代码加上try，代码在运行期时也只不过是在正常运行的基础上加一层皮。但是你一旦对一段代码加上try，就等于显示地承诺编译器，对这段代码可能抛出的异常进行捕获而非向上抛出处理。如果是普通异常，编译器要求必须用catch捕获以便进一步处理；如果运行时异常，捕获然后丢弃并且+finally扫尾处理，或者加上catch捕获以便进一步处理。
  • 至于加上finally，则是在不管有没捕获异常，都要进行的“扫尾”处理。

8. try-catch-finally 中，如果 catch 中 return 了，finally 还会执行吗？

答：会执行，在 return 前执行。

注意：在 finally 中改变返回值的做法是不好的，因为如果存在 finally 代码块，try中的 return 语句不会立马返回调用者，而是记录下返回值待 finally 代码块执行完毕之后再向调用者返回其值，然后如果在 finally 中修改了返回值，就会返回修改后的值。显然，在 finally 中返回或者修改返回值会对程序造成很大的困扰，C#中直接用编译错误的方式来阻止程序员干这种龌龊的事情，Java 中也可以通过提升编译器的语法检查级别来产生警告或错误。

代码示例1：

public static int getInt() 
    int a = 10;
    try 
        System.out.println(a / 0);
        a = 20;
     catch (ArithmeticException e) 
        a = 30;
        return a;
        /*
         * return a 在程序执行到这一步的时候，这里不是return a 而是 return 30；这个返回路径就形成了
         * 但是呢，它发现后面还有finally，所以继续执行finally的内容，a=40
         * 再次回到以前的路径,继续走return 30，形成返回路径之后，这里的a就不是a变量了，而是常量30
         */
     finally 
        a = 40;
    
	return a;


执行结果：30

代码示例2：

public static int getInt() 
    int a = 10;
    try 
        System.out.println(a / 0);
        a = 20;
     catch (ArithmeticException e) 
        a = 30;
        return a;
     finally 
        a = 40;
        //如果这样，就又重新形成了一条返回路径，由于只能通过1个return返回，所以这里直接返回40
        return a; 
    



执行结果：40

9. 类 ExampleA 继承 Exception，类 ExampleB 继承ExampleA。

有如下代码片断：

try 
	throw new ExampleB("b")
 catch（ExampleA e）
	System.out.println("ExampleA");
 catch（Exception e）
	System.out.println("Exception");

请问执行此段代码的输出是什么？

答：输出：ExampleA。（根据里氏代换原则[能使用父类型的地方一定能使用子类型]，抓取 ExampleA 类型异常的 catch 块能够抓住 try 块中抛出的 ExampleB 类型的异常）

面试题 - 说出下面代码的运行结果。（此题的出处是《Java 编程思想》一书）

class Annoyance extends Exception 

class Sneeze extends Annoyance 

class Human 
	public static void main(String[] args)
	throws Exception 
		try 
			try 
				throw new Sneeze();
			 catch ( Annoyance a ) 
				System.out.println("Caught Annoyance");
				throw a;
			
		 catch ( Sneeze s ) 
			System.out.println("Caught Sneeze");
			return ;
		 finally 
			System.out.println("Hello World!");

结果

Caught Annoyance
Caught Sneeze
Hello World!

10. 常见的 RuntimeException 有哪些？

  • ClassCastException(类转换异常)
  • IndexOutOfBoundsException(数组越界)
  • NullPointerException(空指针)
  • ArrayStoreException(数据存储异常，操作数组时类型不一致)
  • 还有IO操作的BufferOverflowException异常

11. Java常见异常有哪些

  • java.lang.IllegalAccessError：违法访问错误。当一个应用试图访问、修改某个类的域（Field）或者调用其方法，但是又违反域或方法的可见性声明，则抛出该异常。

  • java.lang.InstantiationError：实例化错误。当一个应用试图通过Java的new操作符构造一个抽象类或者接口时抛出该异常.

  • java.lang.OutOfMemoryError：内存不足错误。当可用内存不足以让Java虚拟机分配给一个对象时抛出该错误。

  • java.lang.StackOverflowError：堆栈溢出错误。当一个应用递归调用的层次太深而导致堆栈溢出或者陷入死循环时抛出该错误。

  • java.lang.ClassCastException：类造型异常。假设有类A和B（A不是B的父类或子类），O是A的实例，那么当强制将O构造为类B的实例时抛出该异常。该异常经常被称为强制类型转换异常。

  • java.lang.ClassNotFoundException：找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。

  • java.lang.ArithmeticException：算术条件异常。譬如：整数除零等。

  • java.lang.ArrayIndexOutOfBoundsException：数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。

  • java.lang.IndexOutOfBoundsException：索引越界异常。当访问某个序列的索引值小于0或大于等于序列大小时，抛出该异常。

  • java.lang.InstantiationException：实例化异常。当试图通过newInstance()方法创建某个类的实例，而该类是一个抽象类或接口时，抛出该异常。

  • java.lang.NoSuchFieldException：属性不存在异常。当访问某个类的不存在的属性时抛出该异常。

  • java.lang.NoSuchMethodException：方法不存在异常。当访问某个类的不存在的方法时抛出该异常。-

  • java.lang.NullPointerException：空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等。

  • java.lang.NumberFormatException：数字格式异常。当试图将一个String转换为指定的数字类型，而该字符串确不满足数字类型要求的格式时，抛出该异常。

  • java.lang.StringIndexOutOfBoundsException：字符串索引越界异常。当使用索引值访问某个字符串中的字符，而该索引值小于0或大于等于序列大小时，抛出该异常。

Java异常处理最佳实践

  • 在 Java 中处理异常并不是一个简单的事情。不仅仅初学者很难理解，即使一些有经验的开发者也需要花费很多时间来思考如何处理异常，包括需要处理哪些异常，怎样处理等等。这也是绝大多数开发团队都会制定一些规则来规范进行异常处理的原因。而团队之间的这些规范往往是截然不同的。

  • 本文给出几个被很多团队使用的异常处理最佳实践。

1. 在 finally 块中清理资源或者使用 try-with-resource 语句

  • 当使用类似InputStream这种需要使用后关闭的资源时，一个常见的错误就是在try块的最后关闭资源。
public void doNotCloseResourceInTry() 
    FileInputStream inputStream = null;
    try 
        File file = new File("./tmp.txt");
        inputStream = new FileInputStream(file);
        // use the inputStream to read a file
        // do NOT do this
        inputStream.close();
     catch (FileNotFoundException e) 
        log.error(e);
     catch (IOException e) 
        log.error(e);
  • 问题就是，只有没有异常抛出的时候，这段代码才可以正常工作。try 代码块内代码会正常执行，并且资源可以正常关闭。但是，使用 try 代码块是有原因的，一般调用一个或多个可能抛出异常的方法，而且，你自己也可能会抛出一个异常，这意味着代码可能不会执行到 try 代码块的最后部分。结果就是，你并没有关闭资源。

所以，你应该把清理工作的代码放到 finally 里去，或者使用 try-with-resource 特性。

1.1 使用 finally 代码块

与前面几行 try 代码块不同，finally 代码块总是会被执行。不管 try 代码块成功执行之后还是你在 catch 代码块中处理完异常后都会执行。因此，你可以确保你清理了所有打开的资源。

public void closeResourceInFinally() 
    FileInputStream inputStream = null;
    try 
        File file = new File("./tmp.txt");
        inputStream = new FileInputStream(file);
        // use the inputStream to read a file
     catch (FileNotFoundException e) 
        log.error(e);
     finally 
        if (inputStream != null) 
            try 
                inputStream.close();
             catch (IOException e) 
                log.error(e);

1.2 Java 7 的 try-with-resource 语法

如果你的资源实现了 AutoCloseable 接口，你可以使用这个语法。大多数的 Java 标准资源都继承了这个接口。当你在 try 子句中打开资源，资源会在 try 代码块执行后或异常处理后自动关闭。

public void automaticallyCloseResource() 
    File file = new File("./tmp.txt");
    try (FileInputStream inputStream = new FileInputStream(file);) 
        // use the inputStream to read a file
     catch (FileNotFoundException e) 
        log.error(e);
     catch (IOException e) 
        log.error(e);

2. 优先明确的异常

  • 你抛出的异常越明确越好，永远记住，你的同事或者几个月之后的你，将会调用你的方法并且处理异常。

  • 因此需要保证提供给他们尽可能多的信息。这样你的 API 更容易被理解。你的方法的调用者能够更好的处理异常并且避免额外的检查。

  • 因此，总是尝试寻找最适合你的异常事件的类&#x

    Java基础面试题有哪些?

    参考技术A 1.java异常机制的原理与应用\\x0d\\x0a答：每当程序出现异常之后，如果程序没有进行相应的处理，则程序会出现中断现象。\\x0d\\x0a实际上，产生了异常之后，JVM会抛出一个异常类的实例化对象，如果此时使用了try语句捕获的话，则可以进行异常的处理，否则，交给JVM进行处理。当try语句捕获异常之后，将与catch语句的异常类型进行匹配，如果匹配成功则执行catch内的语句。简单的应用：在所以throws语句的地方加入try-catch。标准应用：try-catch-finally-throw-throws一起使用。 \\x0d\\x0a\\x0d\\x0a2. 垃圾回收机制的优点\\x0d\\x0a答：释放无用的对象所占用的空间。方式：自动回收，手动回收。使用System.gc(),实际上调用Runtime.getRuntime().gc()\\x0d\\x0a\\x0d\\x0a3. Error与Exception区别\\x0d\\x0a答：Error是jvm进行处理，是jvm出错\\x0d\\x0aexception是可以由程序处理的，可以用try-catch捕获的\\x0d\\x0a\\x0d\\x0a4. final,finally,finallize\\x0d\\x0a答：final定义的变量的值不能改变，定义的方法不能被覆盖，定义的类不能被继承\\x0d\\x0afinally是异常的统一出口，finallize是垃圾回收前的收尾工作，是Object类定义的\\x0d\\x0a\\x0d\\x0a5. Anonymous Inner Class是否可以extends，是否可以implements Interface\\x0d\\x0a答：允许继承和实现，因为匿名内部类就是在抽象类和接口的基础上发展起来的\\x0d\\x0a\\x0d\\x0a6. Static Nested Class 与Inner Class的区别\\x0d\\x0a答：使用Static定义的Class就是外部类，可以通过外部类. 内部类直接访问\\x0d\\x0a而Inner Class是不能被外部访问的，只能通过外部类的实例再找到内部类实例。\\x0d\\x0a\\x0d\\x0a7. HashMap and HashTable？\\x0d\\x0a答：HashMap:1) released in jdk 1.2,new Class 2)采用异步处理方式，性能较高，是非线程安全的 3）允许null\\x0d\\x0aHashTable:\\x0d\\x0a1)released in jdk 1.0 ,old Class \\x0d\\x0a2)采用同步处理方式，性能低，是线程安全的\\x0d\\x0a3）不允许null\\x0d\\x0a\\x0d\\x0a8. assert代表什么？\\x0d\\x0a答：asserts是jdk 1.4之后发布的新关键字，表示断言，即程序执行到某个地方肯定是预计的值，一般开发很少使用。要使用assert，必须加上 -ea参数\\x0d\\x0a\\x0d\\x0a9. gc是什么？\\x0d\\x0a答：gc是garbage collection，垃圾回收，使用gc可以进行垃圾空间的释放\\x0d\\x0a\\x0d\\x0a10. String s = new String("xyz")产生了几个对象？\\x0d\\x0a答：一个匿名对象xyz，在栈空间内。一个new实例化的对象，在堆空间内。\\x0d\\x0a\\x0d\\x0a11. sleep() and wait()?\\x0d\\x0a答：sleep()是Thread类定义方法，表示线程的休眠，可以自动唤醒\\x0d\\x0await()方法是Object类定义的方法，需要手动notify()和notifyAll()//sleep()不释放资源，wait()释放资源\\x0d\\x0a\\x0d\\x0a12. Overload与Override的区别\\x0d\\x0a答：Overload：重载\\x0d\\x0a |- 在一个类中定义的若干方法\\x0d\\x0a |- 所有的方法名相同，但参数类型或个数不同\\x0d\\x0a |- 只有参数有关，与返回类型无关\\x0d\\x0aOverride：覆写\\x0d\\x0a |- 在继承的关系中\\x0d\\x0a |- 子类定义了父类同名的方法，参数类型或个数最好完全一样。\\x0d\\x0a |- 访问权限不能更严格\\x0d\\x0a\\x0d\\x0a13. abstract class 和 interface有什么区别？\\x0d\\x0a答：抽象类：\\x0d\\x0a |-由抽象方法和常量、变量、全局常量、构造方法、普通方法组成\\x0d\\x0a |-使用abstract声明\\x0d\\x0a |-子类要通过extends继承抽象类，子类如果不是抽象类，则必须覆写抽象类的全部抽象方法\\x0d\\x0a |-存在单继承的局限\\x0d\\x0a |-抽象类可以实现若干个接口\\x0d\\x0a接口：\\x0d\\x0a |-由抽象方法和全局常量组成\\x0d\\x0a |-使用interface关键字\\x0d\\x0a |-子类要通过implements实现接口，子类如果不是抽象类，则必须覆写抽象类的全部抽象方法\\x0d\\x0a |-一个子类可以实现多个接口\\x0d\\x0a |-接口不能继承一个抽象类，但允许继承多个接口

    以上是关于面试Java异常面试题的主要内容，如果未能解决你的问题，请参考以下文章

    （Java实习生）每日10道面试题打卡——JVM篇

    （Java实习生）每日10道面试题打卡——JVM篇

    2021秋招最新JAVA面试题|JVM剖析与常用的调优总结

    2020 年最新版 Java 面试题大全（文末附参考答案）

    2020年最新版Java面试题大全（文末附参考答案）

    2020年1-6月份Java面试题总结，20多类1100道面试题含答案解析