Java 异常类及异常处理简单概念

异常也称为例外，是在程序运行过程中发生的、会打断程序正常执行的事件，下面是几种常见的异常：
1. 算术异常（ ArithmeticException）。
2. 没有给对象开辟内存空间时会出现空指针异常（ NullPointerException）。
3. 找不到文件异常（ FileNotFoundException）。
当异常发生时，通常可以用两种方法来处理，一种是交由 Java 默认的异常处理机
制做处理。但这种处理方式， Java 通常只能输出异常信息，接着便终止程序的运行。Java 的异常处理机制也秉承着面向对象的基本思想。在 Java 中，所有的异常都是以类的类型存在，除了内置的异常类之外， Java 也可以自定义的异常类。此外， Java的异常处理机制也允许自定义抛出异常。
异常处理是由 try、 catch 与 finally 三个关键字所组成的程序块，其语法如下：

语法是依据下列的顺序来处理异常：
1、 try 程序块若是有异常发生时，程序的运行便中断，并抛出“异常类所产生的对象”。
2、 抛出的对象如果属于 catch()括号内欲捕获的异常类，则 catch 会捕捉此异常，然后进到 catch 的块里继续运行。
3、 无论 try 程序块是否有捕捉到异常，或者捕捉到的异常是否与 catch()括号里的异常相同，最后一定会运行 finally 块里的程序代码。finally 的程序代码块运行结束后，程序再回到 try-catch-finally 块之后继续执行。
try语句块不能单独使用，后面必须跟一个catch块或者finally块

异常类的继承架构

习惯上将 Error 与 Exception 类统称为异常类，但这两者本质上还是有不同的。Error
类专门用来处理严重影响程序运行的错误，可是通常程序设计者不会设计程序代码去
捕捉这种错误，其原因在于即使捕捉到它，也无法给予适当的处理，如 JAVA 虚拟机
出错就属于一种 Error。
不同于 Error 类， Exception 类包含了一般性的异常，这些异常通常在捕捉到之后
便可做妥善的处理，以确保程序继续运行。
从异常类的继承架构图中可以看出： Exception 类扩展出数个子类，其中
IOException、 RunntimeException 是较常用的两种。 RunntimeException 即使不编写异
常处理的程序代码，依然可以编译成功，而这种异常必须是在程序运行时才有可能发生，例如：数组的索引值超出了范围。
与 RunntimeException 不同的是，IOException一定要编写异常处理的程序代码才行，它通常用来处理与输入/输出相关的操作，如文件的访问、网络的连接等。当异常发生时，发生异常的语句代码会抛出一个异常类的实例化对象，之后此对象与 catch 语句中的类的类型进行匹配，然后在相应的 catch 中进行处理。

抛出异常

抛出（ throw）异常，以及如何由 try-catch 来接收所抛出的异常。抛出异常有下列两种方式：
1、 程序中抛出异常
2、 指定方法抛出异常

程序中抛出异常

在程序中抛出异常时，一定要用到 throw 这个关键字，其语法如下：
throw 异常类实例对象 ；

public class TestException7_4 {
    public static void main(String args[]) {
        int a = 4, b = 0;
        try

        {
            if (b == 0)
                throw new ArithmeticException("一个算术异常"); // 抛出异常
            else
                System.out.println(a + "/" + b + "=" + a / b);// 若抛出异常，则执行此行
        } catch (ArithmeticException e) {
            System.out.println("抛出异常为： " + e);
        }
    }
}

指定方法抛出异常

如果方法内的程序代码可能会发生异常，且方法内又没有使用任何的代码块来捕捉这些异常时，则必须在声明方法时一并指明所有可能发生的异常，以便让调用此方法的程序得以做好准备来捕捉异常。也就是说，如果方法会抛出异常，则可将处理此异常的 try-catch-finally 块写在调用此方法的程序代码内。
如果要由方法抛出异常，则方法必须以下面的语法来声明:
方法名称（参数…） throws 异常类 1，异常类 2， …

package dd20161115;



public class ExceptionDome {
    public static void main(String[] args)  {
    int a=4,b=0;
    //在调用抛出异常的方法中捕获异常
    try {
        add(a,b);
    } catch (Exception e) {
        // TODO Auto-generated catch block
        System.out.println(e);
        //处理异常，添加默认值
        try {
            add(1,1);
        } catch (Exception e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
    }
    }

    public static void add(int a,int b) throws Exception{
        int c=a/b;
        System.out.println("c="+c);
    }
}

输出结果：
java.lang.ArithmeticException: / by zero
c=1

也就是说在调用用 throws 抛出异常的方法时，可以将此异常在方法中再向上传递，而 main()方法是整个程序的起点，所以如果在 main()方法处如果再用 throws 抛出异常，则此异常就将交由JVM 进行处理了。

编写自己的异常类

为了各种异常， Java 可通过继承的方式编写自己的异常类。因为所有可处理的异常类均继承自 Exception 类，所以自定义异常类也必须继承这个类。自己编写异常类的语法如下:
class 异常名称 extends Exception
{
… …
}

在 JDK 中提供的大量 API 方法之中含有大量的异常类，但这些类在实际开发中往往并不能完全的满足设计者对程序异常处理的需要，在这个时候就需要用户自己去定义所需的异常类了，用一个类清楚的写出所需要处理的异常。

总结

1、 程序中没有处理异常代码时， Java 的默认异常处理机制会做下面的操作：
（ 1）、 抛出异常。
（ 2）、 停止程序运行。
2、 异常处理是由 try、 catch 与 finally 三个关键字所组成的程序块。
3、 try 程序块中若有异常发生时，程序的运行便会中断，抛出“由系统类所产生的对象”，并依下列的步骤来运行：
（ 1）、 抛出的对象如果属于 catch()括号内所要捕捉的异常类， catch 会捕捉此异
常，然后进到 catch 程序块里继续执行。
（ 2）、 无论 try 程序块是否捕捉到异常，也不管捕捉到的异常是否与 catch()括
号里的异常相同，最后都会运行 finally 块里的程序代码。
（ 3）、 finally 中的代码是异常的统一出口，无论是否发生异常都会执行此段代
码。
4、 当异常发生时，有两种处理方式：
（ 1）、 交由 Java 默认的异常处理机制去处理。
（ 2）、 自行编写 try-catch-finally 块来捕捉异常。
5、 异常可分为两大类： java.lang.Exception 与 java.lang.Error 类。
6、 RunntimeException 可以不编写异常处理的程序代码，依然可以编译成功，它是在
程序运行时才有可能发生的；而其它的 Exception 一定要编写异常处理的程序代
码才能使程序通过编译。
7、 catch()括号内，只接收由 Throwable 类的子类所产生的对象，其它的类均不接收。
8、 抛出异常有下列两种方式：
（ 1）、 在程序中抛出异常。
（ 2）、 指定方法抛出异常。
9、 程序中抛出异常时，要用到 throw 这个关键字。
10、如果方法会抛出异常（使用 throws），则可将处理此异常的 try-catch-finally 块写在调用此方法的程序代码中。