Java中怎么处理异常类型

这期内容当中小编将会给大家带来有关Java中怎么处理异常类型，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。

一、异常的描述

程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常。异常发生时，是任程序自生自灭，立刻退出终止。在Java中即，Java在编译或运行或者运行过程中出现的错误。

Java提供了更加优秀的解决办法：异常处理机制。

异常处理机制能让程序在异常发生时，按照代码的预先设定的异常处理逻辑，针对性地处理异常，让程序尽最大可能恢复正常并继续执行，且保持代码的清晰。

Java中的异常可以是函数中的语句执行时引发的，也可以是程序员通过throw 语句手动抛出的，只要在Java程序中产生了异常，就会用一个对应类型的异常对象来封装异常，JRE就会试图寻找异常处理程序来处理异常。

• 异常指在运行时期发生的不正常情况。

• 在java中用类的形式对不正常情况进行了描述和封装对象。

• 描述不正常情况的类，就成为异常类。

• 将正常代码和问题处理代码分离，提高阅读性。

• 其实异常就是java通过面向对象的思想将问题封装成了对象，用异常类对其进行描述。

二、异常的体系

两大类:

• hrowable：可抛出的异常，无论是error还是exception，问题发生就应该可以抛出，让调用者知道并且处理。

• 该体系的特点就是在于Throwable及其所有的子类都具有可抛性。

可抛性到底指的是什么？怎么体现可抛性呢？

• 通过两个关键字来体现的。

• throws throw 凡是可以被这两个关键字所操作的类和对象都具有可抛性。

• 子类1  一般不可处理的。————Error

• 特点：是由jvm抛出的严重性问题，这种问题发生一般不针对性处理，直接修改程序。

• 子类2）可以处理的。————Exception，问题抛给调用者，谁用抛给谁。

• 特点：子类后缀名都是用其父类名作为后缀名，阅读性很强！

范例：比如自定义一个负数角标的异常，使用面向对象思想封装成对象。

• 注意：如果让一个类称为异常类，必须要继承异常类。因为只有异常体系的子类才具有可抛性。

class FuShuIndex extends Exception{                //构造函数 和类名一样                FuShuIndex(){                  }                //定义一个带参数的构造函数                FuShuIndex(String msg){                    //调用Exception中的带参数异常函数                    super(msg);                  }            }            主函数 throws FuShuIndex：{               int[] arr = new int[3];               method(arr,-7);            }            public static int method(int[] arr,int index) throws arrIndexexception {                 if (index<0){                    throw new arrIndexexception("数组的角标不能为负数");                 }                return arr[index];            }

三、异常的分类：

编译时被检测异常还要是Exception和其子类都是，除了特殊子类RuntimeException体系未处理即编译失败！

• 这种问题一旦出现，希望在编译时就进行检测，让这种问题有相应的处理方式，这样的问题都可以针对性处理。

编译时不被检测异常（运行时异常）：RuntimeException和其子类

• 可处理可不处理，编译都可以通过，运行时会检测！

• 这种问题的发生，无法让功能继续，运算无法运行，更多因为调用的原因导致，或者引发了内部状态的改变导致的。这种问题一般不处理，直接编译通过，在运行时，让调用者时程序强制停止，让调用者对代码进行修正。

throws和throw的区别：

• throws使用在函数上  ————申明

• throw使用在函数内，可以抛出多个，用逗号隔开。 ————抛出

• throws抛出的是异常类，可以抛出多个。

• throw抛出的是异常对象。

四、异常处理的捕捉形式

这是可以对异常进行针对性处理的方式。

格式：

try{            //需要被检测异常的代码        }        catch(异常类 变量)//该变量用于接收发生的异常对象{            //处理异常代码        }        finally{            //一定会被执行的代码      }

范例

class FuShuIndex extends Exception{            //构造函数 和类名一样            FuShuIndex(){              }            //定义一个带参数的构造函数            FuShuIndex(String msg){                //调用Exception中的带参数异常函数                super(msg);              }  }

主函数：无需throws抛出，下面我们自己捕获异常

{           int[] arr = new int[3];           try{           method(arr,-7);           }catch(arrIndexexception a){                a.printStackTrace();//jvm默认的异常处理机制就是调用异常对象的这个方法。                System.out.println("数组的角标异常！！！");//自定义捕获后打印的信息                System.out.println(a.toString());//打印该异常对象的信息                System.out.println(a.getMessage());//获取我们自定义抛出所定义的信息                }  }public static int method(int[] arr,int index) throws arrIndexexception {             if (index<0){                throw new arrIndexexception("数组的角标不能为负数");             }            return arr[index]; }

一个try对应多个catch：

• 多catch情况下，父类的catch要放在最下面，否则编译为空。

五、异常处理的原则

函数内部如果抛出了需要检测的异常，那么函数上必须申明，或者必须在函数内用try catch捕捉，否则编译失败。

如果调用到了申明异常的函数，要么try catch 或者 throws ，否则编译失败。

什么时候catch？什么时候throws？

• 功能内容可以解决，用catch。

• 解决不了，用throws告诉调用者，由调用者解决。

一个功能如果抛出了多个异常，那么调用时，必须有对应的多个catch来进行针对性处理。

• 内部有几个需要检测的异常，就抛几个异常，抛出几个就catch几个异常。

六、finally

通常用于关闭（释放）资源。必须要执行。除非jvm虚拟机挂了。

范例：出门玩，必须关门，所以将关门这个动作放在finally里面，必须执行。

凡是涉及到关闭连接等操作，要用finally代码块来释放资源。

try catch finally 代码块组合特点：

• try catch finally：当有资源需要释放时，可以定义finally

• try catch(多个)：当没有资源需要释放时，可以不定义finally

• try finally：异常处理不处理我不管，但是我得关闭资源，因为资源是我开的，得在内部关掉资源。

范例：

try{                    //连接数据库                }                    //没有catch意思不处理异常，只单纯的捕获异常                finally{                    //关闭连接                }

七、异常的应用

老师用电脑讲课范例：

电脑类：

public class Computer {                private int state = 2;                public void run() throws lanpingExcption,maoyanExcption{                    if (state == 1){                        throw new lanpingExcption("电脑蓝屏啦～");                    }else if (state == 2){                        throw new maoyanExcption("电脑冒烟啦～");                    }                    System.out.println("电脑启动");                }                public void chongqi(){                    state = 0;                    System.out.println("重启电脑！");                }  }

老师类：

public class Teacher {            private String name;            private Computer computer;            Teacher(String name){                this.name = name;                computer = new Computer();            }            void teach() throws maoyanExcption{                try {                    computer.run();                    System.out.println(this.name + "开始用电脑讲课了");                } catch (lanpingExcption l) {                    l.printStackTrace();                    computer.chongqi();                    teach();//重启后再次讲课                } catch (maoyanExcption m) {                    m.printStackTrace();                    test();                    throw m;                }            }            public void test(){                System.out.println("大家自己练习去～");            }  }

蓝屏异常类：

public class lanpingExcption extends Exception{            lanpingExcption (String msg){                 super(msg);            } }

冒烟异常类：

public class maoyanExcption extends Exception {            maoyanExcption (String msg){                super(msg);            }}

主函数：

public class Testmain {            public static void main (String[] args){                Teacher teacher = new Teacher("丁老师");                try {                    teacher.teach();                } catch (maoyanExcption m) {                    //m.printStackTrace();                    System.out.println("。。。。。");                }            }    }

八、异常的注意事项：

• 子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类。

• 如果父类抛出多个异常，那么子类只能抛出父类异常的子集。

• 子类覆盖父类，只能抛出父类的异常或者子类。

• 如果父类的方法没有抛出异常，子类覆盖时绝对不能抛。

上述就是小编为大家分享的Java中怎么处理异常类型了，如果刚好有类似的疑惑，不妨参照上述分析进行理解。如果想知道更多相关知识，欢迎关注编程网行业资讯频道。