java中的异常

Error和Exception

Error

1.Error类对象由java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关；

2.Java虚拟机运行错误（Virtual MachineError），当JVM不再有继续执行操作所需内存资源时，将出现OutOfMemoryError，这些异常发生时，Java虚拟机一般会选择线程终止；

3.还有发生在虚拟机试图执行应用时，如类定义错误（NoClassDefFoundError）、链接错误（LinkageError）。这些错误是不可查的，因为它们在应用程序和控制处理能力之外，而且绝大多数是程序运行时不允许出现的情况；

Exception

1.在Exception分支中有一个重要的子类RuntimeException(运行时异常)；

2.java提供了两种异常机制。一种是运行时异常(RuntimeExepction)，一种是检查式异常(checked execption)；

检查式异常: 我们经常遇到的IO异常及sql异常就属于检查式异常。对于这种异常，java编译器要求我们必须对出现的这些异常进行catch 所以 面对这种异常不管我们是否愿意，只能自己去写一堆catch来捕捉这些异常；

运行时异常: 我们可以不处理。当出现这样的异常时，总是由虚拟机接管。比如：我们从来没有人去处理过NullPointerException异常，它就是运行时异常，并且这种异常还是最常见的异常之一；

下面是java中几种常见的几种运行时异常

1、ClassCastException(类转换异常)

2、IndexOutOfBoundsException(数组越界)

3、NullPointerException(空指针)

4、ArrayStoreException(数据存储异常，操作数组时类型不一致)

5、BufferOverflowException异常

下面是由java虚拟机提供的运行时异常

AnnotationTypeMismatchException,

ArithmeticException,

ArrayStoreException,

BufferOverflowException,

BufferUnderflowException,

CannotRedoException,

CannotUndoException,

ClassCastException,

CMMException,

ConcurrentModificationException,

DOMException,

EmptyStackException,

EnumConstantNotPresentException,

EventException,

IllegalArgumentException,

IllegalMonitorStateException,

IllegalPathStateException,

IllegalStateException,

ImagingOpException,

IncompleteAnnotationException,

IndexOutOfBoundsException,

JMRuntimeException,

LSException,

MalformedParameterizedTypeException,

MirroredTypeException,

MirroredTypesException,

MissingResourceException,

NegativeArraySizeException,

NoSuchElementException,

NoSuchMechanismException,

NullPointerException,

ProfileDataException,

ProviderException,

RasterFormatException,

RejectedExecutionException,

SecurityException,

SystemException,

TypeConstraintException,

TypeNotPresentException,

UndeclaredThrowableException,

UnknownAnnotationValueException,

UnknownElementException,

UnknownTypeException,

UnmodifiableSetException,

UnsupportedOperationException,

WebServiceException

异常关键字和自定义异常

示例代码如下：

package com.han.base;

/**
 * 异常测试
 */
public class Demo06 {
    public static void main(String[] args) {
        //test1();
        //test2();
        //test3();
        //加上try catch 程序还需继续往下执行，不加程序到这里就停止了
        try {
            test4(1,0);
        } catch (ArithmeticException e) {
            System.out.println("b不能为0");
            //e.printStackTrace();
        }
    }

    public static void test1(){
        int a = 1;
        int b = 0;
        System.out.println(a/b);
    }

    /*
     * try catch finally 捕获异常
     */
    public static void test2(){
        int a = 1;
        int b = 0;
        // CTRL + ALT + T 打开 try catch finally 快捷键
        try {
            System.out.println(a/b);
        } catch (ArithmeticException e) {
            System.out.println("b不能为0");
            //e.printStackTrace();
        } finally {
            System.out.println("finally");
        }
        // finally可以不要，加了里面的代码一定会执行，一般会在finally里面关闭io流之类的操作
    }

    /*
     * 捕获 多个异常情况，注意范围大的异常一定要定义在下面
     */
    public static void test3(){
        int a = 1;
        int b = 0;
        try {
            System.out.println(a/b);
        } catch (Error e) {
            System.out.println("Error");
        } catch (Exception e) {
            System.out.println("Exception");//会打印这个
        } catch (Throwable e) {
            System.out.println("Throwable");
        } finally {
            System.out.println("finally");
        }
    }

    /*
     * 主动抛出一个异常
     */
    public static void test4(int a,int b) throws ArithmeticException{
        if(b==0){
            throw new ArithmeticException();
        }
    }
}

运行结果如下：
test1:

test2:
b不能为0
finally

test3:
Exception
finally

test4:
b不能为0

自定义异常

示例代码如下：

MyException类

package com.han.myexception;

/**
 * 自定义异常
 */
public class MyException extends Exception {
    private int a;

    public MyException(int a) {
        this.a = a;
    }

    @Override
    public String toString() {
        return "MyException{" + "a=" + a + '}';
    }
}

Test类

package com.han.myexception;

/**
 * 运行结果：
 * 传递的参数为11
 * Exception=>MyException{a=11}
 */
public class Test {
    public static void test(int a) throws MyException{
        System.out.println("传递的参数为"+a);
        if(a>10){
            throw new MyException(a);
        }
        System.out.println("ok");
    }

    public static void main(String[] args) {
        try {
            test(11);
        } catch (MyException e) {
            //这里的e打印的就是toString方法里的信息
            System.out.println("Exception=>" + e);
            //e.printStackTrace();
        }
    }
}

实际应用中的经验总结
1.处理运行时异常时，采取逻辑去合理的规避，并同时辅助try-catch处理2.
2.在多重catch后面可以加一个catch（Exception）,防止可能遗漏的异常
3.对于不确定的代码可以加上try-catch，处理潜在的异常
4.尽量去处理异常，切忌不要简单的去调用e.printStackTrace()打印输出
5.具体如何处理异常，要根据不同业务需求和异常类型去决定
6.尽量添加finally语句块去释放占用的资源