Exception-CFANZ编程社区

异常简介

错误：程序运⾏时发⽣的不被期望的事件，阻⽌了程序按照预期正常执⾏

常⻅程序错误分三类: 
    编译错误：新⼿最常⻅，没遵循语法规范
    运⾏时错误：程序在执⾏时
    逻辑错误：程序没有按照预期的逻辑顺序执⾏

Java.lang软件包中有⼀个java.lang.Throwable类，这个类是java中所有错误和异常的超类，Throwable类有两个⼦类，Error与 Exception

Error

是Throwable 的⼦类，包含⼤量⼦类
出错后程序⽆法处理，如OutOfMemoryError

Exception

是Throwable 的⼦类，包含⼤量⼦类
程序本身可以处理的异常，如ArrayIndexOutOfBoundException

异常类型

可查异常（编译器要求必须处置的异常）：RuntimeException及其⼦类以外，其他的Exception类及其⼦类, 如 IOException和ClassNotFoundException
不可查异常(编译器不要求强制处置的异常): 包括运⾏时异常（RuntimeException与其⼦类）和错误（Error），如ArrayIndexOutOfBoundsException

Exception_java

内置异常

可查异常（必须要在⽅法⾥⾯捕获或者抛出）
    ClassNoFoundException 应⽤程序试图加载类，找不到对应的类
    IllegalAccessException 拒绝访问⼀个类的时候
    NoSuchFieldExcetion 请求的变量不存在
    NoSuchMethodException ⽅法不存在

不可查异常
    ArrayIndexOutOfBoundsException 数组索引越界
    ClassCastException 强制失败抛出异常
    NullPointerException 需要对象的地⽅使⽤ null 时，抛出该异常
    NumberFormatException 将字符串转换成⼀种数值类型，但该字符串不能转换为适当格式时，抛出该异常

Throwable类核⼼⽅法

public String getMessage()
    异常的详细信息

public Throwable getCause()
    异常原因

public void printStackTrace()
    打印错误的堆栈信息，即错误输出流，可以看到错误原因和所在位置

public StackTraceElement [] getStackTrace()
    堆栈层次的数组，下标为0的元素代表栈顶，最后⼀个元素代表⽅法调⽤堆栈的栈底

# 如下
public class ExceptionTest {

    public static void main(String [] args){
        try{
            int result = 25/0;
            System.out.println(result);
        }catch (Exception e){
            String msg = e.getMessage();
            StackTraceElement [] arr = e.getStackTrace();
            e.printStackTrace();
        }
    }

}

# 控制台
java.lang.ArithmeticException: / by zero
    at chapter7_2.ExceptionTest.main(ExceptionTest.java:7)

捕获异常

try{
   // 可能发⽣异常的代码
}catch(AExceptionName e){
   //出异常的时候处理
}catch(BExceptionName e){

}fianall{
 
}

try后⾯跟⼀个或多个catch块，或⼀个finally块，或两者的组合
catch 不能独⽴于 try ⽽单独存在
如果代码没有对应的异常类进⾏捕获，则默认打印异常堆栈

# 如下
public class Exceotion2Test {

    public static void main(String [] args){
            test();
    }

    public static void test(){
        try {
            Student student = new Student();
            student.setAge(-1);
        }catch (NullPointerException e){
            System.out.println("出异常了 NullPointerException");
        }catch (IllegalArgumentException e){
            System.out.println("出异常了 IllegalArgumentException");
        }
    }

}

多重异常捕获

⼀个 try 代码块后⾯跟多个 catch 代码块的情况就叫多重捕获
代码中发⽣异常，异常被抛给第⼀个 catch 块, 如果不匹配则继续往下⼀个catch进⾏传递

try{
   // 可能发⽣异常的代码
}catch(ExceptionName1 e1){
   //出异常的时候处理
}catch(ExceptionName2 e2){
   //出异常的时候处理
}

finally关键字

⽤来创建在 try 代码块后⾯执⾏的代码块
finally 代码块中的代码总会被执⾏
⼀般⽤于资源回收释放等操作

try、catch和finally块有两种可能的组合:try-catch-finally或try-finally

try{
   // 可能发⽣异常的代码
}catch(ExceptionName1 e1){
   //出异常的时候处理
}finally{
   //肯定执⾏的代码
}

try{
   // 可能发⽣异常的代码
}finally{
   //肯定执⾏的代码
}

# 如下
public class TestException3 {

    public static void main(String [] args){
       int result =  divide(25,0);
       System.out.println("最终结果="+result);
    }


    public static int divide(int num1, int num2){
        try {
            int result = num1/num2;
            return result;
        }catch (Exception e){
            System.out.println("出异常");
        }finally {
            System.out.println("finally执行了");
            return -2;
        }
    }
    
}

# 控制台
出异常
finally执行了
最终结果=-2

throws/throw关键词

throws 声明异常 往外抛出
throws⼦句放在⽅法参数列表的右括号之后，⼀个⽅法可以声明抛出多个异常，多个异常之间⽤逗号隔开
# 如下方式抛出异常
public class Main {
   public static void readChar() throws IOException,RemoteException {
       int input = System.in.read(); 
   }  
}

try catch中捕获了异常，处理⽅法
捕获⾃⼰处理然后继续往外⾯抛异常
# 如下方式抛出异常
throw new ExceptionName("异常信息");

# 如下
public class TestException5 {

    public static void main(String [] args)throws Exception{
        int  result = divide(25,0);
    }

    public static int  divide(int num1, int num2)throws Exception{
        try {
            int result = num1/num2;
            return result;
        }catch (Exception e){
            System.out.println("出异常了");
            throw new Exception("参数异常");
        }
    }

}

# 控制台
出异常了
Exception in thread "main" java.lang.Exception: 参数异常
   at chapter7_5.TestException5.divide(TestException5.java:15)
   at chapter7_5.TestException5.main(TestException5.java:6)

自定义异常

public class UserNotEnoughException extends Exception {

    private int code;

    private String msg;

    public UserNotEnoughException(){
        super();
    }

    public UserNotEnoughException(int code, String msg){
        super(msg);
        this.code = code;
        this.msg = msg;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public int getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

public class CustomExceptionTest {

    public static void main(String [] args){
        try{
            test();
        }catch (NullPointerException e){
            e.printStackTrace();
        }catch (UserNotEnoughException e){
          int code =  e.getCode();
          String msg = e.getMsg();
          e.printStackTrace();
          System.out.println("code="+code  + ", msg="+msg);
        }
    }

    // 抛出异常
    public static void test()throws UserNotEnoughException{
        throw new UserNotEnoughException(-1,"人员不够异常");
    }

}

# 控制台
chapter7_6.UserNotEnoughException: 人员不够异常
    at chapter7_6.CustomExceptionTest.test(CustomExceptionTest.java:22)
    at chapter7_6.CustomExceptionTest.main(CustomExceptionTest.java:10)
code=-1, msg=人员不够异常