自定义异常
05错误及异常处理
错误及及异常处理
• 综合实例Example6_9
作业
• 书上1-6章的所有代码 • 生肖、星座、身份证、登陆、考试系统、 回声程序(首先登陆、选择系统功能，异常， 方法，注释，用户友好性)
try-finally结构 结构
案例名称：使用 案例名称：使用try-finally语句 语句 程序名称： 程序名称：2-22.cs using System; public class Sample { public static void Main() { try { Console.WriteLine("执行try子句!"); goto leave; // 跳转到leave标签 } finally { Console.WriteLine("执行finally子句!"); } leave: Console.WriteLine("执行leave标签!"); } }
错误及及异常处理
• 详细实例 详细实例Example6_1
异常处理
• C#的异常可能由两种方式导致： • throw语句无条件抛出异常。 • C#语句和表达式执行过程中激发了某个异常的条件，使 得操作无法正常结束，从而引发异常。例如整数除法操作 分母为零时将抛出一个异常。 • 异常由try语句来处理，try语句提供了一种机制来捕捉执行 过程中发生的异常。Try语句有3种基本格式：
错误及及异常处理
• 自定义异常
避免使用很深的异常层次结构 尽量从System.Exception或其他常见基本异常派生异常 异常类名称尽量使用Exception作为结尾 一定要在所有异常上提供常见构造函数 详细地编写自定义异常的相关信息
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace Example6_1 { //定义一个自定义异常，该异常继承于InvalidOperationException异常类。 class MyException : InvalidOperationException { } }
Python中的异常类型及处理方式示例详解
Python中的异常类型及处理⽅式⽰例详解⽬录前⾔正⽂⼀、什么是异常⼆、异常的类型三、异常处理四、try 介绍五、finally 介绍六、raise 介绍结尾前⾔Python 是⼀种⾯向对象的、解释型的、通⽤的、开源的脚本编程语⾔。
现在市⾯上 Python ⾮常的流⾏，主要是因为它简单易⽤，学习成本低，⽐如要实现某个功能，Python 可能只需要⼏⾏代码，⽽⽤C语⾔可能需要上百⾏代码，因为C语⾔什么都要得从头开始编码，⽽ Python 已经内置了很多功能模块，所以，我们只需要导⼊特定的包，就可以实现想要的效果。
正⽂今天，我们主要来了解⼀下 Python 中的异常类型以及它们的处理⽅式。
说到异常处理，我们⾸先要知道什么是异常。
其实，异常就是⼀类事件，当它们发⽣时，会影响到程序的正常执⾏。
⼀、什么是异常其实，异常就是⼀类事件，当此类事件在程序执⾏过程中发⽣时，就会影响程序的正常执⾏。
⼀般情况下，在 Python ⽆法正常处理程序时就会发⽣⼀个异常，⽽异常是Python 的⼀种对象类型，⽤来表⽰⼀个错误。
当 Python 脚本发⽣异常时我们需要捕获并处理它，否则程序就会终⽌。
⼆、异常的类型Python 中定义了⼀些标准的异常类型，具体的异常名称和对应的实际意义，我们可以通过下⾯的表格来了解。
异常名称描述BaseException所有异常的基类SystemExit解释器请求退出KeyboardInterrupt⽤户中断执⾏(通常是输⼊^C)Exception常规错误的基类StopIteration迭代器没有更多的值GeneratorExit⽣成器(generator)发⽣异常来通知退出StandardError所有的内建标准异常的基类ArithmeticError所有数值计算错误的基类FloatingPointError浮点计算错误OverflowError数值运算超出最⼤限制ZeroDivisionError除(或取模)零 (所有数据类型)AssertionError断⾔语句失败AttributeError对象没有这个属性EOFError没有内建输⼊,到达EOF 标记EnvironmentError操作系统错误的基类IOError输⼊/输出操作失败OSError操作系统错误WindowsError系统调⽤失败ImportError导⼊模块/对象失败LookupError⽆效数据查询的基类IndexError序列中没有此索引(index)KeyError映射中没有这个键MemoryError内存溢出错误(对于Python 解释器不是致命的)NameError未声明/初始化对象 (没有属性)UnboundLocalError访问未初始化的本地变量ReferenceError弱引⽤(Weak reference)试图访问已经垃圾回收了的对象RuntimeError⼀般的运⾏时错误NotImplementedError尚未实现的⽅法SyntaxError Python 语法错误IndentationError缩进错误TabError Tab 和空格混⽤SystemError⼀般的解释器系统错误TypeError对类型⽆效的操作ValueError传⼊⽆效的参数UnicodeError Unicode 相关的错误UnicodeDecodeError Unicode 解码时的错误UnicodeEncodeError Unicode 编码时错误UnicodeTranslateError Unicode 转换时错误Warning警告的基类DeprecationWarning关于被弃⽤的特征的警告FutureWarning关于构造将来语义会有改变的警告OverflowWarning旧的关于⾃动提升为长整型(long)的警告PendingDeprecationWarning关于特性将会被废弃的警告RuntimeWarning可疑的运⾏时⾏为(runtime behavior)的警告SyntaxWarning可疑的语法的警告UserWarning⽤户代码⽣成的警告其实，在上述表格中列出的异常中，也具备⼀定的层次关系，我们可以通过下图来了解⼀下。
raise runtimeerror用法
raise runtimeerror用法`RuntimeError`是Python中的一个内置异常类，用于表示运行时错误。
当某个条件不满足时，可以使用`raise RuntimeError`语句来触发`RuntimeError`异常。
`raise RuntimeError`有两种使用方式：1. 简单触发异常：可以简单地使用`raise RuntimeError`语句来触发一个不带任何额外信息的`RuntimeError`异常。
示例如下：```pythonif some_condition:raise RuntimeError```2. 自定义异常信息：除了触发异常外，还可以提供自定义的异常信息，以便更清楚地说明异常的原因。
可以在`raise RuntimeError`后添加一个字符串参数，作为异常信息。
示例如下：```pythonif some_condition:raise RuntimeError("Some error message")```当触发`RuntimeError`异常时，程序会立即停止执行当前代码块，并开始处理异常。
可以使用`try-except`语句来捕获和处理该异常，以避免程序因异常而终止。
以下是一个完整的示例，演示了如何使用`raise RuntimeError`来触发并处理异常：```pythontry:if some_condition:raise RuntimeError("Some error message")except RuntimeError as e:print("Exception occurred:", str(e))```在上述示例中，如果`some_condition`为`True`，则会触发`RuntimeError`异常，并输出异常信息。
否则，程序会正常执行，不会触发异常。
Java常见异常（RuntimeException）详细介绍并总结
Java常见异常（RuntimeException）详细介绍并总结本⽂重在Java中异常机制的⼀些概念。
写本⽂的⽬的在于⽅便我很长时间后若是忘了这些东西可以通过这篇⽂章迅速回忆起来。
1. 异常机制1.1 异常机制是指当程序出现错误后，程序如何处理。
具体来说，异常机制提供了程序退出的安全通道。
当出现错误后，程序执⾏的流程发⽣改变，程序的控制权转移到异常处理器。
1.2 传统的处理异常的办法是，函数返回⼀个特殊的结果来表⽰出现异常（通常这个特殊结果是⼤家约定俗称的），调⽤该函数的程序负责检查并分析函数返回的结果。
这样做有如下的弊端：例如函数返回-1代表出现异常，但是如果函数确实要返回-1这个正确的值时就会出现混淆；可读性降低，将程序代码与处理异常的代码混爹在⼀起；由调⽤函数的程序来分析错误，这就要求客户程序员对库函数有很深的了解。
1.3 异常处理的流程1.3.1 遇到错误，⽅法⽴即结束，并不返回⼀个值；同时，抛出⼀个异常对象1.3.2 调⽤该⽅法的程序也不会继续执⾏下去，⽽是搜索⼀个可以处理该异常的异常处理器，并执⾏其中的代码2 异常的分类2.1 异常的分类2.1.1 异常的继承结构：基类为Throwable，Error和Exception继承Throwable，RuntimeException和IOException等继承Exception，具体的RuntimeException继承RuntimeException。
2.1.2 Error和RuntimeException及其⼦类成为未检查异常（unchecked），其它异常成为已检查异常（checked）。
2.2 每个类型的异常的特点2.2.1 Error体系 Error类体系描述了Java运⾏系统中的内部错误以及资源耗尽的情形。
应⽤程序不应该抛出这种类型的对象（⼀般是由虚拟机抛出）。
如果出现这种错误，除了尽⼒使程序安全退出外，在其他⽅⾯是⽆能为⼒的。
c中exception的用法
C中Exception的用法简介在C语言中，异常处理是一种机制，可以让程序在运行时遇到异常情况时执行特定的操作，而不是简单地崩溃或者产生不可预测的行为。
本文将介绍C语言中异常处理的概念和用法。
异常处理的概念在传统的C语言中，程序在运行时遇到错误或异常情况时，通常会产生未定义的行为，甚至导致程序崩溃。
而异常处理机制的引入，可以让我们在程序中明确地指定异常出现时应该执行的操作，从而提高程序的稳定性和可读性。
使用方法在C语言中，我们可以使用以下几个关键字和函数来实现异常处理：t r y使用`t ry`关键字来表示一段异常处理的代码块，其中包含可能引发异常的代码。
通常情况下，我们将会在`t r y`代码块中执行一些会出现异常的操作。
```ct r y{//可能引发异常的代码}```c a t c h使用`c at ch`关键字来定义异常处理的代码块，用于捕获和处理`tr y`代码块中抛出的异常。
我们可以使用多个`c at ch`代码块来分别处理不同类型的异常。
```ct r y{//可能引发异常的代码}c a tc h(ty pe1){//处理类型为t yp e1的异常}c a tc h(ty pe2){//处理类型为t yp e2的异常}//...```t h r o w使用`t hr ow`关键字来抛出异常。
可以将任何类型的数据作为异常抛出，但通常我们会定义一些特定的异常类型来表示不同的错误或异常情况。
```ct h ro we xc ep ti on;```自定义异常类型为了更好地管理和处理异常，我们可以自定义一些异常类型。
这样可以使代码更加清晰和可读，同时也提高了程序的可维护性。
定义异常类型我们可以使用结构体来定义一个自己的异常类型，并根据需要添加相应的字段。
```c//定义异常类型t y pe de fs tr uc t{i n tc od e;c h ar me ss ag e[100];}E xc ep ti on;```抛出异常当程序遇到错误或异常情况时，我们可以使用自定义的异常类型来抛出异常。
kotlin 方法thraw exception
kotlin 方法thraw exceptionKotlin 方法throw异常Kotlin是一种现代的编程语言，它旨在提供简单而直观的编程体验。
在Kotlin中，异常处理是一个重要的部分，用于处理程序中的错误和异常情况。
在本文中，我们将介绍如何在Kotlin中编写throw异常的方法。
一、throw异常简介在Kotlin中，throw异常用于在程序中显式地中止当前的执行流程，并传递一个异常对象给调用者。
通过使用throw语句，我们可以抛出特定的异常类型，以便在发生错误时采取适当的措施进行处理。
二、throw异常的语法在Kotlin中，可以使用throw语句来抛出异常。
语法如下：```kotlinthrow <exception_type>(arguments)```其中，`<exception_type>`是要抛出的异常类型的名称，`arguments`是可选的异常对象参数。
如果提供了异常对象参数，它将传递给调用者的catch块来处理。
三、几种常见的throw异常示例1. 自定义异常：在Kotlin中，可以通过定义自己的异常类来抛出特定的异常。
例如：```kotlinclass CustomException(message: String) :Exception(message)```在代码中抛出该异常：```kotlinfun testFunction() {throw CustomException("测试异常")}```2. RuntimeException：在Kotlin中，RuntimeException是Java 中RuntimeException的子类。
它可以用于表示代码中发生的不常见或意外的运行时错误。
例如：```kotlinfun testFunction() {throw RuntimeException("运行时异常")}```3. AssertionError：AssertionError是Java中的一种异常类型，用于表示代码中的断言失败。
python raise 用法
python raise 用法Python中的raise语句用法详解1. 引言在Python中，raise是一个关键字，用于手动引发异常。
我们可以使用raise语句来显式地触发异常，从而在程序中进行错误处理或控制流程。
2. raise的基本用法•raise后面可以跟一个异常类的实例来引发异常。
例如，raise ValueError("Invalid value")会引发一个ValueError异常，同时传递一条错误消息。
•使用raise语句时，可以不指定异常类，只传递一条错误消息。
例如，raise Exception("Something went wrong")会引发一个通用的Exception异常。
3. 自定义异常除了使用内置的异常类之外，我们还可以自定义异常类，以便更好地满足我们的需求。
自定义异常类可以继承自内置异常类或自定义异常类。
class CustomException(Exception):passtry:raise CustomException("This is a custom exception") except CustomException as e:print(e)4. 携带异常信息当使用raise语句引发异常时，可以携带更多的异常信息。
例如，我们可以使用raise语句携带一个异常对象，并在异常对象中设置一些特定的属性。
class CustomException(Exception):passtry:exc = CustomException("Something went wrong")_code = 42raise excexcept CustomException as e:print(e)print(_code)5. 再次引发异常在异常处理过程中，我们可以选择捕获并处理异常，或者重新引发该异常，使其被上层的异常处理程序捕获。
throw new serviceexception用法
`throw new ServiceException()` 是Java中抛出自定义异常的一种用法。
首先，你需要创建一个继承自`Exception` 或其子类的自定义异常类，然后在需要抛出异常的地方使用`throw` 关键字抛出该异常。
以下是一个简单的示例：
1. 创建一个自定义异常类`ServiceException`：
```java
public class ServiceException extends Exception {
public ServiceException(String message) {
super(message);
}
}
```
2. 在需要抛出异常的地方使用`throw new ServiceException()`：
```java
public void someMethod() throws ServiceException {
// 一些逻辑判断
boolean isError = true;
if (isError) {
throw new ServiceException("发生了一个错误");
}
}
```
在这个示例中，当`isError` 为`true` 时，`someMethod` 方法会抛出一个`ServiceException` 异常。
调用该方法的代码需要处理这个异常，例如使用`try-catch` 语句捕获并处理它。
exception用法
exception用法什么是exception？在计算机编程中，exception（异常）是指在程序运行过程中出现的错误或异常情况。
当程序执行到某个地方时，如果遇到了错误或者无法正常处理的情况，就会抛出一个异常。
异常可以是由程序员主动触发，也可以是由系统自动触发。
为什么要使用exception？异常处理机制是现代编程语言中的一个重要特性，其目的是提高程序的稳定性和可靠性。
通过使用异常处理机制，可以在程序出现错误时，及时捕获并处理异常情况，避免程序崩溃或产生未知结果。
通过合理地使用异常，可以提高代码的可读性和可维护性，使程序更加健壮和可靠。
如何使用exception？在编程中，使用异常需要遵循一定的规范和步骤。
首先，需要明确应该捕获哪些异常。
通常情况下，应该捕获那些可能导致程序出错或无法正常处理的异常，例如除零异常、空指针异常等。
接下来，需要在可能发生异常的地方添加异常处理的代码。
可以使用try-catch语句来捕获异常。
在try 块中，编写可能会产生异常的代码，而在catch块中，根据需要进行异常处理的代码。
当try块中的代码出现异常时，程序会跳转到对应的catch 块继续执行异常处理的代码。
此外，还可以使用finally块，该块中的代码不论是否发生异常都会执行。
finally块通常用于释放资源或进行清理操作。
除了try-catch-finally语句，还可以使用throw语句来主动抛出异常。
当程序中的某个条件不满足时，可以使用throw语句抛出一个异常对象。
throw语句将异常对象传递给调用者，然后由调用者决定如何处理该异常。
在处理异常时，应该根据具体情况进行合适的异常处理。
可以选择捕获异常后直接处理，也可以选择包装异常后再抛出。
包装异常通常用于在不损失异常信息的情况下将异常传递给上层调用者。
此外，在进行异常处理时，应该遵循“避免过早优化”的原则，尽量不要过度使用异常处理语句，以免降低代码的可读性和性能。
Java里的异常（Exception）详解
Java⾥的异常（Exception）详解作为⼀位初学者, 本屌也没有能⼒对异常谈得很深⼊. 只不过⾥关于Exception的东西实在是很多. 所以这篇⽂章很长就是了..⼀, 什么是java⾥的异常由于java是c\c++ 发展⽽来的, ⾸先我们先看看c语⾔⾥的错误.1.1 c语⾔⾥的错误我们实现1个程序的过程包括, 代码编写, 编译代码成为程序, 执⾏程序..其中⼤部分常见的语法错误都会被编译代码这样部过滤掉. 但是即使通过了编译. 执⾏程序这⼀步可能还是会有错误.原因很多, 例如常见的除数为0, 内存溢出(数组的index超出界限), 或者内存被其他程序修改等.最简单的例⼦:[java]1. #include <stdio.h>2.3. int f(int a, int b){4. return a/b;5. }6.7. int main(){8. int i = f(8,0);9. printf("i is %d\n",i);10. return 0;11. }上⾯的例⼦编译时是⽆错的, 但是⼀旦执⾏就会提⽰吐核错误了.c语⾔⾥对这种执⾏时出现的错误是⽆能为⼒的, ⼀旦出错就会整个程序崩溃, 就不会在继续执⾏下⾯的代码.⽽且很多时候出错信息很少, 让你⽆法判断出错的原因和地⽅, 只能⼀步步⼩⼼debug...所以很多⽤c写的程序有时会出现⾮法关闭的现象.解决⽅法只能是在代码⾥对可能出错的地⽅添加if 判断.例如f()函数⾥可以对b进⾏判断, 如果是0就不执⾏.1.2 java⾥运⾏时出现的错误java⾥编译器对代码的规范性⽐c严格得多. 但是即使如此, 通过编译的java程序有时也很难避免执⾏时出错.例如, 将上⾯的c程序改编成java程序:[java]1. package Exception_kng;2.3. class Exp1{4. public int f(int a, int b){5. return a/b;6. }7. }8.9. public class Expt_1{10. public static void g(){11. Exp1 e = new Exp1();12. int i = e.f(8,0);13. System.out.printf("i is %d\n", i);14. }15. }运⾏时⼀样会出错, 下⾯是出错信息:[java]1. [java] Caused by: ng.ArithmeticException: / by zero2. [java] at Exception_kng.Exp1.f(Expt_1.java:5)3. [java] at Exception_kng.Expt_1.g(Expt_1.java:12)4. [java] at Enter_1.main(Enter_1.java:31)但是可以见到, java告诉你出错的类型: 运算错误(ArithmeticExcetion), 出错信息和出错的类与⽂件⾏数输出, ⽅便你调试. jvm虚拟机是会对错误作出⼀定的处理的.所以可以简单地将java⾥的异常理解成java运⾏时出现的错误, 异常机制就是对这种错误进⾏处理的机制.1.3 java异常的定义实际上, 当java程序执⾏时出现错误时, jvm会把执⾏时出错的信息(例如出错原因, 类型, 位置) 收集,然后打包成为1个对象(object), 程序员可以对这种对象进⾏处理. 这种对象就是所谓的异常.可能出现的异常的代码并不是肯定会出现异常, 取决于执⾏环境和数据.!⼆, java⾥的异常的分类.见下图:Throwable/ \Error Exception/ / \xxxxxx xxxxxx RuntimeException/ \xxxxxx ArithmeticException上图的所有对象都是类.Throwable 代表是可抛出的.Error 代表的是严重错误, 这种错误程序员⽆法进⾏处理, 例如操作系统崩溃, jvm出错, 动态链接库失败等. Error并不是异常, 不是本⽂的重点.Exception 代表的就是异常了. 它下⾯很多派⽣类, 其中它的派⽣类也分两种, ⼀种是RuntimeException(运⾏时异常), 其他的都是⾮运⾏时异常RuntimeException 包括除数为0, 数组下标超界等. 运⾏时异常的派⽣类有很多, 其产⽣频率较⾼. 它的派⽣类可以由程序处理或者抛给(throw) 给jvm处理. 例如上⾯的例⼦就是抛给了jvm处理, jvm把程序中断执⾏, 并把错误信息输出到终端上.⾮RuntimeExcption 这种异常属于Excepion的派⽣类(上⾯红⾊的xxx), 但是不是RuntimeException的派⽣类, 这种异常必须由程序员⼿动处理,否则不通过编译.ArithmeticExcpetion 算术异常, 它是RuntimeException的派⽣类, 所以程序员不⼿动处理也通过编译, 只不过出错时会被jvm处理.三, java⾥对异常的处理java⾥对异常的处理有三种.3.1 程序猿对有可能出现的异常使⽤try catch处理.例如我们将上⾯的例⼦改动⼀下:[java]1. package Exception_kng;2.3. class Exp2{4. public int f(int a, int b){5. int i = 0;6. try{7. i = a/b;8. }9. catch(Exception e){10. System.out.printf("Exception occurs!!\n");11. System.out.println(e.getMessage()); //print the root cause12. System.out.printf("===========================\n");13. e.printStackTrace(); //print the info of function stuck.14. }15.16. return i;17. }18. }19.20. public class Expt_2{21. public static void g(){22. Exp2 ex = new Exp2();23. int i = ex.f(8,0); //call f()24. System.out.printf("i is %d\n", i); //successfully executed25. }26. }在f()函数中对可能出现的异常的代码进⾏try catch处理后, 程序会执⾏catch⾥的代码. ⽽且不会中断整个程序, 继续执⾏try catch后⾯的代码.程序执⾏输出:[java]1. [java] Exception occurs!!2. [java] / by zero3. [java] ===========================4. [java] ng.ArithmeticException: / by zero5. [java] at Exception_kng.Exp2.f(Expt_2.java:7)6. [java] at Exception_kng.Expt_2.g(Expt_2.java:23)7. [java] at Enter_1.main(Enter_1.java:31)8. [java] i is 0注意最终也执⾏了g()函数中的最后⼀条语句, 输出了i的值.也就是说try catch处理后并不会终⽌程序, 令程序即使出现了错误, 也可以对错误进⾏⼀定的处理后继续执⾏. 这就是java异常机制⽐c语⾔安全的地⽅.下⾯会详细讲解 try catch.注:getMessage() ⽅法: Exception类的⽅法之⼀, 返回异常的原因, 上⾯的 / by zero 就是这个⽅法输出的.printStackTrace(): Exception类的⽅法之⼀, 在屏幕输出函数栈信息, 也就是异常出现的地⽅.3.2 函数⾥并不处理异常, 使⽤throw or throws 关键字把可能出现的异常抛给调⽤该函数的上级函数处理.例如我在f()函数中不想处理可能出现的异常, 想把它抛出上级函数处理:下⾯是个例⼦:[java]1. package Exception_kng;2.3. class Exp3{4. public int f(int a, int b){5. if (0 == b){6. throw new ArithmeticException("Shit !!! / by zero!");7.8. }9.10. return a/b;11. }12. }13.14. public class Expt_3{15. public static void g() throws ArithmeticException{16. Exp3 ex = new Exp3();17. int i = 22;18. i = ex.f(8,0); //throw excetpion19. System.out.printf("i is %d\n", i); //failed executed20. System.out.printf("g() is done!!\n"); //failed executed21. }22.23. public static void h(){24. try{25. g();26. }catch(ArithmeticException e){27. System.out.printf("Exception occurs!!\n");28. System.out.println(e.getMessage()); //print the root cause29. System.out.printf("===========================\n");30. e.printStackTrace(); //print the info of function stuck.31. }32.33. System.out.printf("h() is done!!\n"); //successfully executed34. }35. }可以见到f() 加了个条件判断, 如果参数b = 0, 使⽤throw 直接⼿动抛出1个异常. 让调⽤它的函数处理.g()调⽤f()函数, 预见到f()可能有异常, 但是也不想处理, 使⽤throws 关键字告诉调⽤它的函数本函数有可能抛出这种异常. // 注, 这⾥的throws 对程序并没有实质的影响.h()调⽤g(), 简单g()定义的throws, ⽤try catch在本函数进⾏处理.输出:[java]1. [java] Exception occurs!!2. [java] Shit !!! / by zero!3. [java] ===========================4. [java] ng.ArithmeticException: Shit !!! / by zero!5. [java] at Exception_kng.Exp3.f(Expt_3.java:6)6. [java] at Exception_kng.Expt_3.g(Expt_3.java:18)7. [java] at Exception_kng.Expt_3.h(Expt_3.java:25)8. [java] at Enter_1.main(Enter_1.java:31)9. [java] h() is done!!注意这个程序没有执⾏g() 最后的代码.throw 和 throws 后⾯也会详细讲解.3.3 交给jvm虚拟机处理假如上⾯的例⼦h() 也不处理怎么办? 就如1.2 的例⼦, 会抛给jvm处理.但是这种情况只适⽤于RuntimeExecption及其派⽣类.jvm怎么处理呢, 就是中断整个程序, 并把异常信息输出到屏幕上.实际上, 当java程序的1个函数抛出异常时,⾸先会检查当前函数有没有try catch处理, 如果⽆检查上⼀级函数有⽆try..catch处理....这样在函数栈⾥⼀级⼀级向上检查, 如果直⾄main函数都⽆try..catch, 则抛给jvm..项⽬中强烈建议尽量⼿动处理, 不要把异常交给jvm.四,Try catch finally 的处理机制.这⾥开始详解try catch finally了.语法是这样的.try{可能出异常的若⼲⾏代码;}catch(ExceptionName1 e){产⽣ExceptionName 1的处理代码;}catch(ExceptionName2 e){产⽣ExceptionName 2的处理代码;}...finally{⽆论如何, 最终肯定会执⾏的代码}4.1 try catch finally的执⾏路线.下⾯⽤个例⼦来说明:[java]1. try{2. f();3. ff();4. }5. catch(ArithmeticException e){6. g();7. }8. catch(IOException e){9. gg();10. }11. catch(AuthorizedException e){12. ggg();13. }14. finally{15. h();16. }17.18. k();4.1.1 当try⾥⾯的f()抛出了IOException当f()抛出了异常, 那么ff()就不会执⾏了. 程序会尝试捕捉异常.⾸先捕捉ArithmeticException, 捕捉失败.接下来捕捉IOException, 捕捉成功, 执⾏gg();⼀旦捕捉到⼀个异常, 不会再尝试捕捉其他异常, 直接执⾏finally⾥的h();执⾏后⾯的函数k().也就是说路线是:f() -> gg() -> h() -> k()有2点要注意的.1. f()函数极有可能未完整执⾏, 因为它抛出了异常, 抛出异常的语句执⾏失败, 之后的语句放弃执⾏.2. try{} ⾥⾯, f()之后的语句, 例如ff()放弃执⾏.4.1.2 没有任何异常抛出这种情况很简单, 就是try{}⾥⾯的代码被完整执⾏, 因为没有抛出任何异常, 就不会尝试执⾏catch⾥的部分, 直接到finally部分了.路线是:f() -> ff() -> h() -> k()4.2 如何确定要捕捉的异常名字.也许有⼈会问, 我们怎么知道到底会抛出什么异常?下⾯有3个解决⽅案.1.看代码凭经验, 例如看到1段除法的代码, 则有可能抛出算术异常.2.在catch的括号⾥写上Exception e, 毕竟Exception 是所有其他异常的超类, 这⾥涉及多态的知识, ⾄于什么是多态可以看看本⼈的另⼀篇⽂章.3. 观察被调⽤函数的函数定义, 如果有throws后缀, 则可以尝试捕捉throws 后缀抛出的异常4.3 为什么需要finally包括我在内很多⼈会觉得finally语句简直多勾余, 既然是否捕捉到异常都会执⾏, 上⾯那个例⼦⾥的h()为什么不跟下⾯的k() 写在⼀起呢.上⾯的例⼦的确看不出区别.但下⾯两种情况下就体现了finally独特的重要性.4.3.1 抛出了1个异常, 但是没有被任何catch⼦句捕捉成功.例如try⾥⾯抛出了1个A异常, 但是只有后⾯只有捕捉B异常, 和C异常的⼦句.这种情况下, 程序直接执⾏finally{}⾥的⼦句, 然后中断当前函数, 把异常抛给上⼀级函数, 所以当前函数finally后⾯的语句不会被执⾏.例⼦:[java]1. package Exception_kng;2.3. import .*;4. import java.io.*;5.6. class Exp4{7. public int f(int a, int b) throws IOException, BindException{8. return a/b;9. }10. }11.12. public class Expt_4{13. public static void g(){14. Exp4 ex = new Exp4();15. int i = 22;16. try{17. System.out.printf("g() : try!!\n"); //failed18. i = ex.f(8,0); //call f()19. }20. catch(BindException e){21. System.out.printf("g() : BindException!!\n"); //failed22. }23. catch(IOException e){24. System.out.printf("g() : IOException!!\n"); //failed25. }26. finally{27. System.out.printf("g() : finaly!!\n"); //successfully executed28. }29. System.out.printf("g() is done!!\n"); //failed30. }31.32. public static void h(){33. try{34. g();35. }catch(ArithmeticException e){36. System.out.printf("Exception occurs!!\n");37. System.out.println(e.getMessage()); //print the root cause38. System.out.printf("===========================\n");39. e.printStackTrace(); //print the info of function stuck.40. }41.42. System.out.printf("h() is done!!\n"); //successfully executed43. }44. }我所说的情况, 就在上⾯例⼦⾥的g()函数, g()函数⾥尝试捕捉两个异常, 但是抛出了第3个异常(ArithmeticException 算术异常).所以这个异常会中断g()的执⾏, 因为没有被捕捉到, 然后抛给调⽤g()的 h()函数处理, ⽽在h()捕捉到了, 所以h()函数是能完整执⾏的.也就是说g()⾥的[java]1. System.out.printf("g() is done!!\n"); //failed执⾏失败⽽h()⾥的[java]1. System.out.printf("h() is done!!\n"); //successfully executed执⾏成功但是⽆论如何, g()⾥的finally{}部分还是被执⾏了执⾏结果如下:[java]1. [java] g() : try!!2. [java] g() : finaly!!3. [java] Exception occurs!!4. [java] / by zero5. [java] ===========================6. [java] ng.ArithmeticException: / by zero7. [java] at Exception_kng.Exp4.f(Expt_4.java:8)8. [java] at Exception_kng.Expt_4.g(Expt_4.java:18)9. [java] at Exception_kng.Expt_4.h(Expt_4.java:34)10. [java] at Enter_1.main(Enter_1.java:31)11. [java] h() is done!!这种情况是1中编程的低级错误, 在项⽬中是不允许出现.避免⽅法也⼗分简单, 在catch⼦句集的最后增加1个catch(Exception e)就ok, 因为Exception是所有异常的超类, 只要有异常抛出, 则肯定会捕捉到.4.3.2 在catch⼦句内有return⼦句.下⾯例⼦:[java]1. try{2. f();3. ff();4. }5. catch(ArithException e){6. g();7. return j();8. }9. catch(IOException e){10. gg();11. return j();12. }13. catch(AuthorizedException e){14. ggg();15. return j();16. }17. finally{18. h();19. }20.21. k();假如在f()函数抛出了IOExcepion 异常被捕捉到.那么执⾏路线就是f() -> gg() -> j() -> h() -> 上⼀级function也就说, 这种情况下finally⾥的⼦句会在return回上⼀级function前执⾏. ⽽后⾯的k()就被放弃了.4.3.3 finally作⽤⼩结.可以看出, finally⾥的语句, ⽆论如何都会被执⾏.⾄有两种情况除外, ⼀是断电, ⼆是exit函数.在项⽬中, 我们⼀般在finally编写⼀些释放资源的动作, 例如初始化公共变量. 关闭connections, 关闭⽂件等.4.4 try catch finally⾥⼀些要注意的问题.4.4.1 ⽆论如何最多只有1个catch被执⾏这个上⾯提到过了, ⼀旦捕捉到1个异常, 就不会尝试捕捉其他异常.如果try⾥⾯的⼀段代码可能抛出3种异常A B C,⾸先看它先抛出哪个异常, 如果先抛出A, 如果捕捉到A, 那么就执⾏catch(A)⾥的代码. 然后finally.. B和C就没有机会再抛出了.如果捕捉不到A, 就执⾏finally{}⾥的语句后中断当前函数, 抛给上⼀级函数...(应该避免)4.4.2 有可能所有catch都没有被执⾏两种情况, 1就是没有异常抛出, 另⼀种就是抛出了异常但是没有捕捉不到(应该避免)4.4.3 先捕捉⼦类异常, 再捕捉⽗类异常, 否则编译失败加⼊try ⾥⾯尝试捕捉两个异常, 1个是A, 1个是B, 但是A是B的⽗类.这种情况下, 应该把catch(B)写在catch(A)前⾯.原因也很简单, 加⼊把catch(A)写在前⾯, 因为多态的存在, 即使抛出了B异常, 也会被catch(A)捕捉, 后⾯的catch(B)就没有意义了.也就是说如果捕捉Exception这个异常基类, 应该放在最后的catch⾥, 项⽬中也强烈建议这么做, 可以避免上述4.3.1的情况出现.4.4.4 catch与catch之间不能有任何代码.这个没什么好说的. 语法规则4.4.5 finally⾥不能访问catch⾥捕捉的异常对象e每1个异常对象只能由catch它的catch⼦句⾥访问.4.4.6 try⾥⾯的定义变量不能在try外⾯使⽤.跟if类似, 不多说了.4.4.7 try catch finally可以嵌套使⽤.这个也不难理解..五, throw 和throws的机制和⽤法.下⾯开始详讲异常另⼀种处理⽅法throw 和 throws了.注意的是, 这两种⽤法都没有真正的处理异常, 真正处理的异常⽅法只有try catch, 这两种⽅法只是交给上⼀级⽅法处理.就如⼀个组织⾥ , 有1个⼤佬, 1个党主, 1个⼩弟.⼤佬叫党主⼲活, 堂主叫⼩弟⼲活, 然后⼩弟碰上⿇烦了, 但是⼩弟不会处理这个⿇烦, 只能中断⼯作抛给党主处理, 然后堂主发现这个⿇烦只有⼤佬能处理, 然后抛给⼤佬处理..道理是相通的..5.1 throw 的语法与作⽤throws的语法很简单.语法:throw new XException();其中xException必须是Exception的派⽣类.这⾥注意throw 出的是1个异常对象, 所以new不能省略作⽤就是⼿动令程序抛出1个异常对象.5.2 throw 1个 RuntimeException及其派⽣类我们看回上⾯3.2 的例⼦:[java]1. public int f(int a, int b){2. if (0 == b){3. throw new ArithmeticException("Shit !!! / by zero!");4.5. }6.7. return a/b;8. }5.2.1 throw会中断当前函数, 当前函数执⾏失败(不完整)当这个函数的if 判断了b=0时, 就利⽤throws⼿动抛出了1个异常. 这个异常会中断这个函数. 也就是说f()执⾏不完整, 是没有返回值的.5.2.2, 接下来哪个调⽤这个函数就会在调⽤这个函数的语句上收到异常.[java]1. public void g(){2. int i;3. h();4. i = f(); //recevie excepton5. k();6. }例如上没的g()函数, 在调⽤f() 会收到1个异常.这时g()函数有三种选择.1. 不做任何处理这时, g()收到f()⾥抛出的异常就会打断g()执⾏, 也就是说g()⾥⾯的k(); 被放弃了, 然后程序会继续把这个函数抛给调⽤g()函数.然后⼀级⼀级寻求处理, 如果都不处理, 则抛给jvm处理. jvm会中断程序, 输出异常信息. 这个上没提到过了.2. 使⽤try catch处理如果catch成功, 则g()函数能完整执⾏, ⽽且这个异常不会继续向上抛.如果catch失败(尽量避免), 则跟情况1相同.5.3 throw 1个⾮RuntimeException派⽣类的异常将上⾯的例⼦改⼀下:[java]1. public int f(int a, int b){2. if (0 == b){3. throw new IOException("Shit !!! / by zero!");4. }5.6. return a/b;7. }例如, 我不想抛出ArithmeticException, 我想抛出IOExcetpion.注意这⾥, IOException虽然逻辑上是错误的(完全不是IO的问题嘛), 但是在程序中完全可⾏, 因为程序猿可以根据需要控制程序指定抛出任何1个异常.但是这段代码编译失败, 因为IOException 不是 RuntimeException的派⽣类.java规定:5.3.1 如果⼀个⽅法⾥利⽤throw⼿动抛出1个⾮RuntimeException异常, 必须在函数定义声明⾥加上throws 后缀改成这样就正确了:[java]1. public int f(int a, int b) throws IOException{2. if (0 == b){3. throw new IOException("Shit !!! / by zero!");4. }5.6. return a/b;7. }注意在⽅法定义⾥加上了throws⼦句. 告诉调⽤它的函数我可能抛出这个异常.5.3.2 调⽤该⽅法的⽅法则必须处理这个异常例如抄回上⾯的例⼦, g()调⽤f()函数.[java]1. public void g(){2. int i;3. h();4. i = f(); //recevie excepton5. k()6. }但是编译失败.因为f()利⽤throws 声明了会抛出1个⾮runtimeExcetpion. 这时g()必须做出处理.处理⽅法有两种:1. try catch⾃⼰处理:[java]1. public void g(){2. int i = 0;3. h();4. try{5. i = f(); //recevie excepton6. }7. catch(IOException e){8.9. }10. k();11. }需要注意的是, catch⾥⾯要么写上throws对应的异常(这⾥是 IOException), 要么写上这个异常的超类, 否则还是编译失败.2.g()利⽤throws 往上⼀级⽅法抛.[java]1. public void g() throws IOException{2. int i = 0;3. h();4. i = f(); //recevie excepton5. k();6. }这是调⽤g()的函数也要考虑上⾯的这两种处理⽅法了...但是最终上级的⽅法(main ⽅法)还是不处理的话, 就编译失败, 上⾯说过了, ⾮runtimeException⽆法抛给jvm处理.虽然这两种处理⽅法都能通过编译, 但是运⾏效果是完全不同的.第⼀种, g()能完整执⾏.第⼆种, g()被中断, 也就是g()⾥⾯的k(); 执⾏失败.5.4 throws 的语法.throws稍微⽐throw难理解点:语法是:public void f() throws Exception1, Exception2...{}也就是讲, thorws可以加上多个异常, 注意这⾥抛出的不是对象, 不能加上new.⽽且不是告诉别⼈这个函数有可能抛出这么多个异常. ⽽是告诉别⼈, 有可能抛出这些异常的其中⼀种.5.5 throws 的作⽤.如果为f()函数加上throws后续, 则告诉调⽤f()的⽅法, f()函数有可能抛出这些异常的⼀种.如果f()throws 了1个或若⼲个⾮RuntimeException, 则调⽤f()的函数必须处理这些⾮RuntimeException, 如上⾯的g()函数⼀样.如果f() throws的都是RuntimeException, 则调⽤f()的函数可以不处理, 也能通过编译, 但是实际上还是强烈建议处理它们.实际上, 如果1个⽅法f() throws A,B那么它有可能不抛出任何异常.(程序运⾏状态良好)也有能抛出C异常(应该避免, 最好在throws上加上C)5.6 什么时候应该⽤throws5.6.1 ⼀个函数体⾥⾯⼿动throw了1个RumtimeException, 则这个函数的定义必须加上throws⼦句这个是强制, 告诉别⼈这个函数内有炸弹.5.6.2 ⼀个函数内有可能由系统抛出异常.这个是⾮强制的, 但是如果你知道⼀个函数内的代码有可能抛出异常, 最好还是写上throws 后缀⽆论这个异常是否runtimeExcepion.5.7 ⼀般情况下,调⽤1个带有throws⽅法时怎么办个⼈建议, 如果你调⽤1个函数throws A, B, C那么你就在当前函数写上catch(A)catch(B)catch(C)catch(Exception)这样能处理能保证你的函数能完整执⾏, 不会被收到的异常中断.当然如果你允许你的函数可以被中断, 那么就可以在当前函数定义加上throws A, B 继续抛给上⼀级的函数.5.8 重写⽅法时, throws的范围不能⼤于超类的对应⽅法.例如你在⼀个派⽣类重写⼀个⽅法f(), 在超类⾥的f() throws A, B 你重写⽅法时就不throws出 A,,B,C 或者throws A和B的超类.原因也是由于多态的存在.因为1个超类的引⽤可以指向1个派⽣类的对象并调⽤不同的⽅法. 如果派⽣类throws的范围加⼤那么利⽤多态写的代码的try catch就不再适⽤.六, throw和throws⼀些主要区别.⾯试问得多,单独拉出来写了:6.1 throw 写在函数体内, throws写在函数定义语句中.应付⾯试官.6.2 throw 是抛出1个异常对象, throws是有能抛出异常的种类所以throw后⾯的⼀般加上new 和exception名字().⽽throws后⾯不能加上new的6.3 ⼀个⽅法最多只能throw1个异常, 但是可以throws多个种类异常因为⼀旦⼀个函数throw出1个异常, 这个函数就会被中断执⾏, 后⾯的代码被放弃, 如果你尝试在函数内写两个throw, 编译失败.⽽throws 是告诉别⼈这个函数有可能抛出这⼏种异常的⼀种. 但是最多只会抛出⼀种.6.4 如果在⼀个函数体内throw 1个⾮runtimeException, 那么必须在函数定义上加上throws后缀. 但反过来就不是必须的.原因上⾯讲过了.七, ⾃定义异常.我们可以⾃定义异常, 只需要编写1个类, 继承1个异常类就ok例⼦:[java]1. package Exception_kng;2.3. class User_Exception1 extends ArithmeticException{4. public User_Exception1(String Exception_name){5. super(Exception_name);6. }7.8. public void printStackTrace(){ //overwrite9. super.printStackTrace();10. System.out.printf("hey man, i am an user_defined excetpion\n");11. }12. }13.14. class Exp6{15. public int f(int a, int b){16. if (0 == b){17. throw new User_Exception1("Shit !!! / by zero!"); //use User_defined exception18. }19.20. return a/b;21. }22. }23.24. public class Expt_6{25. public static void g() {26. Exp6 ex = new Exp6();27. int i = 22;28. try{29. i = ex.f(8,0); //throw excetpion30. }catch(User_Exception1 e){31. e.printStackTrace();32. }33. System.out.printf("i is %d\n", i);34. System.out.printf("g() is done!!\n");35. }36. }上⾯的类User_Exception1 就是1个⾃定义异常, 并重写了printStackTrace()⽅法.⼋,java异常的优缺点.8.1 c语⾔是如何处理程序错误的.我们要理解异常的优缺点, ⾸先看看没有异常的是如何处理错误的.下⾯是个例⼦:[cpp]1. //openfile2. if (fileOpen() > 0){3. //check the length of the file4. if (gotLengthOfTheFile() > 0){5. //check the memory6. if (gotEnoughMemory() > 0){7. //load file to memory8. if (loadFileToMem() > 0){9. readFile();10. }else{11. errorCode = -5;12. }13.14. }else{15. errorCode = -5;16. }17.18. }else{19. errorCode = -5;20. }21.22. }else{23. errorCode = -5;24. }25.26. //handle error27. case errorCode....28.29. //release Source30. releaseSource();可以见到处理错误有这些特点1. ⼤部分精⼒都在错误处理.2. 需要把各种可能出现的错误全部考虑到, 才能保证程序的稳定性.3. 程序可读性差, 错误处理代码混杂在其他代码中.4. 出错返回信息少, ⼀旦出错难以调试.5. ⼀旦出现了未考虑到的错误, 资源释放代码⽆法执⾏.8.2 java异常机制下是如何编写上述代码的.[java]1. try{2. fileOpen();3. gotLengthOfTheFile();4. gotEnoughMemory();5. loadFileToMem();6. readFile();7. }8. catch(fileOpenFail) { handle1()}9. catch(gotLengthOfTheFileFail) { handle2()}10. catch(gotEnoughMemoryFail) { handle3()}11. catch(loadFileToMemFail) { handle4()}12. catch(readFileFail) { handle4()}13. catch(Exception e) { handle5()} //catch unexpected error14. finally{15. releasSource();16. }8.3 java异常机制的优点:由上⾯的代码可以看出部分优点:1. 业务代码和错误处理代码分离.2. 强制程序猿考虑程序的稳定性.3. 有利于代码调试(异常信息)4. 即使任何异常产⽣, 能保证占⽤的释放(finally)8.4 java异常机制的缺点:1. 异常嵌套难免影响代码可读性2. 并不能令程序逻辑更加清晰.3. 异常并不能解决所有问题。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1.异常处理
1.1异常概述
1.1.1异常概念
java程序在运行和编译过程中出现的意外情况，导致程序出错。
1.1.2异常类型：
Error:java程序本身无法解决的严重错误（JVM出现错误，内容泄露）
1.2异常处理
1.若try 没有异常发生则，则catch语块不会执行；若try语句中抛出异常，则try语句中抛出异常后的代码不再执行，转而执行catch中的代码。
2.无论是否发生异常，finally语句总会执行。
唯一不执行的情况是catch（只限catch）语句中出现了system.exit（1）语句。
3.异常处理结构中，try必须出现，catch和finally至少出现一个
4.如果异常结构中含有return语句，finally语句仍然会被执行。
而且return语句中的值（含有return语句的结构块中）是最后被执行的结构快的返回值。
1.3异常的抛出和捕获
1.3.1异常抛出
throw:手动抛出异常
throws:方法声明式抛出异常
1.3.2异常捕获
单捕获：一个异常对应一个catch结构
语法：
try{
//...
}catch(Exception1 e){
//...
}catch(Exception2 e){
//...
}
多捕获：多个异常对应一个catch结构
语法：
try{
//...
}catch(Exception1 | Exception2 | ... | ExceptionN
e){
//...
}
1.4自定义（DIY）异常
自定义异常类：继承Exception
使用自定义异常类。