6.3 异常类

墨蓝 2021-09-30 00:48 251阅读 0赞

*  **异常类**
 *  **自定义异常类**

所谓异常就是程序在运行时候可能出现一些错误，如打开一个不存在的文件，异常处理将会改变程序的控制流程，让程序有机会对错误做出处理

Java的异常出现在方法的调用过程中，即在方法调用过程中抛出异常对象，导致程序运行出现异常，并等待处理。

如流对象在调用read方法读取一个不存在的文件，会抛出IOException异常。

**异常对象可以调用以下方法得到或输出有关异常的信息：**

*  **public String getMessage();**
 *  **public void printStackTrace();**
 *  **public String toString();**

**一: try-catch语句（可以由多个catch组成）**

格式:
    try{
    包含可能发生的异常语句（发生异常的语句后跳到catch里面，异常语句下面那些不再执行）
    }
    catch(ExceptionSubClass1 e){
    ...
    }
    catch(ExceptionSubClass2 e){
    ...
    }

例子;如果我有多个catch，那么catch到一个异常后，是继续捕获其他异常，还是就此停止程序

参考：[https://www.jb51.net/article/72901.htm][https_www.jb51.net_article_72901.htm]

// Demonstrate multiple catch statements. 
    class MultiCatch { 
      public static void main(String args[]) { 
        try { 
          int a = args.length; 
          System.out.println("a = " + a); 
          int b = 42 / a; 
          int c[] = { 1 }; 
          c[42] = 99; 
        } catch(ArithmeticException e) { 
          System.out.println("Divide by 0: " + e); 
        } catch(ArrayIndexOutOfBoundsException e) { 
          System.out.println("Array index oob: " + e); 
        } 
        System.out.println("After try/catch blocks."); 
      } 
    }

该程序在没有命令行参数的起始条件下运行导致被零除异常，因为a为0。如果你提供一个命令行参数，它将幸免于难，把a设成大于零的数值。但是它将导致ArrayIndexOutOf BoundsException异常，因为整型数组c的长度为1，而程序试图给c\[42\]赋值。

C:\>java MultiCatch 
    a = 0 
    Divide by 0: java.lang.ArithmeticException: / by zero After try/catch blocks. 
    C:\>java MultiCatch TestArg 
    a = 1 
    Array index oob: java.lang.ArrayIndexOutOfBoundsException After try/catch blocks.

我的结论：捕获到了就停止吧

当你用多catch语句时，记住异常子类必须在它们任何父类之前使用是很重要的。这是因为运用父类的catch语句将捕获该类型及其所有子类类型的异常。这样，如果子类在父类后面，子类将永远不会到达。而且，Java中不能到达的代码是一个错误。例如，考虑下面的程序：

/* This program contains an error. 
    A subclass must come before its superclass in a series of catch statements. If not,unreachable code will be created and acompile-time error will result. 
    */ 
    class SuperSubCatch { 
      public static void main(String args[]) { 
        try { 
          int a = 0; 
          int b = 42 / a; 
        } catch(Exception e) { 
          System.out.println("Generic Exception catch."); 
        } 
        /* This catch is never reached because 
        ArithmeticException is a subclass of Exception. */
        catch(ArithmeticException e) { // ERROR - unreachable 
          System.out.println("This is never reached."); 
        } 
      } 
    }

如果你试着编译该程序，你会收到一个错误消息，该错误消息说明第二个catch语句不会到达，因为该异常已经被捕获。因为ArithmeticException 是Exception的子类，第一个catch语句将处理所有的面向Exception的错误，包括ArithmeticException。这意味着第二个catch语句永远不会执行。为修改程序，颠倒两个catch语句的次序。

**各个catch参数中的异常都是Exception的某个子类，表明try部分可能发生的异常，这些子类之间不能有父子关系，否则保留一个含有父类参数的catch即可(这句话可能有点奇怪，看下面例子)。**

问：java异常处理中的catch语句可以有多个，但是catch后面的异常类的类型可以是父子类关系吗？

答：首先所有异常都是Exception的子类。  
try后面可以跟多个catch，并且多个catch的异常可以有父子关系，但是要先catch子类异常，再catch父类异常。  
举例来说，SocketException套接字异常是IOException输入输出异常的子类，也就是说SocketException是具体的一种IOException，当然还有其它种类的IOException。  
所以要先catch(SocketException e)，再catch(IOException e)，这样的意思就是如果是SocketException异常就会在前面的catch被抓到，否则其它的IOException就会在后面被抓到。这样你就可以理解为什么要把子类放前面catch了。

**Java.lang包中的Integer类调用其类方法：**

**public static int parseInt(String s)**

**可以将“数字”格式的字符串（如“982”）转化为int型数据，但是当试图将字符串“ab85”转化成数字时，例如：**

**Int number=Integer.parseInt(****“****ab85****”****);**

**方法parseInt在执行过程中会抛出NumberFormatException对象，即程序运行时出现NumberFormatException异常（数字格式异常）**

**二：自定义异常类**

我们也可以扩展Exception类定义自己的异常类，然后规定哪些方法产生这样的异常。

一个方法在声明时可以使用throws关键字声明要产生的若干个异常，如：

**public void** setAge(**int** age) **throws** IntegerEx

并在该方法的方法体中具体给出产生异常的操作，即用对应的异常类创建对象，并使用throw关键字抛出该异常对象，导致该方法结束执行，如：

**throw new** IntegerEx(age);

程序必须在try-catch块语句中调用能发生异常的方法，其中catch的作用就是捕获throw方法抛出的异常。

**注意：throw和throws是两个不同的关键字**

package p4;
    
    public class IntegerEx extends Exception{
        String message;
        public IntegerEx(int a){          //带参数的构造方法
            message=a+"不合理";
        }
        public String toString(){
            return message;
        }
    }

package p4;
    
    public class People {
        private int age=1;
        public void setAge(int age) throws IntegerEx{
            if(age>=100||age<=0){
                throw new IntegerEx(age);          //方法抛出异常，导致方法结束
            }
            else{
                this.age=age;
            }
        }
        public int getAge(){
            System.out.println(age+"合理");
            return age;
        }
    }

package p4;
    
    public class P4 {
        public static void main(String args[]){
            People chy=new People();
            People hhx=new People();
            try{
                chy.setAge(120);         //调用方法
                System.out.println(chy.getAge());
            }
            catch (IntegerEx e){
                System.out.println(e.toString());
            }
            try{
                hhx.setAge(20);
                System.out.println(hhx.getAge());
            }
            catch (IntegerEx e){
                System.out.println(e.toString());
            }
        }
    }

附：

[https://blog.csdn.net/qq\_22075041/article/details/78771554][https_blog.csdn.net_qq_22075041_article_details_78771554]

[https://blog.csdn.net/hexiaoli666/article/details/82768615][https_blog.csdn.net_hexiaoli666_article_details_82768615]

[https_www.jb51.net_article_72901.htm]: https://www.jb51.net/article/72901.htm
[https_blog.csdn.net_qq_22075041_article_details_78771554]: https://blog.csdn.net/qq_22075041/article/details/78771554
[https_blog.csdn.net_hexiaoli666_article_details_82768615]: https://blog.csdn.net/hexiaoli666/article/details/82768615