异常类-CFANZ编程社区

异常类分为：异常（Exception）和错误（Error），它们都继承Throwable父类。
用法：

try {
        // 有可能抛出异常的代码
    } catch (Exception e) {
        // 异常处理
    } finally {
        // 无论是否捕获到异常都会执行的程序
    }

Error表示程序在运行期间出现了十分严重、不可恢复的错误，在这种情况下应用程序只能中止运行，例如JAVA虚拟机出现错误。在程序中不用捕获Error类型的异常。一般情况下，在程序中也不应该抛出Error类型的异常。

Exception是应用层面上最顶层的异常类，包含RuntimeException（运行时异常）和 Checked Exception（受检异常）。
——RuntimeException是一种Unchecked Exception，即表示编译器不会检查程序是否对RuntimeException作了处理，在程序中不必捕获RuntimException类型的异常，也不必在方法体声明抛出RuntimeException类。一般来说，RuntimeException发生的时候，表示程序中出现了编程错误，所以应该找出错误修改程序，而不是去捕获RuntimeException。常见的RuntimeException有NullPointException、ClassCastException、IllegalArgumentException、IndexOutOfBoundException等。
——Checked Exception是相对于Unchecked Exception而言的，Java中并没有一个名为Checked Exception的类。它是在编程中使用最多的Exception，所有继承自Exception并且不是RuntimeException的异常都是Checked Exception。JAVA 语言规定必须对checked Exception作处理，编译器会对此作检查，要么在方法体中声明抛出checked Exception，要么使用catch语句捕获checked Exception进行处理，不然不能通过编译。常用的Checked Exception有IOException、ClassNotFoundException等。

异常如果没有解决，会出现以下两种情况：
1. 当前线程会停止运行，异常触发点后面的代码将得不到运行。
2. 异常栈信息会通过标准错误流输出。

处理手段：
1)标准格式:try…catch…finally:捕获异常!

处理单个异常：
  try{
        //可能有很多行代码---->一旦有出现问题了
  }catch(异常类名 变量名){
    输出语句处理
  }

处理多个异常：
try{
                        可能会出现问题的多个语句
                    }catch(异常类名1 变量名){
                        输出语句处理
                    }catch(异常类名2 变量名){
                        输出语句处理
                    }

private static void method1() {
        //定义一个变量
        int a = 10 ;
        int b = 0 ;

        //第一个异常
        try {
            System.out.println(a/b);
        } catch (ArithmeticException e) {
            //输出语句处理
            System.out.println("除数不能为0");
        }

        //定义一个数组
        int[] arr = {1,2,3} ;
        try{
            System.out.println(arr[3]);
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println("您访问了数组中不存在的索引");
        }

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

2)throws 抛出异常

throws:抛出异常
        在方法声明上抛出异常,由于,编译时期异常,调用者必须要处理

private static void method2() throws Exception {
        int a = 10 ;
        int b = 0 ;
        if(b==0){
            System.out.println(a/b);
            throw new ArithmeticException() ;//跟的异常对象
        }else{
            System.out.println("不会出现问题");
        }
    }

    private static void method() throws ParseException {
        String str = "2017-11-19" ;

        //创建SimpleDataFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd") ;

        //解析
        Date d = sdf.parse(str) ;

        System.out.println(d);
    }

throws要比throw用的比较多,而try…catch…又比throws用的比较多!

捕获异常的标准格式: try…catch…finally
finally用在数据库IO流中，作用是释放资源。

final,finalize,和finally的区别?
 *          区别:
 *              final:表示最终的,终态的意思
 *              可以修饰类:类不能继承
 *              可以修饰成员方法:成员方法被重写
 *              可以修饰成员变量:此变量是一个常量   :自定义常量:  public static final int ORANGLE = 100 ;
 *              finalize:它表示通过gc垃圾回收器回收不用的对象或者是变量,System.gc():实质,调用的是重写了Object类中的
 * finalize()方法,表示回收没有跟多引用对象或者变量等等...
 *              finally:不能单独使用,和try...catch...finally中一块使用,(异常,IO,数据库中中使用的),是用来释放资源
 *                      finally中的代码一定会执行,并且除非Java虚拟机Jvm退出了,才不会执行!

public static void main(String[] args) {

        //String--->Date
        String s = "2014-5-20" ;

        //创建SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd") ;

        Date d = null ;

        try {
            d = sdf.parse(s) ;
            System.out.println("d:"+d);
        } catch (ParseException e) {
//          e.printStackTrace();
            System.out.println("解析出问题了...");
            System.exit(0) ;
        }finally{
            System.out.println("这里的代码一定会执行...");
        }

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

如何自定义一个异常类?
自定义一个类,继承自Exception或者继承自RuntimeException

测试类
package Day17_Exception;

import java.util.Scanner;

/**
 * @author Aoman_Hao
 */
public class ExceptionTest {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        System.out.println("输入一个分数：");
        int num = sc.nextInt();

        Score  score= new Score();

            try{
                score.check(num);
            }
            catch(MyException s){
                System.out.println();
            }
//          finally{
//              System.out.println("正常输入");
//          }

    }

}

对象类
package Day17_Exception;
/**
 * @author Aoman_Hao
 */
public class Score  {
    public void check(int num)throws MyException{
    if(num>100&&num<0){
        //如果分数不对，抛出异常
        throw new MyException("分数异常，应该在0-100之前");
    }else{
        System.out.println("正常分数录入");
    }
}}

继承的类
package Day17_Exception;
/**
 * @author Aoman_Hao
 */
public class MyException extends Exception {
    public MyException(){

    }
    //提示用户错误类型（string语句）
    public MyException(String s){
        super(s);
    }

}


输出：
输入一个分数：
12
正常
正常输入

异常的注意事项:
* 1)子类在重写父类中的方法的时候,如果父类中方法有抛出异常,那么子类重写的这个方法,
* 抛出异常不能够比父类中该方法异常大,(要么是父类中该方法异常的子类)(最起码应该保存一致)(父亲坏了,儿子不能比父亲更坏)
* 2)子类继承父类,要重写父类中的方法的时候,如果本身父类中该方法没有异常,那么在子类中重写该方法的时候,不能抛出异常,只能捕获异常!