JAVA 异常处理

1 java的异常处理机制

java中所有异常的超类为Throwable,其下派生了两个子类型：Error和Exception

Error表示系统错误，通常是不能在程序运行期间被解决的错误。

Exception表示程序级别的错误，通常是由于逻辑等导致的问题，可以在程序运行期间被解决。

1.1

异常处理机制中的try-catch

语法：

try{

可能出现异常的代码片段

}catch(XXXXXXXException e){

try语句块中出现XXXXXXXXEception后的解决办法

}

public class TryCatchDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了....");
        try {
//          System line = null;
//        String line = "";
            String line = "a";
            System.out.println(line.length());
            System.out.println(line.charAt(0));
            System.out.println(Integer.parseInt(line));
        }catch (NullPointerException | StringIndexOutOfBoundsException e ){
            System.out.println("两种异常的统一解决办法");
        }catch ( Exception e){
            System.out.println("通用错误的解决办法！");
        }
        System.out.println("程序结束了...");
    }
}

1.2

异常处理机制中的finally块

finally块是异常处理机制的最后一块，它可以跟在try之后或者最后一个catch之后。

finally可以保证只要程序执行到try语句块中，无论try中是否出现异常，finally最终都会必定执行。

通常我们将释放资源这类操作放在finally中确保运行，例如IO操作后最终的close()调用。

public class FinallyDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了");
        try {
            String line = "abc";
            System.out.println(line.length());
            //try语句块中出错代码以下的内容均不执行!
            System.out.println("!!!!!");
            return;
        }catch(Exception e){
            System.out.println("出错了!");
        }finally {
            System.out.println("finally中的代码执行了!");
        }
        System.out.println("程序结束了");
    }
}

1.3  异常处理机制在IO中的使用，finally在IO中通常用来关闭流

public class FinallyDemo2 {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("fos.dat");
            fos.write(1);
        }catch(IOException e){
            e.printStackTrace();
        }finally {
            try {
                if(fos!=null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

1.4

JDK7之后，java推出了一个自动关闭特性。

可以在异常处理机制中用更精简的写法完成IO的关闭操作

public class AutoCloseableDemo {
    public static void main(String[] args) {
        try(
                /*
                    只有实现了java.io.AutoCloseable接口的类才可以在这里定义并初始化
                    编译器在编译代码的时候最终会将在这里定义的类在finally中调用close()关闭
                    注:最终编译完的样子可以参考FinallyDemo2.java的样子。
                 */
                FileOutputStream fos = new FileOutputStream("fos.dat");
        ){
            fos.write(1);
        }catch(IOException e){
            e.printStackTrace();
        }
    }
}

2. 异常的抛出

2.1 throw关键字可以主动对外抛出一个异常

通常: 1:程序出现了异常，但是该异常不应当在当前代码块中被解决时，可以主动将其抛出去

         2:程序可以运行，但是以不满足业务场景要求时可以当作异常抛出去

2.2  自定义异常

通常用于那些满足语法但是不满足业务场景时的错误。

自定义异常要做如下操作:

1:类名要做到见名知义

2:要继承自Exception(直接或间接继承都可以)

3:提供超类异常支持的所有构造器 年龄不合法异常

public class IllegalAgeException extends Exception{
    public IllegalAgeException() {
    }

    public IllegalAgeException(String message) {
        super(message);
    }

    public IllegalAgeException(String message, Throwable cause) {
        super(message, cause);
    }

    public IllegalAgeException(Throwable cause) {
        super(cause);
    }

    public IllegalAgeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

public class Person {
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) throws IllegalAgeException {
        if(age<0||age>100){
//            throw new RuntimeException("年龄不合法");
            /*
                当我们使用throw主动对外抛出一个异常时，除了RuntimeException之外
                其他异常抛出时必须在方法上使用throws声明该异常的抛出
             */
//            throw new IllegalAgeException("年龄不合法");
        }
        this.age = age;
    }
}

public class ThrowDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了");

        Person p = new Person();
        //满足语法但是不满足业务场景

            /*
                当我们调用一个含有throws声明异常抛出的方法时，编译器要求我们必须处理
                这个异常，否则编译不通过。
                处理方式有两种:
                1:使用try-catch主动捕获并处理这个异常
                2:使用throws继续将该异常声明抛出
             */
        try {
            p.setAge(1000);
        } catch (IllegalAgeException e) {
            e.printStackTrace();
        }


        System.out.println("此人年龄:"+p.getAge());

        System.out.println("程序结束了");
    }
}

2.3  子类重写超类含有throws声明异常抛出的方法时，

      对throws的重写规则

允许仅抛出部分异常

允许不再抛出任何异常

允许抛出超类方法抛出异常的子类型异常

不允许抛出额外异常:超类没有的，且没有继承关系的

不允许抛出超类方法抛出异常的超类型异常

public class ThrowsDemo {
    public void dosome()throws IOException, AWTException {}
}

class SubClass extends ThrowsDemo{
//    public void dosome()throws IOException, AWTException {}

    //允许仅抛出部分异常
//    public void dosome()throws IOException{}

    //允许不再抛出任何异常
//    public void dosome(){}

    //允许抛出超类方法抛出异常的子类型异常
//    public void dosome()throws FileNotFoundException {}

    //不允许抛出额外异常:超类没有的，且没有继承关系的
//    public void dosome()throws SQLException {}

    //不允许抛出超类方法抛出异常的超类型异常
//    public void dosome()throws Exception {}
}