第2课第5节_Java面向对象编程_异常_P

qq_34738528

于 2020-03-05 14:46:12 发布

阅读量120

点赞数

分类专栏： java快速入门

本文链接：https://blog.csdn.net/qq_34738528/article/details/104674664

版权

java快速入门专栏收录该内容

12 篇文章 0 订阅

订阅专栏

异常：程序在运行过程中发生由于外部问题（如硬件错误、输入错误）等导致的程序异常事件。（在Java等面向对象的编程语言中）异常本身是一个对象，产生异常就是产生了一个异常对象。异常（Exception）都是运行时的。编译时产生的不是异常，而是错误（Error）。需要注意的是，程序设计导致的错误（Error）不属于异常（Exception）。JAVA中异常都是从类Throwable类派生出来的，而Throwable类是直接从Object类继承而来，可见Java对异常处理的重视程度。
Error：系统内部错误，这类错误由系统进行处理，程序本身无需捕获处理；
Exception：可以处理的异常
RuntimeException：可以捕获，也可以不捕获的异常。
IOException：必须被捕获的异常。

java的异常处理的原则如下:

1、我们先写一个没有对异常处理的程序，在进行除法运算的时候，除数是非零的话，运行时没有问题的，但是除数为零的时候，运行就会有问题，程序也不能往下执行(只打印了Begin of div)

/* 下面程序的运行方式
 * java Div 6 2
 * 6/2=3
 */
public class Div{

    public static void main(String args[]){
        int m = Integer.parseInt(args[0]);//从字符串里面解析出整数
        int n = Integer.parseInt(args[1]);

        System.out.println("Begin of div");
        int r = div(m,n);
        System.out.println("end of div");

        System.out.println(m+"/"+n+"="+r);
    }

    public static int div(int m,int n){
        int r = m / n;
        return r;
    }
}

这里的“ArithmeticException”就是算数异常，属于 RuntimeException 这个运行异常（这个异常可以处理可以不处理，不处理程序会退出，但是编译是能够通过的），在进行处理时可以在本方法内自己进行处理，也可以抛出让调用者去处理，下面代码是本方法内进行处理的方式：

2、我们先写一个有对异常进行处理程序(自己处理异常)，根据下面的运行结果，程序可以捕获到异常并且可以正常的执行.

public class Div2{

    public static void main(String args[]){
        int m = Integer.parseInt(args[0]);
        int n = Integer.parseInt(args[1]);

        System.out.println("Begin of div");
        int r = div(m,n);
        System.out.println("end of div");

        System.out.println(m+"/"+n+"="+r);
    }

    public static int div(int m,int n){
        int r = 0;
        try {/* try catch进行处理后程序在发生异常时就不会奔溃 */
            r = m / n ;
        }catch (ArithmeticException e){//捕获算数异常
            System.out.println(e);
        }finally{//加了 finally 无论是否发生异常都会执行这段代码
            System.out.println("This is finally of div");
        }
        /* 算数异常属于runtime异常可以处理也可以不处理,不处理就奔溃,但编译能通过 */
        return r;
    }
}

上面的程序在自己方法内进行处理，如果想让调用者处理，可以抛出这个异常，如下：

3、我们写一个程序将异常抛出的类，这个抛出的异常是由main进行处理.

public class Div4{

    public static void main(String args[]){
        int m = Integer.parseInt(args[0]);
        int n = Integer.parseInt(args[1]);
        int r = 0;

        System.out.println("Begin of div");
        try {/* 对异常进行处理 */
            r = div(m,n);
        }catch (ArithmeticException e){
            System.out.println(e);
        }
        System.out.println("end of div");

        System.out.println(m+"/"+n+"="+r);
    }

     /* 这里用 throws 把算数异常抛出给调用者*/
    public static int div(int m,int n) throws ArithmeticException{
        int r = 0;
        
        r = m / n ;

        return r;
    }
}

4、如果在类的方法中如果处理了异常，那样在main方法中就不会对异常进行处理.

public class Div5{

    public static void main(String args[]){
        int m = Integer.parseInt(args[0]);
        int n = Integer.parseInt(args[1]);
        int r = 0;

        System.out.println("Begin of div");
        try {
            r = div(m,n);
        }catch (ArithmeticException e){
            System.out.println(e);
        }
        System.out.println("end of div");

        System.out.println(m+"/"+n+"="+r);
    }

    public static int div(int m,int n) throws ArithmeticException{
        int r = 0;

        try{
            r = m / n ;
        }catch(ArithmeticException e){
            System.out.println("div :"+e);
        }

        return r;
    }
}

5、如果在类的方法中如果处理了异常，同时在类方法中把异常抛出，那样main方法也可以捕获到异常.

如果这个异常想要本方法内处理一部分，也想让调用者也做处理的话，代码可以这样写：

public class Div6{

    public static void main(String args[]){
        int m = Integer.parseInt(args[0]);
        int n = Integer.parseInt(args[1]);
        int r = 0;

        System.out.println("Begin of div");
        try {
            r = div(m,n);
        }catch (ArithmeticException e){
            System.out.println(e);
        }
        System.out.println("end of div");

        System.out.println(m+"/"+n+"="+r);
    }
    /* 把异常丢给调用者处理,main里面如果不做处理也会奔溃 */
    public static int div(int m,int n) throws ArithmeticException{
        int r = 0;

        try{
            r = m / n ;
        }catch(ArithmeticException e){
            System.out.println("div :"+e);
            throw e;/* 这里要丢出异常main才会处理，否则调用者mian是捕捉不到这个异常的 */
        }

        return r;
    }
}

6、现在我们上面第5个例子的代码，只有对这种算术运行的异常进行处理，如果我传入的参数个数不对，还有参数的格式也不对，程序是处理不了的。

为了修复上述的问题，我们添加对传入参数格式不对，还有传入参数个数不对这两种异常的处理。

需要说明的是，对于“不可查的异常”， runtime 异常属于这个范畴，系统会自动抛出它，所以 div 方法后面的 throws 我们也可以不写。下面写一个同时捕获多个异常的程序，如下：

public class Div7{

    public static void main(String args[]){
        int m = 0;
        int n = 0;
        int r = 0;

        System.out.println("Begin of div");
        try {
            m = Integer.parseInt(args[0]);
            n = Integer.parseInt(args[1]);
            r = div(m,n);
             /* 当异常太多,每个都写太麻烦,可以捕获它们的父类 */
        }catch (ArithmeticException e){//算数异常
            System.out.println("main :" + e);
        }catch (NumberFormatException e){//数据格式异常
            System.out.println("main :" + e);
        }catch (ArrayIndexOutOfBoundsException e){//它们的父类，属于这个异常的子类都会被处理
            System.out.println("main :" + e);
        }
        System.out.println("end of div");

        System.out.println(m+"/"+n+"="+r);
    }
    /* 对于“不可查异常”, 系统也会抛出它，写不写后面这个throws效果一样 */
    public static int div(int m,int n) throws ArithmeticException{
        int r = 0;

        try{
            r = m / n ;
        }catch(ArithmeticException e){
            System.out.println("div :"+e);
            /* 这里执行throw之前会先去执行finally,但是如果finally它return了,
               这里就不会执行throw，会导致异常没有抛出 */
            throw e;
        }finally {
            System.out.println("finally of div");
            /* 这里不能 return */
            //return r;
        }

        return r;
    }
}

7、在第6个例子继续优化，上面的程序目前只能对算术运算、参数格式还有参数个数不对的异常进行处理，其他的情况是无法处理的到的，我们可以添加对这些异常的父类RuntimeException来捕获异常.

public class Div8{

    public static void main(String args[]){
        int m = 0;
        int n = 0;
        int r = 0;

        System.out.println("Begin of div");
        try {
            m = Integer.parseInt(args[0]);
            n = Integer.parseInt(args[1]);
            r = div(m,n);
        }catch (ArithmeticException e){
            System.out.println("main :" + e);
        }catch (NumberFormatException e){    //去掉了参数个数的异常，仍然可以捕获到
            System.out.println("main :" + e);
        }catch (RuntimeException e){
            System.out.println("main :" + e);
        }
        System.out.println("end of div");

        System.out.println(m+"/"+n+"="+r);
    }

    public static int div(int m,int n) throws ArithmeticException{
        int r = 0;

        try{
            r = m / n ;
        }catch(ArithmeticException e){
            System.out.println("div :"+e);
            throw e;
        }

        return r;
    }
}

8、对于“不可查异常”, 系统也会抛出它，写不写throws效果一样

public class Div9{

    public static void main(String args[]){
        int m = 0;
        int n = 0;
        int r = 0;

        System.out.println("Begin of div");
        try {
            m = Integer.parseInt(args[0]);
            n = Integer.parseInt(args[1]);
            r = div(m,n);
        }catch (ArithmeticException e){
            System.out.println("main :" + e);
        }catch (NumberFormatException e){
            System.out.println("main :" + e);
        }catch (RuntimeException e){
            System.out.println("main :" + e);
        }
        System.out.println("end of div");

        System.out.println(m+"/"+n+"="+r);
    }

    //public static int div(int m,int n) throws ArithmeticException{
    public static int div(int m,int n){
        int r = 0;

        try{
            r = m / n ;
        }catch(ArithmeticException e){
            System.out.println("div :"+e);
            throw e;
        }finally{
            System.out.println("finally of div");
        }

        return r;
    }
}

上面是属于runtime运行异常，可处理也可不处理，属于不可查异常范畴，下面是写一个可查的异常，即我们必须处理的异常，否则连编译都编译不过，程序如下：

public class Div9{
    public static void main(String args[]){
        int m = 0;
        int n = 0;

        int r = 0; 
        try {
            m = Integer.parseInt(args[0]);
            n = Integer.parseInt(args[1]);
            r = div(m, n);
        } catch (ArithmeticException e){
            System.out.println("main :"+e);
        } catch (NumberFormatException e){//数据格式异常
            System.out.println("main :"+e);
        } catch (RuntimeException e){//它们的父类
            System.out.println("main :"+e);
        } catch (Exception e){//捕获自己手工创建的可见异常，必须捕获并处理
            System.out.println("main :"+e);
        }

        System.out.println(m+"/"+n+"="+r);
    }

    /* 这里是“可查的异常”，所以如果div没有处理的话 throws 就必须写 */
    public static int div(int m, int n)throws Exception{
        int r=0;

        try {
            r = m / n;
        } catch (ArithmeticException e){
            System.out.println("div :"+e);
            /* 手工创建的可见异常,扔出去让别人处理 */
            throw new Exception("My Error");
        } finally {
            System.out.println("finally of div");           
        }

        return r;
    }
}

上面创建了可查的异常后，抛出来让调用者 main 来处理了，如果想自己处理了，就可以不用加 throws，如下：

    public static int div(int m, int n){
        int r=0;

        try {
            r = m / n;
        } catch (ArithmeticException e){
            System.out.println("div :"+e);
            try {
                throw new Exception("My Error");
            } catch (Exception e2){ //不抛出异常就得处理
                System.out.println("div :"+e2);         
            }
        } finally {
            System.out.println("finally of div");           
        }
        return r;
    }

qq_34738528

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第2课第5节_Java面向对象编程_异常_P

java的异常处理的原则如下:1、我们先写一个没有对异常处理的程序，在进行除法运算的时候，除数是非零的话，运行时没有问题的，但是除数为零的时候，运行就会有问题，程序也不能往下执行(只打印了Begin of div)public class Div{ public static void main(String args[]){ int m = In...
复制链接

扫一扫

专栏目录