java异常分类，异常处理，面试中常见异常问题！

程序错误一般分为三种：

1.编译错误；2.运行时错误；3.逻辑错误。

（1）编译错误是因为程序没有遵循语法规则，编译程序能够自己发现并且提示我们错误的原因和位置，这个也是我们在刚接触编程语言最常遇到的问题。

（2）运行时错误是因为程序在执行时，运行环境发现了不能执行的操作。

（3）逻辑错误是因为程序没有按照预期的逻辑顺序执行。异常也就是指程序运行时发生错误，而异常处理就是对这些错误进行处理和控制。

先说一下java异常体系结构图吧：

两个子类区别：

1. Error： 程序不应该捕捉的错误，应该交由JVM来处理。一般可能指非常重大的错误。这个错误我们一般获取不到，也无法处理！

2. Exception：程序中应该要捕获的错误。这个异常类及它的子类是我们需要学习获取要处理的。

（1）RuntimeException：运行时异常，也叫未检查异常，是Exception的子类，但不需捕捉的异常超类，但是实际发生异常时，还是会导致程序停止运行的的，只是编译时没有报错而已。比如除数为零，数组空指针等等，这些都是在运行之后才会报错。此类异常，可以处理也可以不处理，并且可以避免。

（2）在Exception的所有子类中 除了RuntimeException类和它的子类，其他类都叫做非运行时异常，或者叫已检查异常，通常被定义为Checked类，是必须要处理可能出现的异常，否则编译就报错了。Checked类主要包含：IO类和SQL类的异常情况，这些在使用时经常要先处理异常（使用throws或try catch捕获）。

java几种常见的异常：

运行时异常：

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

2，ArithmeticException 算术错误情形，如以零作除数，算术条件异常。

3 java.lang.SecurityException 安全性异常

4，IllegalArgumentException 方法接收到非法参数，非法参数异常！

5，java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常

6，java.lang.NegativeArraySizeException 数组长度为负异常

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

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

9，java.lang.NumberFormatException（数字格式转换异常）

10，java.lang.ClassCastException(强制类型转换异常)

IOException

1， IOException 操作输入流和输出流时可能出现的异常

2， EOFException 文件已结束异常

3， FileNotFoundException 文件未找到异常

异常的产生：

自动产生：当程序遇到错误代码，会产生异常，程序终止

手动产生：throw new 异常类名();

throw必须定义在在方法体中，用来抛出一个Throwable类型的异常。程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中（可能在上层调用函数中）从里向外寻找含有与其匹配的catch子句的try块。

下面看一个手动抛出异常的例子：

package prac;

public class t2 {

public static void main(String[] args) throws Exception {

// TODO Auto-generated method stub

m1();

}

public static void m1() throws Exception {

System.out.println(“m1----------start”);

m2();

// 手动抛出受查异常

throw new Exception();

//System.out.println(“m1----------end”);

}

public static void m2() {

System.out.println(“m2----------start”);

// 手动抛出运行时异常，需要携带信息“程序因为异常而终止”

throw new RuntimeException(“程序因为异常而终止”);

//System.out.println(“m2----------end”);

}

}

程序运行结果为：

m1----------start

m2----------start

Exception in thread “main” java.lang.RuntimeException: 程序因为异常而终止

at prac.t2.m2(t2.java:31)

at prac.t2.m1(t2.java:21)

at prac.t2.main(t2.java:16)

异常的处理：

异常的处理分为消极的处理（自己处理不了，就往调用它的地方上抛throws，异常没有解决，只是抛出）和积极处理（异常捕获，捕捉异常通过try-catch语句或者try-catch-finally语句实现）

消极的处理：

语法：public void m1() throws 异常类名1,异常类名2{}

特点：相当于推卸责任，最终问题依然无法得到解决。

允许编译通过。

当上抛的异常为非运行（已检查）时异常时，调用此方法的调用者必须处理。

当上抛的异常为运行（未检查）时异常时，可以处理可以不处理。

积极的处理：(异常捕获)

将异常直接捕获，并且做出处理

语法：

try{

//异常代码

}catch(异常类名 引用名){

//当异常产生执行的代码

}

try 后的catch代码块 只能匹配成功一个

catch后声明的异常为父类时，它能够捕捉的异常为它本身+所有子类异常（多态的体现）

注意：catch代码块捕获异常时，子类异常必须定义在父类异常前面，否则会编译出错

finally代码块：一定会执行此代码块中的代码，常用来关闭资源，

try{

}catch(){

}finally{

//无论是否产生异常，一定会去执行的代码

}

注意：finally代码块中不要定义return语句

下面一个程序详细介绍异常的处理：

package work;

import java.io.EOFException;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.sql.SQLException;

import java.util.Scanner;

/**

• @author 超伟

• @date 2019年5月13日

• @version 1.0.0

*/

public class t4 {

public static void main(String[] args) {

System.out.println(“main1”);

int n;

Scanner sc = new Scanner(System.in);

n = sc.nextInt();

ma(n);

System.out.println(“main2”);

}

public static void ma(int n){

try {

System.out.println(“m1”);

mb(n);

System.out.println(“m2”);

} catch (EOFException e) {

//e.printStackTrace();

System.out.println("EOFException ");

} catch (IOException e) {

System.out.println(“IOException e111”);

}catch (SQLException e) {

System.out.println(“SQLException”);

}catch (Exception e) {

System.out.println(“Exception”);

}finally{

System.out.println(“in finally”);

}

}

public static void mb(int n) throws Exception {

System.out.println(“mb1”);

if (n==1) {

throw new EOFException();

}

if (n==2) {

throw new FileNotFoundException();

}

if (n==3) {

throw new SQLException();

}

if (n==4) {

throw new NullPointerException();

}

System.out.println(“mb2”);

}

}

程序运行结果为：

main1

1

m1

mb1

EOFException

in finally

main2

throw和throws的区别

这只是有点相似的关键字，并没有任何关联，要学会区分。

throw是用在方法体里面的，一般是放在判断情况的后面，手动抛出异常。

throws只能用在需要捕获异常的方法的方法名的括号后面使用。

自定义异常：

为什么要自定义异常？

当Java内置的异常都不能明确的说明异常情况的时候，需要创建自己的异常。

自定义一个异常类，需要继承于Exception或者其子类。

若想要这个异常类为运行时异常，需继承于RuntimeException或者其子类。

一般定义为运行时异常

自定义的异常类需要至少无参有参两个构造方法

例如：

package work;

import java.io.EOFException;

import java.util.Scanner;

public class t5 {

public static void main(String[] args) {

// TODO Auto-generated method stub

Scanner sc = new Scanner(System.in);

int n = sc.nextInt();

try {

m(n);

} catch (MyException1 e) {

// TODO Auto-generated catch block

e.printStackTrace();

System.out.println(e.getMessage());

}catch (MyException2 e) {

// TODO: handle exception

e.printStackTrace();

System.out.println(e.getMessage());

}

}

public static void m(int n) throws MyException1{

if (n==1) {

throw new MyException1(“我自己定义的非运行时异常”);

}

else {

throw new MyException2(“这是我定义的一个运行时异常！！！”);

}

}

}

//自定义异常

//已检查异常，非运行时异常

class MyException1 extends EOFException{

public MyException1() {

super();

}

public MyException1(String s) {

super(s);

}

}

//未检查异常

//运行时异常

class MyException2 extends RuntimeException{

public MyException2() {

}

public MyException2(String message) {

super(message);

}

}

方法覆盖，在继承中的异常的提现：

方法覆盖需要满足的3个条件

1.返回值类型 方法名 参数列表完全一致

2.访问修饰符相同或更宽

3.子类中方法不能抛出比父类更多、更宽的异常

package work;

import java.io.EOFException;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.sql.SQLException;

/**

• @author 超伟

• @date 2019年5月13日

• @version 1.0.0

*/

public class t8 {

/**

• @param args

*/

public static void main(String[] args) {

// TODO Auto-generated method stub