zoukankan      html  css  js  c++  java
  • 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());
            }
        }
    }
  • 相关阅读:
    Oracle Index 索引监控
    Oracle Job
    Oracle 数据类型
    Greenplum 的发展历史
    Mongodb账户管理
    MongoDB 备份与恢复
    MySQL 查看用户授予的权限
    Linux 不同方法查看进程消耗CPU IO 等
    Oracle 体系结构图
    Oracle 后台进程(六)PMON进程
  • 原文地址:https://www.cnblogs.com/aihuadung/p/10783884.html
Copyright © 2011-2022 走看看