Java异常

Java中的异常我们经常会见到，现在就让我们来学习Java中宏大的异常类。

 异常：在Java语言中，将程序执行中发生的不正常情况称为“异常”。
 Java程序在执行过程中所发生的异常(运行时一切不正常情况)事件可分为两类：
 Error: Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。一般不编写针对性的代码进行处理。
 Exception: 其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如：
访问数组下标越界
试图读取不存在的文件
网络连接中断

 下面我们来简单认识几个异常。

1.数组越界异常

        int[] a  = new int[5];
        a[5]= 10;                //数组越界异常

2. 算数异常

        int a = 10;
        int b = 0;
        int c = a/b;  //算术异常

3. 空指针异常

  String s = null;  
               s.length();      //空指针异常

 4.类转换异常

       Object s = "abc";
       Integer i = (Integer) s;   //类转换异常

 5.数字格式化异常

new Integer("1a0");  //数字格式化异常

 以上介绍的一些异常使我们比较经常能遇见的异常，而且当代码碰到异常时，下面哪怕是没有异常的代码也不会再运行。

异常的体系

Throwable类有两个直接子类：Exception类、Error类。Error表示错误，可能是编译期错误或者系统错误，往往程序中并不处理。Exception表示异常，是所有异常类的父类，是程序员所关心的。

 异常分为运行期异常和编译期异常两种
 运行期异常：程序运行时抛除的异常，所有RuntimeException的子类都是运行期异常

例如：数学异常     空指针异常    数组下标越界 等等。

 编译期异常(Checked Exception)：除去运行期的异常都是编译期异常，也称为检测异常

例如：IOException    SQLException 等等。

那么既然Java中为我们提供了如此宏大的异常类，碰到异常我们该如何解决呢？

对于这些异常，一般有两种解决方法：一是遇到异常就终止程序的运行。 另一种方法是由程序员在编写程序时，就考虑到异常的检测、异常消息的提示，以及异常的处理。
捕获异常最理想的是在编译期间，但有的异常只有在运行时才会发生。
比如：除数为0，数组下标越界等
分类：编译时异常和运行时异常

Java的异常处理是通过5个关键字来实现的：try、catch、finally、throw、throws

其中前三个try、catch、finally是一种处理方式中的三个关键字。

try：检测不安全的代码块（发现异常）
try块中任何一条语句发生了异常，下面的代码将不会被执行，程序将跳转到异常处理代码块中，即catch块。因此，不要随意将不相关的代码放到try块中，因为随时可能会中断执行。

catch：把抓到的类型匹配的异常捕获，保证程序能继续运行下去catch语句必须紧跟着try语句之后，称为捕获异常，也就是异常处理函数，一个try后面可以写多个catch，分别捕获不同类型的异常，要从子类往父类的顺序写，否则有编译错误

finally是该内容总是会执行的，只能有一个finally语句。

下面我们举个代码示例来讲解一下这三个关键字。

 

 

 这段代码中虽然简短但是有很多要讲的点。

1.我们可以看到在一段try catch语句中 catch语句可以出现很多进行嵌套。

2.本代码中我们在try语句中写出了两种异常第一个是数组空间异常，第二个是算数异常。而我们下面的catch语句中先捕捉的是算数异常。然后我们看结果发现，算数异常根本没有处理，直接先处理了try语句中的数组空间异常。

3.无论如何finally语句中的内容是必定会执行的，而且在catch语句之后，且只能有一个finally语句

4.当我们不知道可能会碰到什么异常时，可以直接使用Exception e当catch语句中的形参。

我们下面来再见一段代码。

try {
            int a = 10;
            int b = 0;
            int c = a / b;
            new Integer("a");
        } catch (NumberFormatException n) {
            n.printStackTrace();
            System.out.println("数字格式不正确" + n.getMessage());
        } finally {//无论是否出现异常,都会执行finally代码块
            System.out.println("bbbbbbbbbbbbbbbb");
        }

  1.无论是否捕捉到异常，finally语句始终会运行。图中是算数异常，但catch中并没有捕捉算数异常，所以catch语句中的内容没有运行。

  2.这里可以看到异常中的两个方法，一个printStackTrace（）方法，另一个是getMessage（）方法。异常类中虽然各种类很多，但是方法很少。printStackTrace（）方法是获取异常类名和异常信息，以及异常出现在程序中的位置，返回值void。而getMessage（）方法，获取异常信息，返回字符串。

我们就用上面代码来举个栗子。

当我们将catch语句中的NumberFormatException改成算数异常ArithmeticException，那么便成功捕捉到了异常。

 

throws关键字

throws,定义一个方法的时候可以使用throws关键字声明,表示此方法不处理异常，而交给方法调用处进行处理。

1 任何方法都可以使用throws关键字声明异常类型，包括抽象方法。
2 子类重写父类中的方法，子类方法不能声明抛出比父类类型更大的异常(针对编译期异常)。
3 使用了throws的方法，调用时必须处理声明的异常，要么使用try-catch，要么继续使用throws声明。

 

public class Sjx {
    public static void main(String[] args)  {
        try{
            test();
        }catch (Exception e){
            e.getStackTrace();
        }

    }
    public static void test1()throws ArithmeticException{
        int i=10/0;

    }
    public static  void test()throws ArithmeticException,ArrayIndexOutOfBoundsException{
        test1();
    }
}

 话不多说直接看代码。

1.throws后面甚至可以抛出多个异常。

2.throws在方法参数列表后面声明此方法可能会出现异常。谁调用此方法,在调用处需要根据情况对象异常是否处理。图中便是test1方法中有异常，我们选择抛出异常。在test方法中调用test1方法时便要求我们处理异常，如果我们还是选择抛出。那么到main方式此时已经是最顶层了,就不能再抛出了,再抛就抛给虚拟机了。 此时在顶层就需要try catch处理。

throw关键字

throw关键字用于显式抛出异常,抛出的时候是抛出的是一个异常类的实例化对象.

在异常处理中，try语句要捕获的是一个异常对象，那么此异常对象也可以自己抛出。

public class Sjx {
    public static void judge(int a,int b,int c) throws JudgeException {
        if(a+b<c){
            throw new JudgeException("不能构成三角形");
        }
    }

    public static void main(String[] args) throws JudgeException {
        judge(1,2,6);
    }
}
public class JudgeException extends Exception{
    public JudgeException() {
    }

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

 

 

 图中代码便是我们自定义了一个异常类，使用throw主动去抛出了自己定义的异常。

这时候我们也知道了，java中原来给我们包装了好多种异常类型，能碰到相应情况时便会主动抛出。

throws和throw的区别

1. throw用于方法体中，用来抛出一个实际的异常对象，使用throw后，要么使用try catch捕获异常，要么使用throws声明异常
2. throws用于方法声明处，用来声明该方法可能发生的异常类型，可以是多个异常类型，用来强制调用该方法时处理这些异常
3. 抽象方法也可以使用throws

自定义异常 

 自定义异常就是自己定义的异常类，也就是API中的标准异常类的直接或间接的子类

 作用：用自定义异常标记业务逻辑的异常，避免与标准异常混淆。

其实我们上面写的那个JudgeException便是自定义的异常。这里有几个值得注意的点。

1.自定义的异常类要继承java给我们准备好的异常类。

2.自定义异常类中往往不写其他方法，只重载需要使用的构造方法

3.在方法中使用throw抛出后,必须在方法中try-catch或throws抛出

编译期异常与运行期异常

Exception体系向下又分为
          编译期异常(检查异常): 没有继承RuntimeException,编译时就强制的要进行处理.
          运行期异常: 继承RuntimeException,在编译期间,可以不用强制处理

 比如说我们前面常举例的算数异常就属于运行期异常，我们写会发现在编译期间并没有报错。没有让我们强制处理。

而当碰到编译期异常，系统便会报错给我们让我们强制处理。