• JAVA学习笔记(十九)


    异常

      Java代码在运行时期发生的问题就是异常。

    异常的继承体系

      

      查阅API发现Exception 类及其子类是 Throwable 的一种形式,它用来表示java程序中可能会产生的异常,并要求对产生的异常进行合理的异常处理。继续观察,我们可以发现Exception有继承关系,它的父类是Throwable。Throwable是Java 语言中所有错误或异常的超类,即祖宗类。

    异常继承体系总结

      Throwable: 它是所有错误与异常的超类(祖宗类)

      |- Error 错误

      |- Exception 编译期异常,进行编译JAVA程序时出现的问题

        |- RuntimeException 运行期异常, JAVA程序运行过程中出现的问题  

    异常的产生过程

      这是一个普通的数组下标越界异常的产生过程;

    抛出异常throw

      在编写程序时,我们必须要考虑程序出现问题的情况。比如,在定义方法时,方法需要接受参数。那么,当调用方法使用接受到的参数时,首先需要先对参数数据进行合法的判断,数据若不合法,就应该告诉调用者,传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。

      在java中,提供了一个throw关键字,它用来抛出一个指定的异常对象。那么,抛出一个异常具体如何操作呢?

      1,创建一个异常对象。封装一些提示信息(信息可以自己编写)。

      2,需要将这个异常对象告知给调用者。怎么告知呢?怎么将这个异常对象传递到调用者处呢?通过关键字throw就可以完成。throw 异常对象;

      throw用在方法内,用来抛出一个异常对象,将这个异常对象传递到调用者处,并结束当前方法的执行。

    使用格式:

    throw new 异常类名(参数)

    例如:

    package com.oracle.demo01;
    
    public class ExceptionDemo2 {
    /*
     * 异常:编译时期异常:只要调用了抛出异常的方法没有处理,就会编译失败
     *                         如果出现编译时期异常处理方式(try throws)
     *             运行时期异常:方法内部抛出异常是运行异常 new XXXXException
     *                             如果是运行异常,它不会编译失败,方法声明不需要throws,调用者不需要处理
     *                             一旦发生,不要处理,修改源代码,没有执行的意义
     *                     RuntimeException及其他的子类
     * */
        public static void main(String[] args) {
            //定义一个方法,计算圆的面积
                double area=getArea(0);
                System.out.println(area);
        }
            public static double getArea(double r) {
                if(r<=0) {
                    throw new RuntimeException("传入的值不符合要求");
                }
                return Math.PI*r*r;
            }
    }

    声明异常throws

    声明:将问题标识出来,报告给调用者。如果方法内通过throw抛出了编译时异常,而没有捕获处理(稍后讲解该方式),那么必须通过throws进行声明,让调用者去处理。

    /*
         * throw 后边加的是异常对象
         * throws后边加的是异常类名,并写在方法声明上
         * 作用:告诉调用者此方法可能出现异常,需要处理
         * 
         * */
        public static int getArray(int[] arr) throws Exception{
            if(arr==null) {
                throw new Exception("你传进来的数组是空的");
            }
            if(arr.length<3) {
                throw new Exception("你传的数组长度太小了,请传三个以上");
            }
            int i=arr[3];
            return i;
        } 

    捕获异常try…catch…finally

      try:该代码块中编写可能产生异常的代码。

      catch:用来进行某种异常的捕获,实现对捕获到的异常进行处理。

      finally:有一些特定的代码无论异常是否发生,都需要执行。另外,因为异常会引发程序跳转,导致有些语句执行不到。而finally就是解决这个问题的,在finally代码块中存放的代码都是一定会被执行的。

      捕获异常格式

    /*
         * try{
         * 被监测的代码
         * 可能出现异常的代码
         * }catch(异常类名 变量名){
         * 异常处理方式
         * }finally{
         * 必须要执行的代码
         * }
         * 作用:try监测到了有异常发生,接收到一个异常对象,
         * 将异常对象抛给catch代码块处理,catch捕获到了这个异常对象,那么就执行处理方式代码
         * 
         * */

    多catch情况下的顺序问题:

    package com.oracle.demo01;
    
    public class NullExceptionDemo {
    /*
     * 多catch顺序问题
     * 1.如果异常是平级的情况下(没有继承关系)
     * NullPointerException
     *             extends RuntimeException
     * ArrayIndexOutOfBoundsException extends
     *             IndexOutOfBoundsException extends RuntimeException 
     * 顺序可以随便写
     * 2.如果有继承关系,要把小辈的放在前边,大辈放在后边
     * Exception 
     * NullPointerException
     * */
        public static void main(String[] args) {
                int[] arr= null;
                try {
                int i=getArray(arr);
                System.out.println(i);
                }catch(NullPointerException ex) {
                    System.out.println(ex.getMessage());
                    //打印传入的字符串
                    ex.printStackTrace();
                    //printStackTrace()打印的是完整的异常信息,类名+字符串+报错位置
                }catch(ArrayIndexOutOfBoundsException ex) {
                    System.out.println(ex.toString());
                    //打印的是完整异常类名+传入的字符串
                }finally {
                    //finally经常用于释放资源
                    System.out.println("fianlly必须要执行的代码");
                }
                System.out.println("GameOver");
    
        }
        public static int getArray(int[] arr) throws NullPointerException,ArrayIndexOutOfBoundsException{
            if(arr==null) {
                throw new NullPointerException("你传的数组为null");
            }
            if(arr.length<3) {
                throw new ArrayIndexOutOfBoundsException("你传的数组长度不够");
            }
            return arr[3];
                }
    }

    异常在方法重写中细节

    package com.oracle.demo01;
    
    public class OverideDemo {
        public static void main(String[] args) {
            
        }
    }
    /*
     * 当父类中有异常方法的时候
     * 子类集成父类重写这个方法的时候,注意以下几点:
     * 1.子类可以选择不抛出,但是如果子类选择抛出异常,那么抛出的异常类不得超过父类的异常
     *             可以是父类的异常,也可以是父类异常的子类
     * 2.假如父类方法中没有抛异常,子类重写这个方法也不可以抛出异常
     * 3.假如父类方法中没有抛异常,但是子类重写这个方法时,在方法中调用了抛出异常的方法,
     *             那么你只有一个选择,就是try catch处理这个异常,不能throws
     * */
    class Fu{
        public void FuMethod() {
            
        }
    }
    class Zi extends Fu{
        public void FuMethod(){
            try {
            method();
            }catch(Exception e){}
        }
        public void method() {}
    }

    异常中的常用方法

      getMessage方法:返回该异常的详细信息字符串,即异常提示信息

      toString方法:返回该异常的名称与详细信息字符串

      printStackTrace:在控制台输出该异常的名称与详细信息字符串、异常出现的代码位置

    自定义异常

    class MyException extends Exception{
        /*
        *为什么要定义构造函数,因为看到Java中的异常描述类中有提供对异常对象的初始化方法。
        */
        public MyException(){
            super();
        }
        public MyException(String message)    {
            super(message);// 如果自定义异常需要异常信息,可以通过调用父类的带有字符串参数的构造函数即可。
        }
    }

    继承Exception,必须要throws声明,一声明就告知调用者进行捕获,一旦问题处理了调用者的程序会继续执行。

    继承RuntimeExcpetion,不需要throws声明的,这时调用是不需要编写捕获代码的,因为调用根本就不知道有问题。一旦发生NoAgeException,调用者程序会停掉,并有jvm将信息显示到屏幕,让调用者看到问题,修正代码。

  • 相关阅读:
    “国产化替代”加速!这些软件要硬刚国外巨头
    企业研发流程演进之路
    胜任力模型
    金字塔原理
    扒一扒数据中台的皇帝外衣(转)
    大数据平台构建实战
    浏览器的底层响应原理
    分库分表方案
    spring boot:用spring security加强druid的安全(druid 1.1.22 / spring boot 2.3.3)
    spring boot:用cookie保存i18n信息避免每次请求时传递参数(spring boot 2.3.3)
  • 原文地址:https://www.cnblogs.com/boringLee/p/9054565.html
Copyright © 2020-2023  润新知