一、体系结构

java.lang.Throwable

　　|-----java.lang.Error:一般不编写针对性的代码进行处理

　　|-----java.lang.Exception:可以进行异常的处理

　　　　|-----编译时异常(checked)

　　　　　　|-----IOException

　　　　　　　　|-----FileNotFoundException

　　　　　　|-----ClassNotFountException

　　　　|-----运行时异常(unchecked，RuntimeException)

　　　　　　|-----NullPointerException

　　　　　　|-----ArrayIndexOutOfBoundsException

　　　　　　|-----ClassCastException

　　　　　　|-----NumberFormatException

　　　　　　|-----InputMismatchException

　　　　　　|-----ArithmetucException

二、面试题：常见的异常有哪些？请举例说明。

运行时异常：在执行java.exe命令时，出现的异常

//NullPointerException
@Test
public void test1() {
  int[ ] arr = null;
  System.out.println(arr[3]);    

  String str = "abc";
  str = null;
  System.out.println(str.charAt(0));      
}

//ArrayIndexOutOfBoundsException
@Test
public void test2{
  int [] arr = new int[10];
  System.out.println(arr[10]);    

  //StrijngIndexOutOfBoundsException  
  String str = "abc";
  System.out.println(str.charAt(3));   
}

//ClassCastException类型转换异常
@Test
public void test3{
　　Object obj = new Date();
　　String str = (String)obj;
}

//NumberFormatException
@Test
public void test4{
　　String str = "123"; //可以转
　　str = "abc"; //报异常
　　int num = Integer.parseInt(str);
}

//InputMismatchException 输入不匹配异常
@Test
publci void test5{
　　Scanner scanner = new Scanner(System.in);
　　int score = scanner.nextInt();
　　System.out.println(Score); //比如说输入abc就会报异常
}

//ArithmeticException 算术异常  例如10/0

编译时异常：执行javac.exe命令是，可能会出现的异常

@Test
public void test7{
  File file = new File("hello.txt");
  FileInputStream fis = new FileInputStream(file);

  int data = fis.read();
  while(data != -1){
       System.out.println((char)data); 
        data = fis.read(); 
    }
    fis.close();        
}

异常处理：抓抛模型

过程一：“抛”：程序在正常执行的过程中，一旦出现异常，就会在异常代码出生成一个异常类的对象。并将此对象抛出。一旦抛出对象，其后的代码不再执行

　　　　关于异常对象的产生：①系统自动生成的异常对象

　　　　　　　　　　　　　　②手动的生成一个异常对象，并抛出（throw） 

过程二：“抓”：可以理解为异常的处理 方式：①try-catch-finally ②throws

三、异常处理机制一 

try-catch-finally的使用：

try {
    //可能会出现异常的代码
}cathc(异常类型1 变量名1){
      //处理异常的方式1  
}cathc(异常类型2 变量名2){
      //处理异常的方式2  
}cathc(异常类型3 变量名3){
      //处理异常的方式3 
}......
    finally{
  //一定会执行的代码  
}

说明：1.finally是可选的，

2.使用try将可能出现异常的代码包起来，在执行过程中，一旦出现异常，就会生成一个对应的异常类的对象，根据此对象的类型，取catch中进行匹配

3.一旦try中的异常对象匹配到某一个catch时，就会进入catch中进行异常的处理，一旦处理完成，就跳出当前的try-catch结构（在没有写finally情况下）。继续执行其后面的代码。

4.catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下没有关系

catch中的异常类型如果有父类关系，则要求子类一定声明在父类的上面，否则，报错。

5.catch大括号中，异常处理的方式① String getMessage( ) ②printStackTrace

6.在try结构中声明的变量，在出了try结构后不能再使用。

7.try-catch-finally结构根据需要可以嵌套，比如说在catch中再try-catch-finally

finally的使用：

1.可选的

2.finally中放的是一定会执行的代码，即使catch中有出现异常了，try中有return语句，catch中有return语句等情况。finally中的语句会先被打印出来哦。

3.什么情况下会把代码放到finally中？像数据库连接，输入输出流，网络编程socket等资源，JVM是不能自动回收的，需要我们自己手动进行资源的释放，此时的资源释放，就需要声明在finally中。

总结：如何看待代码中的编译时异常和运行时异常？

体会1：try-catch-finally处理编译时异常，使得程序在编译时不再报错，但是运行时仍然可能报错。相当于我们使用try-catch-finally将一个编译可能出现的异常，延迟到运行时出现。

体会2：由于开发中运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了。针对编译时异常，我们说一定要考虑异常的处理。

面试题：final、finally、finalize三者的区别？

类似：

throw和throws？

Collection和Collenctions？

String、StringBuffer、StringBuilder？

ArrayList和LinkedList？

HashMap、LinkedHashMap？

重写与重载的区别？

结构不相似的：

抽象类、接口？

==      equals()

sleep()和wait()

四、异常处理方式二 throws + 异常类型

@Test
public void test7{
　　public static void main(String args[]){
　　　　method2();//抛到main这里就不要再抛了，可以try-catch处理了
}

　　public static void method2() throws IOException{
　　　　method1();
}

　　public static void method1() throws FileNotFoundException,IOException{ //往上抛
  File file = new File("hello.txt");
  FileInputStream fis = new FileInputStream(file);

  int data = fis.read();
  while(data != -1){
       System.out.println((char)data); 
        data = fis.read(); 
    }
    fis.close();        
}
}

1.“throws + 异常类型”写在方法声明处，指明此方法执行的时候可能会抛出的异常类型，一旦方法体执行出现异常时，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常类型时，就会抛出。异常代码后续的代码，不再执行！

2.对比两种方式：

try-catch-finally：真正的将异常给处理掉了。

throws的方式只是将异常抛给了方法的调用者，并没有真正的将异常处理掉。

3.体会开发中如何选择使用try-catch-finally还是throws？

3.1如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws处理，意味着如果子类重写父类的方法中有异常，必须使用try-catch-finally方式处理。

3.2执行方法中，先后又调用了另外的几个方法，这几个方法是递进的关系执行的，我们建议这几个方法使用throws的方式处理。而执行的方法a可以考虑使用try-catch-finally方式处理。

 补充：

方法重写的规则之一：

子类重写的方法抛出的类型不大于父类被重写的方法抛出的异常类型。

五、手动抛出异常

在程序执行过程中，除了自动抛出异常对象外，我们还可以手动的throw一个异常类对象。

异常处理：抓抛模型

过程一：“抛”：程序在正常执行的过程中，一旦出现异常，就会在异常代码出生成一个异常类的对象。并将此对象抛出。一旦抛出对象，其后的代码不再执行

　　　　关于异常对象的产生：①系统自动生成的异常对象

　　　　　　　　　　　　　　②手动的生成一个异常对象，并抛出（throw） 

过程二：“抓”：可以理解为异常的处理 方式：①try-catch-finally ②throws

class Student{

    private int id;
    public void regist(int id){
        if(id > 0){
            this.id = id;
        }else{
           // System.out.println("您输入的数据非法");
            //手动抛出异常
            throw new RuntimeException("您输入的数据非法");
        }
    }

    @Override
    public String toString(){
        return "[Student:id]=" + id; 

六：自定义异常类

如何定义异常类？

1.继承现有的异常结构体系：RuntimeException、Exception

2.提供全局常量序列号：serialVersionUID

3.提供重载构造器

public clsss MyException extends RuntimeException{
　　static final long serialVersionUID = -7034897190745766939L;

　　public MyException(){
　　
　　}
　　public MyException(String msg){
　　　　super(msg);
　　}

}

七：总结

 面试题：throw和throws有什么区别？

首先明白异常处理：抓抛模型（两个过程）

过程一：“抛”：程序在正常执行的过程中，一旦出现异常，就会在异常代码出生成一个异常类的对象。并将此对象抛出。一旦抛出对象，其后的代码不再执行

　　　　关于异常对象的产生：①系统自动生成的异常对象

　　　　　　　　　　　　　　②手动的生成一个异常对象，并抛出（throw） 

过程二：“抓”：可以理解为异常的处理 方式：①try-catch-finally ②throws

throw表示抛出一个异常类的对象，生成异常对象的过程。声明在方法体内。

throws属于异常处理的一种方式，声明在方法的声明处。

异常处理

原文：https://www.cnblogs.com/ldbstart/p/14483085.html