异常体系（入门级初学者）

一、异常概述

1、为什么要学习异常：

    异常一旦出现，没有提前处理，程序就会退出JVM虚拟机而终止

2、什么是异常：

  异常是程序在“编译”或“执行”的过程中可能出现的问题。注意：语法错误不在异常体系中

3、Exception异常的分类：

* 1、编译时异常：继承自Exception的异常或者其他子类，编译阶段就会报错

*          必须程序员处理的，否则代码编译就不能通过

* 2、运行时异常：继承自RuntimeException 的异常或者其子类，编译阶段是不会出错的，它是在            运行时可能出现

* 运行时异常可以处理也可以不处理，编译阶段是不会出错的，但是运行阶段可能出现，还是建                提前处理。

* * 小结：

*          异常是程序在编译或者运行的过程中可能出现的错误

*          异常分为2类：编译时异常，运行时异常

*                  ---编译时异常：继承了Exception，编译阶段就报错，必须处理，否则代码不通过

*                  ---运行时异常：继承了RuntimeException,编译阶段不会报错，运行时才可能出现

* 异常一旦真的出现，程序就会终止，所以要研究异常，避免异常，处理异常，程序更健壮！！！

4、异常体系：

 

二、常见运行时异常

 运行时异常继承了RuntimeException,编译阶段不报错，运行时才可能出现错误

代码示例：

1、数组索引越界异常：ArrayIndexOutOfException

int[] arr = {1,2,3};
System.out.println(arr[2]);

2、空指针异常：NullPointerException 直接输出没有问题，但是调用空指针的变量的功能就会报错

String name = null;
System.out.println(name);//null
//System.out.println(name.length());//运行时出错，程序终止

3、类型转换异常：ClassCastException

Object o = 23;
//String s = (String) o;//运行时出错，程序终止

4、数学操作异常：ArithmeticException

//int c = 10/0;

5、数字转换异常：NumberFormatException

String number = "23";
String number1= "23aabb";
//Integer it = Integer.valueOf(number1);
//System.out.println(it + 1);

三、常见编译时异常

 

 编译时异常的作用是什么：

* 1、是担心程序员的技术可能不行，在编译阶段就爆出一个错误，目的在于提醒

* 2、提醒程序员这里很可能出错，请检查并注意不要出bug

* 3、编译时异常是可遇不可求的。遇到了就遇到了呗

    public static void main(String[] args) throws ParseException {
        String date = "2015-01-12 10:23:21";
        //创建一个简单的日期格式化类
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        //解析字符串时间成日期对象
        Date d = sdf.parse(date);
        System.out.println(d);
    }

编译是异常的特点

1、继承自Exception的异常或者其子类

2、编译阶段报错必须处理，否则代码不通过

四、异常的三种处理机制

1、异常的默认处理机制

  异常一旦出现，会自动创建异常对象，最终抛出给虚拟机

* 只要收到异常，就直接输出异常信息，干掉程序！！！

 * 默认的异常处理机制并不好，一旦真的出现异常，程序立即死亡

    public static void main(String[] args) {
        System.out.println("程序开始。。。");
        chu(10,0);
        System.out.println("程序结束。。。");
    }

    public static void chu(int a,int b){
        System.out.println(a);
        System.out.println(b);
        int c= a/b;
        System.out.println(c);
    }

 

2、编译时异常处理机制

第一种处理办法：

 第二种处理办法：

 public static void main(String[] args) throws Exception {
        System.out.println("程序开始。。。");
        parseTime("2011-11-11 11:11:11");
        System.out.println("程序结束。。。");
    }


    public static void parseTime(String date) throws Exception {//使用Exception作为接口，可以实现多接口，节省了空间，祖宗接口
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date d = sdf.parse(date);
            System.out.println(d);

            InputStream is = new FileInputStream("E:/meinv.jpg");
        } catch (Exception e) {
            e.printStackTrace();//打印异常栈信息

//    public static void parseTime(String date) throws Exception {//使用Exception作为接口，可以实现多接口，节省了空间，祖宗接口
//        try {
//          SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//            Date d = sdf.parse(date);
//            System.out.println(d);
//
//            InputStream is = new FileInputStream("E:/meinv.jpg");
//       } catch (ParseException e) {
//           e.printStackTrace();//打印异常栈信息
//        } catch (FileNotFoundException e) {
//            e.printStackTrace();
        }

        //  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //        Date d = sdf.parse(date);
        //        System.out.println(d);
        //
        //        InputStream is = new FileInputStream("E:/meinv.jpg");
    }

小结：

* 第二种方式：

*          可以处理异常，并且出现异常后代码也不会死亡

*          这种方法还是可以的 * 但是从理论上来说，这种方法不是最好的，上层调用者不能直接知道底层的执行情况！

3、运行时编译异常处理机制

特点：可以知道底层的调用情况，也不会引起程序上的死亡（理论上是最好的）

    public static void main(String[] args) {
        System.out.println("程序开始。。。");
        try {
            parseTime("2011-11-11 11:11:11");
            System.out.println("功能操作成功");
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("功能操作失败");
        }
        System.out.println("程序结束。。。");
    }
    public static void parseTime(String date) throws Exception {//使用Exception作为接口，可以实现多接口，节省了空间，祖宗接口
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date d = sdf.parse(date);
            System.out.println(d);

            InputStream is = new FileInputStream("E:/meinv.jpg");
    }

处理形式：

1、运行时异常编译阶段不会报错，是运行时才可能出错的，所以编译阶段不处理也可以

2、按照规范建议还是处理：建议在最外层调用处集中捕获处理即可

4、总结

 案例1：

    public static void main(String[] args) {
        System.out.println("程序开始。。。");
        try {
            chu(10,0);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("程序结束。。。");
    }
    public static void chu(int a,int b){//throw RuntimeException
        System.out.println(a);
        System.out.println(b);
        int c= a/b;
        System.out.println(c);
    }

案例2、

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (true) {
            try {
                System.out.println("请您输入合法的价格：");
                String priceStr = sc.nextLine();
                //转换成double类型的价格
                double price = Double.valueOf(priceStr);

                //判断价格是否大于0
                if(price >0){
                    System.out.println("定价：" +price);
                    break;
                }
                else{
                    System.out.println("价格必须是正数~~~");
                }
            } catch (Exception e) {
                System.out.println("用户输入的数据有毛病，请您输入合法的数据，建议为正数~~~");
            }
        }
    }
}

五、自定义异常

原因：

Java已经为开发中可能出现的异常都设计了一个类来代表

 但实际在开发中，异常可能有无数中情况，

Java无法为这个世界上所有的异常都定义一个代表类

 假如一个企业如果想为自己认为的某种业务问题定义成一个异常

就需要自己来自定义异常类

1、自定义编译时异常：

        * 1、继承Exception

        * 2、重写构造器

        * 3、在出现异常的地方用throw new 自定义对象抛出

public class mingzhiyifuAgeIlIegalException extends Exception {
    public mingzhiyifuAgeIlIegalException() {
    }

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

    public static void main(String[] args) {
        try {
            checkAge(34);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void checkAge(int age) throws mingzhiyifuAgeIlIegalException {
        if(age < 0 || age > 200){
            //抛出去一个异常对象给调用者
            //throw ： 在方法内部直接创建一个异常对象，并从此点抛出
            //throws ： 用在方法申明上的，抛出方法内部的异常
            throw new mingzhiyifuAgeIlIegalException(age + "is illlegal");
        }else{
            System.out.println("年龄合法：推荐商品给其购买！");
        }
    }

2、自定义运行时异常 

自定义运行时异常：

        * 1、定义一个异常类继承RuntimeExceptio

        * 2、重写构造器

        * 3、在出现异常的地方用throw new自定义对象抛出

        * 提醒不强烈，编译阶段不报错！！！运行时可能出现

public class mingzhiyifuRunException extends RuntimeException {
    public mingzhiyifuRunException() {
    }

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


class SelfDemo1 {
    public static void main(String[] args) {
        try {
            checkAge(34);//只写这个不报错的，只会在运行时报错
        } catch (mingzhiyifuRunException e) {
            e.printStackTrace();
        }
    }

    public static void checkAge(int age) throws mingzhiyifuRunException {
        if(age < 0 || age > 200){
            //抛出去一个异常对象给调用者
            //throw ： 在方法内部直接创建一个异常对象，并从此点抛出
            //throws ： 用在方法申明上的，抛出方法内部的异常
            throw new mingzhiyifuRunException(age + "is illlegal");
        }else{
            System.out.println("年龄合法：推荐商品给其购买！");
        }
    }
}

结语：

学到这的话，小伙伴们也就可以看懂异常的代码啦，并利用异常来更好的为自己服务，可以用来替代一些if，else的判断，减少程序的崩溃，更好的处理崩溃问题！