81 第八天 魔乐java基础视频学习笔记.docx

81 第八天 魔乐java基础视频学习笔记.docx

《81 第八天 魔乐java基础视频学习笔记.docx》由会员分享，可在线阅读，更多相关《81 第八天 魔乐java基础视频学习笔记.docx（16页珍藏版）》请在冰点文库上搜索。

81第八天魔乐java基础视频学习笔记

1、课程名称：

异常的捕获及处理

2、知识点

2.1、上次课程的主要知识点

1、面向对象第一阶段：

围绕着简单Java类、对象比较、引用传递、接口为主；

2、匿名内部类：

在抽象类和接口的基础之上定义的操作，匿名内部类属于接口或抽象类的子类，只使用一次；

3、Object类：

接收所有引用数据类型对象，对象的输出调用toString（），对象比较是equals（）；

4、包装类：

自动装箱和拆箱，因为有此概念，所以Object可以接收基本类型，String和基本类型的转换操作。

2.2、本次预计讲解的知识点

1、异常产生的基本原因及影响；

2、异常处理的标准格式。

3、具体内容

3.1、认识异常（了解）

异常是程序之中导致程序中断的一种指令流，下面，通过两个程序来进行异常产生问题的对比。

范例：

不产生异常的程序

classNew{

publicstaticvoidmain（String[]args）

{

System.out.println（"1、除法计算开始。

"）;

intresult=10/2;

System.out.println（"2、除法计算结果:

"+result）;

System.out.println（"3、除法计算结果。

"）;

}

}

1、除法计算开始。

2、除法计算结果:

5

3、除法计算结果。

范例：

产生异常的程序：

classNew{

publicstaticvoidmain（String[]args）

{

System.out.println（"1、除法计算开始。

"）;

intresult=10/0;//会出现错误

System.out.println（"2、除法计算结果:

"+result）;

System.out.println（"3、除法计算结果。

"）;

}

}

1、除法计算开始。

Exceptioninthread"main"java.lang.ArithmeticException:

/byzero

atNew.main（New.java:

5）

这个时候程序出现了错误，那么出现错误之后的程序不执行了，而是直接进行了错误信息的输出，并且直接结束程序。

但是，出现了错误，应该去处理才对，但是现在没有处理。

3.2、处理异常（重点）

现在，如果希望程序出现了异常之后，程序依然可以正常的完成的话，那么就可以使用如下的格式进行异常处理。

try{

可能出现异常的语句；

}[catch（异常类型异常对象）{

处理异常；

}catch（异常类型异常对象）{

处理异常；

}...][finally{

不管是否出现异常，都执行此代码；

}]

范例：

使用以上的操作处理异常。

classNew{

publicstaticvoidmain（String[]args）

{

System.out.println（"1、除法计算开始。

"）;

try{

intresult=10/0;//会出现错误

System.out.println（"2、除法计算结果:

"+result）;

}catch（ArithmeticExceptione）{

System.out.println（e）;

}

System.out.println（"3、除法计算结果。

"）;

}

}

1、除法计算开始。

java.lang.ArithmeticException:

/byzero

3、除法计算结果。

可以发现，加入了异常处理之后，程序之中即使有了异常，程序也可以正常的执行完毕，但是现在发现，异常处理时的错误输出信息和之前相比，出错的信息不明确了，那么为了让错误的信息更加的完整，一般而言，都会调用printStackTrace（）方法进行异常信息的打印，这个方法打印的异常信息是最完整的：

java.lang.ArithmeticException:

/byzero

atNew.main（New.java:

6）

范例：

加入finally

classNew{

publicstaticvoidmain（String[]args）

{

System.out.println（"1、除法计算开始。

"）;

try{

intresult=10/0;//会出现错误

System.out.println（"2、除法计算结果:

"+result）;

}catch（ArithmeticExceptione）{

e.printStackTrace（）;

}finally{

System.out.println（"不管是否出现异常都执行"）;

}

System.out.println（"3、除法计算结果。

"）;

}

}

对于finally的实际应用必须结合之后的异常处理的标准格式来看，单独看，没意义。

但是，对于之前的程序现在又有了问题：

现在执行数学计算的两个参数，都是由我们程序默认提供，那么如果说现在两个计算的参数通过初始化参数传递呢？

classNew{

publicstaticvoidmain（String[]args）

{

System.out.println（"1、除法计算开始。

"）;

try{

intx=Integer.parseInt（args[0]）;

inty=Integer.parseInt（args[1]）;

intresult=x/y;

System.out.println（"2、除法计算结果:

"+result）;

}catch（ArithmeticExceptione）{

e.printStackTrace（）;

}finally{

System.out.println（"不管是否出现异常都执行"）;

}

System.out.println（"3、除法计算结果。

"）;

}

}

这个时候，数据由外部传送，那么在这种情况下，就有可能出现以下几类问题：

·执行时不输入参数：

ArrayIndexOutOfBoundsException，未处理；

·输入的参数不是数字：

NumberFormatException，未处理；

·被除数为0：

ArithmeticException，已处理。

可以发现，以上的程序实际上是存在三种异常，而程序之中只能够处理一种，而对于不能处理的异常，发现程序依然会直接中断执行。

classNew{

publicstaticvoidmain（String[]args）

{

System.out.println（"1、除法计算开始。

"）;

try{

intx=Integer.parseInt（args[0]）;

inty=Integer.parseInt（args[1]）;

intresult=x/y;

System.out.println（"2、除法计算结果:

"+result）;

}catch（ArithmeticExceptione）{

e.printStackTrace（）;

}catch（ArrayIndexOutOfBoundsExceptione）{

e.printStackTrace（）;

}catch（NumberFormatExceptione）{

e.printStackTrace（）;

}finally{

System.out.println（"不管是否出现异常都执行"）;

}

System.out.println（"3、除法计算结果。

"）;

}

}

此时，问题就来了。

如果按照以上的方式一次一次的测试来进行异常类型的推断，还不如直接编写多个if..else。

3.3、异常的处理流程（重点）

以上已经完成了异常的基本处理流程，但是也可以发现问题，所有的异常都像之前那样一条条的判断似乎是一件不可能完成的任务，因为日后肯定会接触到一些不常见的异常信息，那么下面就必须首先研究异常的流程和结构。

先查看两个异常类的继承结构：

ArithmeticException：

ArrayIndexOutOfBoundsException：

Java.lang.Object

|.java.lang.Throwable

|.java.lang.Exception

|.java.lang.Runtime.Exception

|.java.lang.ArithmeticException

Java.lang.Object

|.java.lang.Throwable

|.java.lang.Exception

|.java.lang.Runtime.Exception

|.java.lang.IndexOutOfBoundsException

|.java.lang.ArrayIndexOutOfBoundsException

可以发现所有的异常处理类型最高的继承类是Throwable。

通过Doc文档可以现在在Throwable下有两个子类：

（面试题：

请解释Error和Exception的区别？

）

·Error：

指的是JVM错误，这个时候的程序并没有执行，无法处理；

·Exception：

指的是程序之中出现的错误信息，可以进行异常处理，主要关心Exception。

那么通过继承关系可以发现，肯定在进行日后异常处理的时候是以Exception为主，而这个时候就可以形成以下的异常处理流程（面试题：

请解释java之中的异常处理流程）

1、如果程序之中产生了异常，那么会自动的由JVM根据异常的类型，实例化一个指定异常类的对象；

2、如果这个时候程序之中没有任何的异常处理操作，则这个异常类的实例化对象将交给JVM进行处理，而JVM的默认处理方式就是进行异常信息的输出，而后中断程序执行；

3、如果程序之中存在了异常处理，则会由try语句捕获产生的异常类对象；

4、与try之后的的每一个catch进行匹配，如果匹配成功，则使用指定的catch进行处理，如果没有匹配成功，则向后面的catch继续匹配，如果没有任何的cathc匹配成功，则这个时候将交给JVM执行默认处理；

5、不管是否有异常，都会执行finally程序，如果此时没有异常，执行完finally，则会继续执行程序之中的其他代码，如果此时有异常没有能够处理（没有一个catch可以满足），那么也会执行finally，但是执行完finally之后，将默认交给JVM进行异常的信息输出，并且程序中断。

通过以上的分析，可以发现，实际上catch捕获异常类型的操作，就和方法接收参数是一样的，那么按照之前所学习过的对象多态性来讲，所有的异常类都是Exception的子类，那么这个时候，实际上所有的异常都可以使用Exception进行接收。

classNew{

publicstaticvoidmain（String[]args）

{

System.out.println（"1、除法计算开始。

"）;

try{

intx=Integer.parseInt（args[0]）;

inty=Integer.parseInt（args[1]）;

intresult=x/y;

System.out.println（"2、除法计算结果:

"+result）;

}catch（Exceptione）{

e.printStackTrace（）;

}finally{

System.out.println（"不管是否出现异常都执行"）;

}

System.out.println（"3、除法计算结果。

"）;

}

}

这个时候就应该可以感受到异常处理所带来的好处了。

但是这种操作也存在一种问题。

如果在一些异常处理要求严格的项目之中，异常必须分别处理，如果现在异常的处理要求不是很严格，直接编写Exception就足够了。

3.4、throws关键字（重点）

Throws关键字主要是在方法定义上使用的，表示的是此方法之中不进行异常的处理，而交给被调用处处理。

classMyMath{

publicintdiv（intx,inty）throwsException{

returnx/y;

}

}

classNew{

publicstaticvoidmain（String[]args）{

System.out.println（newMyMath（）.div（10,2））;

}

}

现在的div（）方法之中抛了一个异常出来，表示的是，所有的异常交给被调用处进行处理。

classMyMath{

publicintdiv（intx,inty）throwsException{

returnx/y;

}

}

classNew{

publicstaticvoidmain（String[]args）{

try{

System.out.println（newMyMath（）.div（10,0））;

}catch（Exceptione）{

e.printStackTrace（）;

}

}

}

在调用throws声明方法的时候，一定要使用异常处理操作进行异常的处理，这个是属于强制性的处理，而现在主方法本身也属于方法，那么实际上在主方法上也可以继续使用throws进行异常的输出。

classMyMath{

publicintdiv（intx,inty）throwsException{

returnx/y;

}

}

classNew{

publicstaticvoidmain（String[]args）throwsException{

System.out.println（newMyMath（）.div（10,0））;

}

}

这个时候表示的是将异常继续向上抛，交给JVM进行异常的处理

3.5、throw关键字（重点）

之前的所有异常类对象都是由JVM自动进行实例化操作的，而现在用户也可以自己手工抛出一个实例化对象，就通过throw完成了。

publicclassNew{

publicstaticvoidmain（String[]args）throwsException{

try{

thrownewException（"我抛"）;

}catch（Exceptione）{

e.printStackTrace（）;

}

}

}

理论上，对于异常应该躲，现在属于不躲反而自己抛了，有病吗？

3.6、异常处理的标准格式（重点）

现在觉得有两个内容实在是没有用处：

finally、throw。

现在要求定义一个div（）方法，而这个方法有如下的一些要求：

·在进行除法操作之前，输出一行提示信息，可以理解为大爷开门；

·在除法操作执行完毕后，输出一行提示信息，可以理解为大爷关门；

·如果中间产生了异常，则应该交给被调用处来进行处理，譬如：

xxOver了。

classMyMath{

//出现异常要交给被调用处处理的话，使用throws

publicintdiv（intx,inty）throwsException{

System.out.println（"====计算开始===="）;//资源打开

intresult=0;

try{

result=x/y;//除法计算

}cathc（Exceptione）{

throwe;//向上抛

}finally{

System.out.println（"====计算结束===="）;//资源关闭

}

returnresult;

}

}

publicclassNew{

publicstaticvoidmain（String[]args）throwsException{

try{

System.out.println（newMyMath（）.div（10,0））;

}catch（Exceptione）{

e.printStackTrace（）;

}

}

}

而对于以上的操作代码也可以按照如下的简化格式编写。

classMyMath{

//出现异常要交给被调用处处理的话，使用throws

publicintdiv（intx,inty）throwsException{

System.out.println（"====计算开始===="）;//资源打开

intresult=0;

try{

result=x/y;//除法计算

}finally{

System.out.println（"====计算结束===="）;//资源关闭

}

returnresult;

}

}

publicclassNew{

publicstaticvoidmain（String[]args）throwsException{

try{

System.out.println（newMyMath（）.div（10,0））;

}catch（Exceptione）{

e.printStackTrace（）;

}

}

}

以上不带有catch的操作在开发之中不建议使用，永远的标准格式：

try…catch、finally、throws、throw一起使用。

3.7、RuntimeException（重点）

在讲解此操作之前，首先来观察一下如下代码。

publicclassNew{

publicstaticvoidmain（String[]args）throwsException{

Stringstr="1234";

intnum=Integer.parseInt（str）;

System.out.println（num*num）;

}

}

这个程序就是将一个字符串变为了基本数据类型，而后执行乘法操作，但是下面来看一下parseInt（）方法定义：

publicstaticintparseInt（Strings）throwsNumberFormatException

发现这个方法上抛出了一个NumberFormatException的异常，按照之前所讲，如果存在了throws，则必须使用try..catch进行处理，可是现在却没有强制要求处理，来观察以下NumberFormatException的继承结构：

Java.lang.Object

|.java.lang.Throwable

|.java.lang.Exception

|.java.lang.Runtime.Exception

|.java.lang.llegalArgumentException

|.java.lang.NumberFormatException

发现NumberFormatException属于RuntimeException的子类，而在Java之中明确规定了，对于RuntimeException的异常类型可以有选择性的来进行处理，在开发之中，如果没有处理，那么出现异常之后将交给JVM默认进行处理。

面试题：

请解释一下RuntimeException和Exception的区别？

请列举出几个常见的RuntimeException。

·RuntimeException是Exception的子类；

·Exception定义了必须处理的异常，而RuntimeException定义的异常可以选择性的进行处理；

·常见的RuntimeException：

NumberFormatException、ClassCastException、NullPointException、ArithmeticException、ArrayIndexOutOfBoudsException。

3.8、断言：

assert（了解）

断言指的是程序执行到某行之后，其结果一定是预期的结果，而在JDK1.4之后增加了一个assert关键字。

范例：

使用断言

publicclassNew{

publicstaticvoidmain（String[]args）throwsException{

intx=10;

//假设经过了若干操作

assertx==30:

"x的内容不是30";

System.out.println（x）;

}

}

默认情况下，Java之中的断言，不会在正常执行的代码中出现，如果要想启用断言，则应该增加一些选项：

java-eaNew

3.9、自定义异常类（了解）

在Java之中本身已经提供了大量的异常类型，但是在开发之中，这个异常类型根本就不能满足于开发的需要，所以在一些系统架构之中往往会提供一些新的异常类型，来表示一些特殊的错误，而这种操作就称为一定要异常类，而要想实现这种自定义异常类，那么可以让一个类继承Exception或RuntimeException。

范例：

自定义异常类

classMyExceptionextendsException{//自定义异常类

publicMyException（Stringmsg）{

super（msg）;

}

}

publicclassNew{

publicstaticvoidmain（String[]args）throwsException{

thrownewMyException（"自己的异常类"）;

}

}

如果以后见到了一些特殊的没见过的异常类，基本上都表示自定义的。

4、总结

1、异常的处理流程，出现错误之后的程序不执行；

2、异常处理的标准结构：

try…catch、finally、throw、throws的使用；

3、RuntimeException和Exception的区别。