黑马程序员——异常Exception

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
异常
在使用计算机语言进行项目开发的过程中，即使程序员把代码写得尽善尽美，在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠代码能够避免的，比如：客户输入数据的格式，读取文件是否存在，网络是否始终保持通畅等等。
异常：在Java语言中，将程序执行中发生的不正常情况称为“异常”。(开发过程中的语法错误和逻辑错误不是异常)
Java程序在执行过程中所发生的异常事件可分为两类：
Error: Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。一般不编写针对性的代码进行处理。

public class TestError {
    public static void main(String[] args) {
        //java.lang.StackOverflowError
        //main(args);
        //java.lang.OutOfMemoryError
        byte[] b = new byte[1024*1024*600];
    }
}

Exception: 其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如：
空指针访问
试图读取不存在的文件
网络连接中断

于这些错误，一般有两种解决方法：一是遇到错误就终止程序的运行。另一种方法是由程序员在编写程序时，就考虑到错误的检测、错误消息的提示，以及错误的处理。

捕获错误最理想的是在编译期间，但有的错误只有在运行时才会发生。比如：除数为0，数组下标越界等

分类：编译时异常和运行时异常
1.运行时异常
是指编译器不要求强制处置的异常。一般是指编程时的逻辑错误，是程序员应该积极避免其出现的异常。java.lang.RuntimeException类及它的子类都是运行时异常。
对于这类异常，可以不作处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响。

2.编译时异常
是指编译器要求必须处置的异常。即程序在运行时由于外界因素造成的一般性异常。编译器要求java程序必须捕获或声明所有编译时异常。
对于这类异常，如果程序不处理，可能会带来意想不到的结果。

常见异常类示例代码：

/*
当执行一个程序时，如果出现异常，那么异常之后的代码就不再执行！
 */
public class TestException {
    //编译时异常
    @Test
    public void test6(){
//      FileInputStream fis = new FileInputStream(new File("hello.txt"));
//      int b;
//      while((b = fis.read()) != -1){
//          System.out.println((char)b);
//      }
//      fis.close();
    }

    //常见的运行时异常
    /*
     * Bank bank = new Bank();
     * Customer[] customers = new Customer[5];
     * customers[0] = new Customer();
     * System.out.println(customers[0].getFirstName());可能出现空指针异常
     * customers[0].setAccount(new Account(200));
     * customers[0].getAccount().withdraw(100);可能出现空指针异常
     */
    //4.空指针异常：NullPointerExcetion
    @Test
    public void test5(){
//      Person p = new Person();
//      p = null;
//      System.out.println(p.toString());

        String str = new String("AA");
        str = null;
        System.out.println(str.length());
    }

    //3.类型转换异常：ClassCastException
    @Test
    public void test4(){
        Object obj = new Date();
        String str = (String)obj;

        //String str1 = (String)new Date();
    }

    //2.算术异常：ArithmeticException
    @Test
    public void test3(){
        int i = 10;
        System.out.println(i / 0);
    }

    //1.数组下标越界的异常:ArrayIndexOutOfBoundsException
    @Test
    public void test2(){
        int[] i = new int[10];
        //System.out.println(i[10]);
        System.out.println(i[-10]);
    }

    @Test
    public void test1(){
        Scanner s = new Scanner(System.in);
        int i = s.nextInt();
        System.out.println(i);
    }
}
class Person{

}

二、如何处理Exception的异常
Java提供的是异常处理的抓抛模型
1.”抛”：当我们执行代码时，一旦出现异常，就会在异常的代码处生成一个对应的异常类型的对象，并
将此对象抛出。(自动抛出 / 手动抛出)

一旦抛出此异常类的对象，那么程序就终止执行
此异常类的对象抛给方法的调用者。
2.”抓”：抓住上一步抛出来的异常类的对象。如何抓？即为异常处理的方式
java 提供了两种方式用来处理一个异常类的对象。
处理的方式一：
try{
//可能出现异常的代码
}catch(Exception1 e1){
//处理的方式1
}catch(Exception2 e2){
//处理的方式2
}finally{
//一定要执行的代码
}
注：1.try内声明的变量，类似于局部变量，出了try{}语句，就不能被调用
2.finally是可选的。
3.catch语句内部是对异常对象的处理：
getMessage(); printStackTrace();
4.可以有多个catch语句，try中抛出的异常类对象从上往下去匹配catch中的异常类的类型，一旦满足
就执行catch中的代码。执行完，就跳出其后的多条catch语句
5.如果异常处理了，那么其后的代码继续执行。
6.若catch中多个异常类型是”并列”关系，孰上孰下都可以。
若catch中多个异常类型是”包含”关系，须将子类放在父类的上面，进行处理。否则报错！
7.finally中存放的是一定会被执行的代码，不管try中、catch中是否仍有异常未被处理，以及是否有return语句。
8.try-catch是可以嵌套的。

三、对于运行时异常来说，可以不显式的进行处理。
对于编译时异常来说，必须要显式的进行处理。

public class TestException1 {
    // 编译时异常
    @Test
    public void test6() {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(new File("hello.txt"));
            int b;
            while ((b = fis.read()) != -1) {
                System.out.print((char) b);
            }

        } catch (FileNotFoundException e1) {//捕获异常
            System.out.println("文件找不到了！");
        } catch (IOException e1) {
            System.out.println(e1.getMessage());
        } finally {
            try {
                fis.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

异常处理的方式二：在方法的声明处，显式的抛出该异常对象的类型
格式：如：public static void method2() throws FileNotFoundException,IOException{}
当在此方法内部出现异常的时候，会抛出一个异常类的对象，抛给方法的调用者。
异常的对象可以逐层向上抛，直至main中。当然在向上抛的过程中，可以再通过try-catch-finally进行处理。

java的异常处理：抓抛模型
1.抓：异常的处理，有两种方式(①try-catch-finally② throws + 异常的类型)
2.抛：一旦执行过程中，出现异常，会抛出一个异常类的对象。（自动的抛出 vs 手动的抛出（throw + 异常类的对象））
异常类，既可以是现成的异常类，也可以是自己创建的异常类

public class TestException {
    public static void main(String[] args){
        try{
        method2();
        }catch(FileNotFoundException e){
            System.out.println(e.getMessage());
        }catch(IOException e){
            e.printStackTrace();
        }

        method3();
    }

    public static void method3(){
        try{
        method1();
        }catch(Exception e){
            e.printStackTrace();
        }
    }

    public static  void method2() throws FileNotFoundException,IOException{
        method1();
    }

    public static void method1() throws FileNotFoundException,IOException{
        FileInputStream fis = new FileInputStream(new File("hello1.txt"));
        int b;
        while((b = fis.read()) != -1){
            System.out.print((char)b);
        }
        fis.close();
    }
}

如何自定义一个异常类
1.自定义的异常类继承现有的异常类
2.提供一个序列号，提供几个重载的构造器
代码：

public class MyException extends Exception{

    static final long serialVersionUID = -70348975766939L;

    public MyException(){

    }
    public MyException(String msg){
        super(msg);
    }
}

最后是一个比较让人考虑的问题，在try中写一个return语句，是先执行return还是先执行finaly();
代码证明：

public class TestFinally {
    public static void main(String[] args){
        System.out.println(tryTest());//打印返回的int值；
    }
    public static int tryTest(){
        int i=0;//初始化变量i
        try {
            return ++i;//执行return语句是返回为6；
        }
        catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            i=3;//执行finally语句是i赋值为3
           // return i;
            /*如上面代码所示：
            * 如果先执行finally语句，再执行try内的return语句
            * 在执行finally时，i被赋值为3，执行return返回时，应该返回的是4
            * 而实际的打印结果为1，说明先返回了return,再执行的finally*/
        }
        return 2;//此语句执行不到，只是为了编译通过。
    }
}