java学习之旅（day.12）

异常机制（Exception）

异常指程序运行中出现的不期而至的各种状况

异常分类：

• 检查性异常：用户输入错误引起的异常
• 运行时异常：写的时候未报错，但一运行就会报错，
• 错误（error）：错误不是异常，而实脱离程序员控制的问题，错误在代码中通常被忽略。如：当栈溢出时，一个错误就发生了，但在编译时是检查不到的

异常体系结构

java把异常当作对象来处理，并定义了一个基类java.lang.Throwable作为所有异常的超类

javaAPI中定义的异常分为2大类：错误（error）和异常（Exception）

Error：

• Error类对象有java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关
• java虚拟机运行错误（Virtual MachineError），当JVM不再有执行操作所需的内存资源时，将出现OutOfMemoryError。这些异常发生时，java虚拟机JVM一般会选择线程终止
• 发生在虚拟机试图执行应用时发生的错误，如：类定义错误（NoClassDefFoundError）、链接错误（LinkageError）。这些错误是不可查的，因为他们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况

Exception

• 在Exception分支中有一个重要的子类RuntimeException（允许是异常）如：

​

捕获和抛出异常

异常处理的5个关键字

try catch finally throw(手动抛出异常) throws（方法抛出异常）

package com.exception;

public class Test {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        //怎么捕获异常并返回一些信息
        try {//打try后自动生成的代码块，try可以监控区域
            //假设可以明显的判断下面第二行错误
            if(b==0){//可以选择主动抛出异常throw
               throw new ArithmeticException();//通过throw关键字new一个异常,主动抛出异常，但是这个主动抛出异常只在方法中使用，见Test3

            }
           new Test().a();
           System.out.println(a/b);
        }catch(Throwable e){//catch(ArithmeticException e){//catch捕获异常，ArithmeticException是异常的类型
            System.out.println("程序出现异常，变量b不能为0");//可以写多个catch，捕获多个异常，层层递进，但根据图123大的要在下方，如throwable应在最下
        }finally{//最后处理善后工作。程序出不出异常都会执行finally
            System.out.println("finally");
        }
//finally可以不要，try catch必须要有
    }
    //再写个方法a中调用b，b中调用a
    public void a() {
        b();
    }
    public void b(){
        a();

    }
}
===================================================
    package com.exception;

public class Test2 {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        try {
            System.out.println(a/b);//选中当前这行代码，ctrl alt+t 选try catch finally会自动生成trycatch语句
        } catch (Exception e) {
            e.printStackTrace();//打印错误的栈信息
        } finally {
        }

    }
}
==================================================
    package com.exception;

public class Test3 {
    public static void main(String[] args) {
        //调用下面的test方法
        try {
            new Test3().test(1,0);//直接使用匿名内部类.test,并传参数a=1，b=0
        } catch (ArithmeticException e) {
            e.printStackTrace();
        } finally {
        }

    }
    //定义一个方法，在方法中使用主动抛出
    //假设这个方法中处理不了这个异常，还可以直接往外抛（在方法上抛出异常）
    public void test(int a,int b) throws ArithmeticException{//但是这样的话需要将其捕获
        if(b==0) {
            throw new ArithmeticException();//主动抛出异常一般在方法中使用
        }
        //System.out.println(a/b);方法体用不用无所谓
    }
}
/*
package com.exception;

public class Test3 {
    public static void main(String[] args) {
        //调用下面的test方法
        new Test3().test(1,0);//直接使用匿名内部类.test,并传参数a=1，b=0

    }
    //定义一个方法，在方法中使用主动抛出
    public void test(int a,int b){
        if(b==0) {
            throw new ArithmeticException();//主动抛出异常一般在方法中使用
        }
        //System.out.println(a/b);方法体用不用无所谓
    }
}
 */

自定义异常

用的并不多，了解

使用java内置的异常类可以描述在编程时出现的大部分异常情况，除此外，用户还可以自定义异常，用户自定义异常只需要继承Exception类即可

自定义异常步骤：

1. 创建自定义异常类
2. 在方法中通过throw关键字抛出异常对象
3. 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理，否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作
4. 在出现异常方法的调用使用者中捕获并处理异常

package com.exception.demo02;
//自定义的异常类
public class MyException extends Exception{
    //传递数字>10就抛出异常
    private int detail;
//构造器
    public MyException(int a) {
       this. detail=a;
    }
    //用toString打印上面的信息
//异常的打印信息
    @Override
    public String toString() {
        return "MyException{" +
                "detail=" + detail +
                '}';
    }
}

package com.exception.demo02;
//写一个测试类，测试下刚写的异常
public class Test {
    //要先写一个可能存在异常的方法
    static void test(int a) throws MyException{
        System.out.println("传递的参数为："+a);
        if (a>10){
            throw new MyException(a);
           /* try {
                throw new MyException(a);//抛出,只写这一句会报错要么在下一行用捕获，要么用throws抛出
            } catch (MyException e) {
                e.printStackTrace();
            }
*/

        }
        System.out.println("OK");
    }

    public static void main(String[] args) {
        try {
            test(101);
        } catch (MyException e) {
            System.out.println("MyException=>"+e);
        }
    }
}