java_异常

一.什么是异常?

1.当程序”运行后”,当jvm遇到一些无法处理的情况,例如:整数/0,这就表示jvm遇到一种”异常情况”.

通常jvm能够识别这些异常并在控制台打印异常信息,并结束程序

2.为了解决这些情况,java提出了”异常处理机制”,这种机制的使用,可以使得我们的代码在遇到异常时,

可以跳过异常的代码,继续健康的执行下去.

二.异常_异常的产生过程及JVM默认处理异常的方式

1).jvm执行到有异常的代码

2).jvm识别出遇到的异常情况

3).jvm 在类库中寻找描述这种异常的异常类,并创建对象

4).jvm 要看我们的代码中是否希望”捕获”这种异常

是:就执行相应的catch语句

否:在控制台打印异常信息,并结束程序

案例图片:

三.异常_Java的异常体系结构及分类

1).Throwable(类):Java中所有“异常”的顶层类；

       |--Error(错误):不希望程序捕获并处理的错误情况。异常类名都是以：XxxxError结尾的。

       |--Exception(异常):希望程序捕获并处理的异常情况。异常类名都是以：XxxxException结尾的。

           |--RuntimeException(运行时异常):

           |--除RuntimeException以外的其它异常(编译期异常):

--------------------------------------------------------------------------

四.异常的处理_try_catch语句及操作异常对象

1).格式：

        try{

            //可能出现异常的代码

        }catch(异常类名  变量名){

            //如果try中出现了与"异常类名"相同的异常情况，

            //JVM将会执行这个catch，以挽救程序。

3).操作异常对象：

1).getMessage():获取异常信息；

2).toString():异常类名 + 异常信息

3).printStackTrace()：打印异常详细信息；【常用：在调试时】

五.第二章：异常的处理_try_catch_catch语句

   1).格式：

        try{

            //可能出现异常的代码

            //多行代码...

        }catch(异常类名1 变量名){

        }catch(异常类名2 变量名){

        }

    2).示例代码：　

public static void main(String[] args) {
    int a = 10;
    int b = 10;
    int[] arr = new int[0];
    try {
       System.out.println("除法：" + (a / b));//算数运算异常
        System.out.println("数组长度：" + arr.length);//空指针异常
        System.out.println("数组的第一个元素：" + arr[0]);//数组索引越界异常
    } catch (ArithmeticException e) {
        System.out.println("算数运算异常！！");
    } catch (NullPointerException e) {
        System.out.println("空指针异常！！");
    } catch (ArrayIndexOutOfBoundsException e) {
        System.out.println("数组索引越界异常！！");
    } catch (Exception e) {
        System.out.println("系统出现了未知异常，请联系系统管理员！");
    }
    System.out.println("后续代码...");
}

注意：

    1).在try中如果某行出现异常，try中的后续代码将不会被执行；

    2).在多个catch中的“异常类名”绝对不能重复；

    3).在多个catch中的“异常类名”通常是“同级”关系；也可以是“子父类”关系，如果是子父类关系，“父类的异常类名”一定要写在多catch的最后。

六.第二章：异常的处理_try_catch_finally语句

1).格式：

try{

//可能出现异常的代码

}catch(异常类名 变量名){

//如果try中出现了与“异常类名”相同的异常，

//将会执行这里

}finally{

                 //无论是否出现异常，都会被执行

                 //通常用在try和catch中有"return"语句的情况。

                 //finally中的代码会保证在try或者catch的return之前被执行。

           }

七.第二章：异常的处理_抛出异常_throw语句

1).格式：

        方法声明(){

            if(....){//判断

                throw new 异常对象("异常信息");//此异常对象，会抛给"调用的代码"，由调用的代码处理；

            }

        }

2).示例代码：

　　

public class Demo {
    public static void main(String[] args) {
        try {
            getMax(null);
        } catch (NullPointerException e) {
            System.out.println(e.getMessage());
        }
        try {
            int[] arr = new int[0];
            getMax(arr);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println(e.getMessage());
        }
    }

    //编写方法，可以求一个数组中所有元素最大值
    public static int getMax(int[] arr) {
        if (arr == null) {
          //为什么要“抛出一个异常对象”？
          //为了告诉调用的代码：我这个方法中出现了异常，没有正常秩序完毕！
            throw new NullPointerException("哥们，别给我传空指针啊！揍你啊！！");
        }
        if (arr.length == 0) {
            throw new ArrayIndexOutOfBoundsException("哥们，别给我传0长度数组！削你啊！！");
        }
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            max = arr[i] > max ? arr[i] : max;
        }
        return max;
    }
}

八.异常的处理_抛出异常_throws语句

    1).格式：

        方法声明() throws 异常类名1,异常类名2...{

            //正常写代码即可

            //如果方法中出现了声明的“异常类名1”，“异常类名2”类型的异常，

            //JVM会将这种异常对象抛给调用的代码，由调用的代码处理。

        }

    2).示例代码：

public class Demo {
    public static void main(String[] args) {
        try {
            getMax(null);
        } catch (NullPointerException e) {
            System.out.println(e.getMessage());
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            int[] arr = new int[0];
            getMax(arr);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println(e.getMessage());
        }
    }

    //编写方法，可以求一个数组中所有元素最大值
    //throws:表示：声明抛出
    public static int getMax(int[] arr) throws NullPointerException,
                                                ArrayIndexOutOfBoundsException{
     //方法中正常写代码即可。
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            max = arr[i] > max ? arr[i] : max;
        }
        return max;
    }
}

3).注意事项：

        1).如果throws声明抛出的是：运行时异常(RuntimeException及其子类)，调用处可以不处理，编译通过。

           但运行时，如果真的出现异常，仍然停掉程序。

        2).如果throws声明抛出的是：编译期异常(除RuntimeException以外的异常)，调用处必须处理，

           要么try...catch...，要么继续抛出，否则编译错误。

throw和throws的区别：

    1).throw:(抛出)

1).用在方法中;

2).throw后面是：new 异常对象();而且只能有一个；

3).表示：立即抛出一个异常对象给方法的调用处；

    2).throws:(声明抛出)【常用】

        1).用在方法的声明处；

2).throws后面是：“异常类名”,可以有多个。

3).表示：告诉JVM，此方法内部“可能会出现某种异常”，如果运行时，真的出现异常，JVM

要将这个异常对象抛给调用处。

九.异常的处理_注意事项

    1).子类重写父类方法时，throws的写法：

class Fu{

public void show1(){}

public void show2() throws NullPointerException{}//空指针异常--运行时异常

public void show3() throws IOException{}//编译期异常

}

class Zi extends Fu{

public void show1() throws Exception{}

public void show2() throws ArrayIndexOutOfBoundsException{}

public void show3() throws IOException,ParseException{}

}

    2).当子类重写父类方法时，throws方面总体遵循以下三条规则：

        1).无论父类方法是否抛出异常，子类方法都可以：不抛出任何异常；

        2).无论父类方法是否抛出异常，子类方法都可以：抛出任何的“运行时异常”；

        3).无论父类方法是否抛出异常，子类方法可以抛出跟父类相同的“编译期异常(或者子类异常)”,

           不能抛出比父类更多的编译期异常。

3).示例代码：

class Fu{
    public void show1() {}
    public void show2() throws NullPointerException{}//空指针异常--运行时异常
    public void show3() throws IOException {}//编译期异常
}
//1.都可以不抛出任何异常；
class Zi1 extends Fu{
    @Override
    public void show1() {
        super.show1();
    }
    @Override
    public void show2() {
        super.show2();
    }
    @Override
    public void show3() {
    }
}
//2.都可以抛出任何的运行时异常
class Zi2 extends Fu{
    @Override
    public void show1() throws NullPointerException {

    }
    @Override
    public void show2() throws NullPointerException {

    }
    @Override
    public void show3() throws NullPointerException {
        super.show1();
    }
}
//3.只能抛出跟父类相同的“编译期异常（或者子类）”，不能抛出父类没有的编译器异常。
class Zi3 extends Fu{
    @Override
    public void show1()  {
    }
    @Override
    public void show2()  {
    }
    @Override
    public void show3() throws ChangedCharSetException,ActivationException {//错误
    }
}

十.异常_自定义异常

    1).有些时候，根据自身的业务逻辑，需要某种异常类，但类库中没有提供这种异常类，这时我们可以自定义自己的异常类。

            class Student{

                private int age;

                public void setAge(int age){

                    if(age < 15 || age > 50){

                        //抛出异常

                        throw new 自定义异常对象();

                    }

                    this.age = age;

                }

            }

    2).定义异常类：

        class Throwable{

            private String detailMessage;

            public String getMessage(){

                this.detailMessage;

            }

        }

        class Exception extends Throwable{

            public Excepton(String msg){

                super(msg);

            }

        }

        class RuntimeException extends Exception{

            public RuntimeException (String msg){

                super(msg);

            }

        }

        //自定义异常类，可以继承自任意的Exception类及其子类。

        class AgeException extends RuntimeException{

            public AgeException (String msg){

                super(msg);

            }

        }

public class Student{
    private int age;
    public void setAge(int age){
        if(age < 15 || age > 50){
            //抛出异常
            throw new AgeException("年龄非法，必须在15到50之间！！");
        }
        this.age = age;
    }
}
public class Demo {
    public static void main(String[] args) {
        Student stu = new Student();
        try {
            stu.setAge(10);
        } catch (NullPointerException e) {
            System.out.println("异常了：");
            System.out.println(e.getMessage());
        }
    }
}