Java学习笔记 -异常

异常概述

• 异常在java中以类的形式存在，每一个异常类都可以创建异常对象
• 当异常发生的时候，JVM就会创建对应的异常类对象，然后抛出异常

java异常类的组织结构

• Object: Throwable

• Throwable: Error(错误) & Exception(异常)

  Error (JVM直接退出) : 
        例如 StackOverflowError          
  Exception (JVM可以继续运行) :
        ExceptionSubClass： Exception的直接子类、编译时异常或者受控异常；例如：文件打开 数据库链接
        RunTimeException：运行时异常或者非受控异常； 例如：NullPointerException   ClassCastException
  

• 编译时异常：发生概率较高，一般可以预料异常的发生,所以在程序编写时必须要预先对其进行处理

• 运行时异常：发生概率较低，一般难以预料其发生，编写程序处理代价较高，可适当编写程序处理

异常的处理方法

1.异常处理一：向上抛

• throws 可以抛当前异常的父类
• throws 后面可以跟多个异常，使用逗号隔开
• 不建议在main方法上使用throws，因为这个这个异常会抛给JVM，如果产生了异常，那么程序就会终止
• 使用throws的方式，出现异常之后，异常之后的代码不会执行，相当于return语句

2.异常处理二：捕捉

• 使用try..catch语句对异常进行捕捉

• 在try语句中出现异常，try语句块中异常之后的代码也不会执行

• catch语句的参数：从上到下必须遵循从小到大的原则，最好每一个catch精确处理每一类异常

• 在finally子句中的代码是最后执行的，并且是一定会执行的，即使try语句块出现了异常也会执行

• 所以在诸如流、链接的关闭，在finally中写，不管异常是否出现，finally语句块中的代码都会执行。

示例程序：

public class ExceptionTest01 {
     public static void main(String[] args) {
        //第二种处理方式：捕捉
        try{
           doSome();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    
    //第一种处理方法：向上抛
    //ClassNotFoundException的直接父类是Exception，编译时异常
    public static void doSome() throws ClassNotFoundException{
        System.out.println("......");
    }
}

finally语句的使用：

public class ExceptionTest04 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis =new FileInputStream("D:\\biangcheng");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            //在finally语句中关闭：无论try语句是否出现异常，close都能执行
            if(fis != null)
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

异常常用方法

1.获取异常简单的描述信息：

• String msg = exception.getMessage();

2.打印异常追踪的堆栈信息：

• exception.printStackTrace();

示例程序：

public class ExceptionTest03 {
    public static void main(String[] args) {
        //有参构造
        NullPointerException e = new NullPointerException("空指针异常！！！！！");

        //获取异常简单的描述信息
        String msg = e.getMessage();
        System.out.println(msg);

        //打印异常追踪的堆栈信息
        //java后台打印异常堆栈追踪信息的时候，采用了异步线程的方式打印的
        e.printStackTrace();

        System.out.println("Hello World!!");

        System.out.println("-----------------------------------");
        try {
            m1();
        } catch (FileNotFoundException e1) {
            //打印异常堆栈追踪信息。这行代码要写上，养成好习惯
            e1.printStackTrace();
        }
    }

    public static void m1() throws FileNotFoundException {
        new FileInputStream("D:\\biancehng\\java\\Test.java");
    }
}

异常在实际开发中的使用 -自定义异常

• 程序中一些错误发生的时候，不是采用输出错误信息的方式，而是更规范的选择抛出异常的方式
• 语法：throw 异常对象;

示例程序：

public class MyStackException extends Exception{
    public MyStackException(){

    }

    public MyStackException(String s){
        super(s);
    }
}

public class Stack01 {
    private Object[] oArray;
    private int size;
    private int u;

    public Stack01() {
    }

    public Stack01(int size) {
        oArray = new Object[size];
        this.size = size;
        this.u = 0;
    }
    public void push (Object t) throws MyStackException{
        if(u == size){
            throw new MyStackException("栈满");
        }
        else{
            oArray[u++] = t;
        }
    }
    public Object pop() throws MyStackException{
        if(u == 0) {
            throw new MyStackException("栈空");
        }else
            return oArray[--u];
    }
}

public class Test {
    public static void main(String[] args) {
        Stack01 s1 = new Stack01(2);
        try {
            s1.push(12);
            s1.push(14);
            s1.push(33);
        } catch (MyStackException e) {
            e.printStackTrace();
        }

        try{
            System.out.println(s1.pop());
            System.out.println(s1.pop());
            System.out.println(s1.pop());
        } catch (MyStackException e){
            e.printStackTrace();
        }
    }
}