<small id='iuFt1zV'></small> <noframes id='Th9i7aVvzx'>

  • <tfoot id='KnQ3'></tfoot>

      <legend id='3dsZ'><style id='plVsPd'><dir id='T4uKl0D9'><q id='jpJxIfoCXy'></q></dir></style></legend>
      <i id='lHhGE63'><tr id='MBgOb'><dt id='s91HpD3'><q id='DXHsJ'><span id='YylwJrX9e6'><b id='IH01'><form id='QeFtZVUJEx'><ins id='rJz27'></ins><ul id='cp4H'></ul><sub id='FcutBgR63w'></sub></form><legend id='0fjHS2qUpC'></legend><bdo id='V1dYUrZ'><pre id='eXv2hDaUq'><center id='dFmY'></center></pre></bdo></b><th id='HOKuWJ'></th></span></q></dt></tr></i><div id='PBwV'><tfoot id='kKsDUWiXh8'></tfoot><dl id='krIdQq3'><fieldset id='F7mAseVIzY'></fieldset></dl></div>

          <bdo id='AIlb7Lvs'></bdo><ul id='oNuXGUa'></ul>

          1. <li id='HPG8'></li>
            登陆

            Java 最全反常解说

            admin 2019-11-20 197人围观 ,发现0个评论

            Java知其所以然

            扶引问题

            实践工作中,遇到的状况不或许是十分完美的。比方:你写的某个模块,用户输入不必定契合你的要求、你的程序要翻开某个文件,这个文件或许不存在或许文件格局不对,你要读取数据库的数据,数据或许是空的等。咱们的程序再跑着,内存或硬盘或许满了。等等。

            软件程序在运转进程中,十分或许遇到刚刚说到的这些反常问题,咱们叫反常,英文是:Exception,意思是破例。这些,破例状况,或许叫反常,怎样让咱们写的程序做出合理的处理。而不至于程序溃散。

            常见的过错:

            1. 用户输入过错
            2. 设备过错。硬件问题,比方打印机关掉、服务器问题
            3. 物理约束。磁盘满了
            4. 代码约束。数组下标越界等

            规划杰出的程序应该在反常发作时供给处理这些过错的方法,使得程序不会由于反常的发作而终断或发作不行预见的成果。

            假如没有反常处理机制,那么:

            两个害处:

            1.逻辑代码和过错处理代堆放一同!

            2.程序员自身需求考虑的破例状况较杂乱,对程序员自身要求较高!

            反常机制便是当程序呈现过错,程序怎么安全退出的机制。

            反常(Exception)的概念

            Java 怎么处理反常?

            第一个反常示例和解析:

            public static void main(String[] args) {
            int i = 1/0;
            }
            Exception in thread "main" java.lang.ArithmeticException: / by zero
            at chuji.BubbleSort.main(BubbleSort.java:11)

            Java 是选用面向目标的方法来处理反常的。

            处理进程:

            抛出反常:在履行一个方法时,假如发作反常,则这个方法生成代表该反常的一个目标,中止当时履行途径,并把反常目标提交给 JRE。

            捕获反常:JRE 得到该反常后,寻觅相应的代码来处理该反常。JRE 在方法的调用栈中查找,从生成反常的方法开端回溯,直到找到相应的反常处理代码停止。

            反常分类

            JDK 中界说了许多反常类,这些类对应了各式各样或许呈现的反常事情,一切反常目标都是派生于 Throwable 类的一个实例。假如内置的反常类不能够满足需求,还能够创立自己的反常类。

            反常类之间的联系图

            Error

            Error 类层次描绘了 Java 运转时体系内部过错和资源耗尽过错。这类过错是咱们无法控制的,一起也是十分稀有的过错。所以在编程中,不去处理这类过错。

            Error 标明体系 JVM 现已处于不行康复的溃散状况中。咱们不需求管他。

            翻开 JDK 的:java.lang.error,查看他的一切子类。

            Exception

            一切反常类的父类,其子类对应了各式各样或许呈现的反常事情。

            Error 和 Exception 的差异:

            我开着车走在路上,一头猪冲在路中心,我刹车。这叫一个反常。

            我开着车在路上,发动机坏了,我泊车,这叫过错。体Java 最全反常解说系处于不行康复的溃散状况。发动机什么时分坏?咱们一般司机能管吗?不能。发动机什么时分坏是汽车厂发动机制造商的事。

            Runtime Exception

            呈现 RuntimeException 就必定是你的问题,能够不捕获,由于当心点这些反常是能够防止的。 派生于 RuntimeException 的反常。是一类特别的反常,如被 0 除、数组下标超规模等,其发作比较频频,处理费事,假如显式的声明或捕获将会对程序可读性和运转功率影响很大。因而由体系主动检测并将它们交给缺省的反常处理程序(用户可不用对其处理)。这类反常一般是由编程过错导致的,由于只要当心点,这些反常都是能够防止的,所以在编写程序时,并不要求有必要运用反常处理机制来处理这类反常,一切这类反常都承继自 java.lang.RuntimeException。

            常见的运转时反常有:

            1. ArithmeticException
            2. 如企图除以0
            3. NullPointerException
            4. 当程序拜访一个空目标的成员变量或方法,拜访一个空数组的成员时发作
            5. ClassCastException
            6. 发作多态后,假如强制转化的并不是父类的子类时发作。编译的时分能够经过,由于编译的时分并不会查看类型转化的问题
            7. ArrayIndexOutOfBoundsException
            8. 拜访的元素下表超越数组长度
            9. NumberFormatException
            10. 数字格局反常!

            心得:

            咱们平常在遇到 NullPointerException,也便是空指针的问题时,不要只记住百度,应该从报错的当地去剖析自己的代码,由于空指针其实是你的代码写的不谨慎形成的。空指针解决方案:Debug ,看你对应的值是否为 null。

            Checked Exception

            一切不是 Runtime Exception 的反常,统称为 Checked Exception,又被称为“已查看反常”。 这类反常的发作不是程序自身的问题,一般由外界要素形成的。为了防备这些反常发作时,形成程序的中止或得到不正确的成果,Java 要求编写或许发作这类反常的程序代码时,必定要去做反常的处理。

            编译器将查看是否为一切已查看反常供给反常处理。

            这一类反常,咱们有必要捕获进行处理。

            Java 言语将派生于 RuntimeException 类或 Error 类的一切反常称为“未查看反常”。

            反常的处理方法之一:捕获反常

            try块

            try 句子指定了一段代码,该段代码便是一次捕获并处理的规模。在履行进程中,当恣意一条句子发作反常时,就会越过该段中后边的代码。代码中或许会发作并抛出一种或几种类型的反常目标,它后边的catch句子要分别对这些反常做相应的处理

            一个 try 句子有必要带有至少一个 catch 句子块或一个 finally 句子块 。

            注:当反常处理的代码履行完毕今后,是不会回到try句子去履行没有履行的代码。

            catch

            1. 每个 try 句子块能够随同一个或多个 catch 句子,用于处理或许发作的不同类型的反常目标。

            2. 常用方法:

            • toString ( )方法,显现反常的类名和发作反常的原因
            • getMessage( ) 方法,只显现发作反常的原因,但不显现类名。
            • printStackTrace( ) 方法,用来盯梢反常事情发作时仓库的内容。

            这些方法均承继自 Throwable 类

            3. catch 捕获反常时的捕获次序:

            假如反常类之间有承继联系,在次序安排上需注意。越是顶层的类(父类),越放在下面。再不然就直接把剩余的 catch 省掉掉。

            finally

            有些句子,不论是否发作了反常,都有必要要履行,那么就能够把这样的句子放到finally 句子块中。

            一般在 finally 中关闭程序块已翻开的资源,比方:文件流、开释数据库衔接等。

            典型代码:

            public class TestException {
            public static void main(String[] args) {
            FileReader reader = null;
            try {
            reader = new FileReader("d:/a.txt");
            char temp = (char) reader.read();
            System.out.println("读出的内容:" + temp);
            } catch (FileNotFoundException e) {
            System.out.println("文件没有找到!!");
            e.printStackTrace();
            } catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件读取过错!");
            } finally {
            System.out.println(" 不论有没有反常,我肯定会被履行!");
            try {
            reader.close();
            } catch (IOException e) {
            e.printStacJava 最全反常解说kTrace();
            }
            }
            }
            }

            try, catch,finally ,return 履行次序

            履行次序:

            1.履行 try,catch , 给返回值赋值

            2.履行finally

            3.return

            反常的处理方法之二:声明反常(throws 子句)

            当 Checked Exception 发作时,不必定马上处理它,能够再把反常 Throws 出去。

            在方法中运用 try-chatch-finally 由这个方法处理反常。在一些状况下,当时方法并不需求处理发作的反常,而是向上传递给调用它的方法处理。

            假如一个方法中或许发作某种反常,可是并不能确认怎么处理这种反常,则应依据反常规范在琅琊榜小说方法的首部声明该方法或许抛出的反常。

            假如一个方法抛出多个已查看反常,就有必要在方法的首部列出一切的反常,之间以逗号离隔。

            典型代码:

            public class FileTest {
            public static void main(String[] args) {
            try {
            readFile("d:/a.txt");
            } catch (FileNotFoundException e) {
            System.out.println("所需求的文件不存在!");
            e.printStackTrace();
            } catch (IOException e) {
            System.out.println("文件读写出过错!");
            e.printStackTrace();
            }
            }
            public static void readFile(String fileName) throws IOException {
            FileReader in = new FileReader(fileName);
            try {
            int tem = 0;
            tem = in.read();
            while (tem != -1) {
            System.out.println((char) tem);
            tem = in.read();
            }
            } finally {
            in.close();
            }
            }
            }

            方法重写中声明反常准则

            子类声明的反常规模不能超越父类声明的规模。包括如下意思:

            1. 父类没有声明反常,子类也不能;
            2. 不行抛出原有方法抛出反常类的父类或上层类
            3. 抛出的反常类型的数目不行以比原有的方法抛出的还多(不是指个数)

            反常的处理方法之三:手动抛出反常(throw子句)

            Java 反常类目标除在程序履行进程中呈现反常时由体系主动生成并抛出,也可依据需求手艺创立并抛出。

            在捕获一个反常前,有必要有一段代码先生成反常目标并把它抛出。这个进程咱们能够手艺做,也能够由 JRE 来完成,可是他们调用的都是 throw 子句。

            关于一个现已存在的反常类,抛出该类反常目标进程如下:

            1. 找到一个适宜的反常类。

            2. 创立一个该类的目标。

            3. 将目标抛出

            File f = new File(Java 最全反常解说"c:/tt.txt");

            if (!f.exists()) {

            try {

            throw new FileNotFoundException("File can't be found!");

            } catch (FileNotFoundException e) {

            e.printStackTrace();

            }

            }

            自界说反常

            在程序中,或许会遇到任何规范反常类都没有充沛的描绘清楚的问题,这种状况下能够创立自己的反常类。

            怎样做:

            从 Exception 类或许它的子类派生一个子类即可

            习惯上,界说的类应该包括 2 个结构器:一个是默许的结构器,另一个是带有详细信息的结构器。

            典型代码

            class IllegalAgeException extends Exception {
            public IllegalAgeException() {
            }
            public IllegalAgeException(String msg) {
            super(msg);
            }
            }
            class Person {
            private String name;
            private int age;
            public void setName(String name) {
            this.name = name;
            }
            public void setAge(int age) {
            if (age < 0)
            throw new IllegalAgeException("人的年纪不该该为负数");
            this.age = age;
            }
            public String toString() {
            return "name is " + name + " and age is " + age;
            }
            }
            public class MyExceptionTest {
            public static void main(String[] args) {
            Person p = new Person();
            try {
            p.setNamJava 最全反常解说e("Lincoln");
            p.setAge(-1);
            } catch (IllegalAgeException e) {
            e.printStackTrace();
            System.exit(-1);
            }
            System.out.println(p);
            }
            }

            运用反常机制主张

            1. 要防止运用反常处理替代过错处理,这样会下降程序的明晰性,而且功率低下( Java 是选用面向目标的方法来处理反常的,所以也是会有必定的开支)
            2. 只在反常状况下运用反常机制
            3. 不要进行小粒度的反常处理---应该将整个使命尽或许包装在一个 Try 句子块中
            4. 反常往往在低层抛出,高层处理(捕获)

            总结

            • 一个图
            • 五个关键字(try, catch, finally, throws, throw)
            • 先逮小的(子类),再逮大的(父类)
            • 反常和重写的联系
            • 自界说反常
            请关注微信公众号
            微信二维码
            不容错过
            Powered By Z-BlogPHP