java进阶7——异常

异常产生&异常处理

异常概述

• 异常的体系结构

Throwable（最顶层）
    Error:出现的不能够处理的严重问题
    Exception:可以处理的问题

就是java程序在运行时期发生的问题。
在Java中，把异常信息封装成了一个类。当出现了问题时，就会创建异常类对象并抛出异常相关的信息（如异常出现的位置、原因等）。
在Java中使用Exception类来描述异常。

Exception类继承自Throwable这个类，Throwable类也是异常的最顶层类，其下有一个和Exception类同级的类Error，Error表示java程序在运行过程中出现的错误，也就是说，只有修改代码才能够解决

异常处理

• JVM默认处理方式
  如果出现异常我们没有处理，jvm会帮我们进行处理，他会把异常的类型，原因还有位置显示在命令行并且还终止了程序，异常后面的代码将不在执行
• 捕捉处理

try {
    // 需要被检测的语句。
}
catch(异常类 变量) { 
    // 异常的处理语句
}
finally {
    // 一定会被执行的语句。
}

通过try…catch来对一场进行捕捉，将有可能发生异常的代码写入try的代码块中，如果发生异常，则执行catch代码块中的内容，如果try中代码没有发生异常，则不会执行catch代码块中的内容，但是finally代码块中的内容，不论有没有异常发生，都会被执行，按照顺序执行的方式
- try…catch的执行顺序：

首先执行try语句
    如果发现异常，异常下面的代码不再执行，直接跳入catch语句中，catch语句结束后，整个try...catch结束
    如果没有发现异常，try语句执行结束后，try...catch直接结束， 不再执行catch语句，然后执行finally中内容

• 抛出处理
  通过throws关键字，将异常抛出

权限修饰符 返回值类型  方法名(形参列表) throws 异常类型1,异常类型2….{
}  

• 多异常处理
  A:对代码进行异常检测，并对检测的异常传递给catch处理。对每种异常信息进行不同的捕获处理。

void show() { // 不用throws 
    try{
        throw new Exception();// 产生异常，直接捕获处理
    }catch(XxxException e){
        // 处理方式 
    }catch(YyyException e){
        // 处理方式 
    }catch(ZzzException e){
        // 处理方式 
    }
}

注意:这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。

Throwable常用方法&自定义异常

Throwable常用方法

String getMessage(); // 返回此 throwable 的详细消息字符串
String toString(); // 返回此 throwable 的简短描述
void printStackTrace(); // 打印异常的堆栈的跟踪信息

public static void main(String[] args) {
    try {
        System.out.println(2 / 0);
    } catch (ArithmeticException e) {
        // String getMessage() : 原因
        System.out.println(e.getMessage());
        // 打印结果：/ by zero

        // String toString() 类型和原因
        System.out.println(e.toString());
        // 打印结果：java.lang.ArithmeticException: / by zero

        // void printStackTrace():类型原因和位置
        e.printStackTrace();
        /* 打印结果：java.lang.ArithmeticException: / by zero
        *          at com.bsw.exceptionDemo.ExceptionDemo.main(ExceptionDemo.java:6)
        */
    }
}

finally的概述和应用场景

• finally使用格式:

try {
    代码
} catch(异常类型 异常变量) {
    异常处理语句
} finally {
   //释放资源的代码
}

编译时异常&运行时异常

• 编译时异常
  编译时异常出现在书写代码的时候，是Exception的子类，非RuntimeExcpetion的子类，一般的编程工具就会报错，程序是无法被运行起来的，有两种处理方式，一种抛出，一种捕捉，如果不处理，程序就运行不成功
• 运行时异常
  当程序运行时出现的异常，只有程序运行起来才会发现，RuntimeException和他的所有子类异常,都属于运行时期异常，简单来说，能在控制台显示的异常都是运行时异常，运行时异常一旦出现，必须修改源代码，否则无法解决。

自定义异常

• 自定义一个异常类
  写一个类去继承Exception或者RuntimeException，然后实现多个构造即可

public static void main(String[] args) throws MyExecption, MyExecption2 {
    int i = 10;

    if (i < 0) {
        throw new MyExecption("这个值小于0");
    } else {
        throw new MyExecption2("这个值大于0");
    }
}

// 自定义异常类2
public class MyExecption2 extends Exception {

    public MyExecption2(String string) {
        System.out.println(string);
    }
}

// 自定义异常类1
public class MyExecption1 extends Exception {

    public MyExecption1(String string) {
        System.out.println(string);
    }
}

递归

递归的概述

• 递归，指在当前方法内调用自己的这种现象

public void method(){
    System.out.println(“递归的演示”);
    // 在当前方法内调用自己
    method();
}

• 案例：求5的阶乘

public static void main(String[] args) {
    System.out.println(jiecheng(2));
}

public static int jiecheng(int i) {
    if (i == 1) {
        return 1;
    } else {
        return i * jiecheng(i - 1);
    }
}

• 递归注意事项：
  递归一定要有出口，内存溢出
  递归次数不宜过多，内存溢出