JAVA 异常处理

1、JAVA常见异常结构图

2、异常处理的抓抛模型

1、过程一，程序正常执行的过程中，一旦出现异常，就会在异常代码处生成一个异常类的对象
并将此对象抛出。抛出对象其后代码不再执行。
2、过程二：可以理解为异常的处理方式A\B
（1）、方式一：try-catch-finally（自己搞定）
使用：（伪代码）

try
{
   // 程序代码
}catch(ExceptionName e1)
{
   //Catch 块1
}catch(ExceptionName e2)
{
   //Catch 块2
}
......................
//一定会执行的代码（可以没有       ）
finally{
//代码块
}

学习的代码

package com.learn.exception;

public class LearnException {
    public static void main(String[] args) {

        String str = "1234";
        str = "abc";
        try {
            int num = Integer.parseInt(str);
            System.out.println("shit");
        }catch (NumberFormatException e){
            System.out.println("数值转化异常哦");
        }catch (NullPointerException e){
        
            System.out.println("空指针异常啦");
        }
    }
}

运行结果
说明

1. finally 是可选的

2. try{}出现异常则生成一个异常类的对象，据此对象类型去catch中匹配

3. catch匹配处理完成则跳出try-catch 结构。执行后续代码

4. catch中的异常类型如果有子父关系，则要求子类在上；否则谁在前都可以

5. 常用的异常对象处理方式：String getMessage（） 、、、、printStackTrace（）

6. try结构中声明的变量出其结构就不能被调用

7. 体会1：try-catch-finally（自己搞定）处理异常，编译时不报错，运行时可能报错。（将编译时的报错延迟到运行时出现）

8. 开发中由于运行时异常比较常见，所以通常不针对运行时异常编写try-catch-finally。针对编译时异常一定要考虑异常处理。

    **处理异常**
   

package com.learn.exception;
/**异常处理例子
 */
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class DealException {
    public static void main(String[] args) {
        try {
            //
            File file = new File("hello.txt");
            FileInputStream fileInputStream = new FileInputStream(file);
            int data = fileInputStream.read();
            while (data != -1) {
                System.out.println((char) data);
                data = fileInputStream.read();
            }
            fileInputStream.close();
        } catch (FileNotFoundException e) {
            //异常处理
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("异常处理后继续执行");   
    }

}

运行结果：

（2）、方式二：throws+异常类型（交给其它处理）

在方法执行时，出现异常，仍然在异常代码处生成一个异常类对象，次对象满足throws 后异常类型时，就会被抛出。

学习代码

package com.learn.exception;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class ThrowException {
    public static void main(String[] args)  {
        try {
            method2();
        }catch (IOException e){
            //处理异常
            e.printStackTrace();
        }
    }
    //method1() 抛出 IOException
    public void method1() throws IOException {
        method2();
    }
    //method1() 抛出 IOException
    public static void method2() throws IOException {

            File file = new File("hello.txt");
            FileInputStream fil = new FileInputStream(file);

            int data = fil.read();
            while (data != -1){
                System.out.println((char) data);
                data = fil.read();
                data = fil.read();
            }
            fil.close();
        System.out.println("+++++++++++++执行结束++++++++++++++++++");
    }
}

运行结果

3、异常处理的特殊情况

1、子类重写的方法抛出的## 标题异常类型不大于父类重写的方法抛出的异常类型。

待补充、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

4、如何选择try-catch-finally（自己搞定）和throws+异常类型（交给其它处理）

1. 如果父类中被重写的方法没有throws方式处理异常，则重写子类不能使用throws。即子类重写的方法中有异常，必须使用
   try-catch-finally（自己搞定）处理

2. 执行的方法A调用会抛异常的方法（可能是多个），一般这几个方法都抛异常，方法A 用try-catch-finally处理异常

5、手动抛异常

直接上代码

package com.learn.exception;

public class StuException {
    public static void main(String[] args)  {
        try {
            MyStudent stu = new MyStudent();
            stu.regist(-10001);
        } catch (Exception e) {
           // e.printStackTrace();
            System.out.println(e.getMessage());
        }
    }
}

    class MyStudent {
        private int id;

        public void regist(int id) throws Exception {
            if (id > 0) {
                this.id = id;
            } else {
                //手动抛出异常
                throw new RuntimeException("你的输入非法");
                //也可以
                //throw  new Exception("你的输入非法");
            }
        }

    }

运行结果

6、用户自定义异常类

使用继承实现

package com.learn.exception;

public class MyException extends RuntimeException {
    public static void main(String[] args) {
        try {
            MyStudentCh stu1 = new MyStudentCh();
            stu1.regist(-10001);
        } catch (Exception e) {
            // e.printStackTrace();
            System.out.println(e.getMessage());
        }
    }

    //模仿(唯一标识作用)
    static final long serialVersionUID = -7034897190745766999L;
    public MyException(){

    }
    public MyException(String msg){
        super(msg);
    }
}
class MyStudentCh {
    private int id;

    public void regist(int id) throws Exception {
        if (id > 0) {
            this.id = id;
        } else {
            //用自己定义的异常类
            System.out.println("使用了自定义异常类");
            throw new MyException("你的输入特别非法");
        }
    }
}

运行结果