《计算概论》课程 第十九讲 C 程序设计语言应用

Java 高级技术 课程 Java 语言的高级特性 李戈 北京大学信息科学技术学院软件研究所 2010 年 4 月 3 日

异常与错误 错误 (Error) 程序中存在的不能满足预定义的需求 ( 语法需求 语义需求 ) 的成分 ; 错误是静态概念, 通常可以通过静态分析分离出来 ; 异常 (Exception) 异常就是指在程序运行过程中所发生的某些事件, 它中断了指令的正常执行流程 异常通常是指程序运行期间很少会发生的事件, 在程序运行期间才会产生 ;

异常处理机制 异常处理 (Exception Handling) 机制 用于管理程序运行期间所产生的异常的一种方法, 其目的是保证程序的控制不会由于异常的产生而随意跳转 异常处理机制通常包括异常的检测 报告与处理 在异常处理模式中, 重点考虑两个基本问题 : 必须确定由哪一个方法处理报告出来的异常 ; 引发异常的方法是否仍可在异常处理之后继续执行

异常处理模式 1 异常只能由调用者先处理 ; 当方法 R 中引发了异常时, 它仅能报告给方法 Q, 由 Q 处理 R 引发的异常 ; 处理过程中方法 Q 本身又可能引发某个异常并向方法 P 报告 ; 方法 P 处理完异常后可能唤醒方法 Q, 然后由方法 Q 再唤醒方法 R 异常处理模式

异常处理模式 2 异常处理模式 引发异常的方法 R 可以选择将异常报告给方法 P 又能够报告给 Q, 可由 P 或 Q 中的任一个处理异常并唤醒 R 第一种处理模式 程序更为结构化, 但处理效率可能比较低, 因为最适合处理该异常的程序可能处在调用链的最高层 第二种处理模式 程序结构变得复杂, 但可能处理效率比较高, 因为引发异常的方法可以直接选择最适合处理该异常的方法进行报告

Java 的异常处理机制 Java 异常处理机制 Java 语言只支持异常的逐层报告, 不支持异常的越级报告, 也不支持在处理异常之后重新唤醒被异常中断执行的方法 Java 语言将异常看作一种特殊的对象, 可以象其他对象一样被创建 创建异常对象是指创建标识发生了某种异常的对象, 以方便报告 捕获与处理 ; 创建异常对象不等于产生异常 ;

Java 异常的分类 (1) Java 语言的异常以类的层次结构组织, 类 Throwable 是所有异常类的祖先类, 它是根类 Object 的子类 类 Throwable 有两个子类 Exception 和 Error 类 Exception 及其后代类标识上述意义上的 异常, 即很少发生的一些特殊事件, Java 语言定义了类 Exception 的一个子类 RuntimeException, 用于标识 Java 程序在运行时可能会发生的一些常见的异常, 例如被 0 除 数组下标越界等 类 Error 及其后代类标识一些导致程序完全无法执行下去的 错误, 例如 : 耗尽内存资源,JVM 内部发生错误等, 这些错误当然也是一些很少会发生的事件, 但与异常不同, 被认为是 Java 程序完全无法恢复和处理的事件

自定义异常类 Java 异常的分类 (2) 程序员可以自定义异常类, 以标识在特定的应用程序环境下可能发生的异常 ; 对于自定义异常类, 程序员通常不将其定义为类 Throwable 的子类, 而将其作为类 Exception 的子类 public class OutOfMoney extends Exception { public OutOfMoney() { super("your account have not enough money!"); public OutOfMoney(String msg) { super(msg); public static void main(string[] args) { OutOfMoney obj = new OutOfMoney(); obj.printstacktrace();

Java 异常的分类 (2) 需要检查的异常 (checked exception) 指当一个方法体的语句会抛出该类型的异常时, 要么在这个方法中捕获该异常, 要么在方法体之前用如下形式的 throws 语句声明要抛出该类型异常, 否则会产生编译错误 : 返回类型方法名 (< 参数列表 >) throws < 异常类列表 > {... // 方法体 其中异常列表中给出该方法要抛出的异常类的名字, 抛出多个异常类时, 用逗号分隔

Java 异常的分类 (2) 无需检查的异常 (unchecked exception) 当一个方法体的语句会抛出该类型异常时, 不管该方法是否捕获该异常都不需要在方法体之前使用 throws 声明要抛出该类型的异常 类 Error 和 RuntimeException, 以及它们的后代类都是无需检查的异常, 其它异常类, 包括 Java API 定义的和用户自定义的 ( 非 Error 和 RuntimeException 的后代类的 ) 异常都是要检查的异常

Java 异常的分类 (2)

类 Error 的几个重要子类 VirtualMachineError: Java 定义的标准异常 JVM 内部出现的错误, 如 : 耗尽内存资源 调用栈溢出等 ; LinkageError: JVM 在装载字节码文件时出现的错误, 通常是因为字节码文件在生成后遭到非法破坏, 如 : 字节码格式错误等 ; AWTError: 图形用户界面控件发生严重错误, 这个类定义在程序包 java.awt, 且没有预定义的子类 ; ThreadDeath: 线程意外死机, 这个类没有预定义子类 ;

Java 定义的标准异常 类 RuntimeException 的常见子类 : ArithmeticException: 算术运算异常, 最常见的异常是被 0 除 ; ClassCastException: 程序在运行时欲进行不正确的强制类型转换 ; IllegalArgumentException: 方法被传递了不合法的参数 ; IndexOutOfBoundsException: 数组或字符串下标访问越界 ; NullPointerException: 程序使用了空引用 ; UnsupportedOperationException: 程序调用了不支持的方法

抛出异常的主体有三种 : Java 虚拟机 Java 异常的分类 (3) 通常这种异常是 Error 或 RuntimeException 的子类 ; 例如 NullPointException; 虽然在程序中无需显式地处理这类异常, 但应避免此类异常的产生 ; Java API 提供的方法 阅读有关 Java API 的文档规范, 了解所使用方法的接口, 以做出相应的处理 ; 程序中的 throw 语句 以显式形式抛出的某种异常, 是一个方法向它的调用者报告异常的基本形式

异常的捕获与处理 将可能抛出异常的语句放在由保留字 try 引导的块, 其后使用保留字 catch 引导的块捕获这些语句所抛出的第一个异常并进行处理, 其基本形式如下 : try {... // 可能抛出异常的语句 ; catch ( 异常类型 1 异常对象 1) {... // 对该类型的异常进行处理的语句 ; catch ( 异常类型 2 异常对象 2) {... // 对该类型的异常进行处理的语句 ;... // 可以有多个 catch 块 catch ( 异常类型 n 异常对象 n) {... // 对该类型的异常进行处理的语句 ;

class Account { private double balance = 1000; public void transfer(double amount) throws OutOfMoney { if (balance < amount) throw new OutOfMoney("Balance< Amount"); balance = balance - amount; public class AccountDemo { public static void main(string[ ] args) throws OutOfMoney{ Account obj = new Account(); double amount = 800; for (int count = 0; count < 3; count++) { try { obj.transfer(amount); System.out.println("balance:"+ obj.getbalance()); catch (OutOfMoney exc) { throw exc; //exc.printstacktrace(); 说出它的执行过程 amount = amount - 300;

一个 try 语句块可有多个 catch 语句块 异常的匹配 当 try 语句块抛出某种类型的异常时, 程序将根据 catch 语句块书写的顺序逐个进行匹配 ; 当发现某个保留字 catch 后声明的异常类是 try 语句块抛出的异常类的祖先类时, 就表示找到了匹配的 catch 语句块, 程序将执行该语句块中的语句 class SuperException extends Exception { public SuperException(String msg) { super(msg); class SubException extends SuperException { public SubException(String msg) { super(msg);

public class DemoMatch { public static void main(string[] args) { try { throw new SubException("SubException"); catch (SubException exc) { System.out.println("Catch SubException!"); catch (SuperException exc) { System.out.println("Catch SuperException!"); catch (Exception exc) { System.out.println("Catch Exception!"); try { throw new SuperException("SuperException"); catch (SubException exc) { System.out.println("Catch SubException!"); catch (SuperException exc) { System.out.println("Catch SuperException!"); catch (Exception exc) { System.out.println("Catch Exception!"); try { throw new SubException("SubException"); catch (SuperException exc) { System.out.println("Catch SuperException!"); catch (SubException exc) { System.out.println("Catch SubException!"); 说出它的执行过程

异常处理与收尾 finally 语句块 try {... // 可能抛出异常的语句 ; catch ( 异常类型 1 异常对象 1) {... // 对该类型的异常进行处理的语句 ; catch ( 异常类型 2 异常对象 2) {... // 对该类型的异常进行处理的语句 ;... // 可以有多个 catch 块 catch ( 异常类型 n 异常对象 n) {... // 对该类型的异常进行处理的语句 ; finally {... // 执行异常处理后收尾工作的语句

public class DemoFinally { public static void main(string[] args) { String[ ] members = new String[4]; for (int count = 0; count < 3; count++) { try { int x; if (count == 0) x = 1 / 0; if (count == 1) members[4] = "George Martin"; if (count == 2) return; catch (ArrayIndexOutOfBoundsException exc) { System.out.println(" 发生数组下标越界异常!"); catch (ArithmeticException exc) { System.out.println(" 发生被零除异常!"); continue; finally { System.out.println("finally 语句块!"); 说出它的执行过程

异常处理与收尾 finally 语句块 不管 try 语句块的语句是否抛出异常, 也不管 catch 语句块是否捕获到异常,finally 语句块的语句总会执行 甚至在执行到 try 语句块或 catch 语句块的 return break 或 continue 语句时, 也会在程序控制跳出语句 try...catch... finally... 之前执行 finally 语句块的语句

语句 try...catch... finally... 的控制流

逐层转发 异常的转发 调用者在捕获异常后, 如果还没有足够信息进行处理可以再转发给调用者的调用者, 逐层报告, 直到最适合处理该异常的方法 public void somemethod(...){... // 其它语句 try {... // 可能引发各种异常的语句 catch (CanHandleException exc) {... // 处理能够处理的异常 catch (CannotHandleException exc) { throw exc; // 转发不能处理的异常... // 其它语句

逐层转发 异常的转发 在将控制转向捕获该异常的方法之前仍将执行 finally 语句块 ; public class DemoClass { public static void main(string[] args) { try { int x = 1 / 0; catch (ArithmeticException exc) { throw exc; finally { System.out.println(" 本语句总是会执行!");

当 异常声明 某方法用 throw 语句显式抛出需检查的异常 ; 或 时 某方法调用的方法会抛出异常, 而该方法又没有使用 catch 语句块对异常进行处理 ; 需要在方法体之前使用 throws 语句声明要抛出该异常类或该异常类的祖先类 ;

异常声明 异常的声明 public void somemethod(...) throws ExceptionOne, ExceptionTwo {... // 方法体 方法重载 如果有以下的方法声明 : public void somemethod(int x) throws ExceptionOne {... public void somemethod(int x) throws ExceptionOne, ExceptionTwo {...

异常声明与继承机制 关于 子类重定义方法的异常声明 Java 语言规定 : 子类重定义方法声明抛出的每个异常类都必须是超类方法声明的某一个异常类本身或其后代类 ; 但不是超类方法声明的每个异常类都必须在子类方法声明抛出

关于子类重定义方法的异常声明 定义如下的异常类 class SuperOneException extends Exception { class SubOneException extends SuperOneException { class SubSubException extends SubOneException { class SubTwoException extends SuperOneException { class SuperTwoException extends Exception { class SubThreeException extends SuperTwoException {

关于子类重定义方法的异常声明 class SuperClassOne { public void methodone() throws SuperOneException { public void methodtwo() throws SubOneException, SuperTwoException { public void methodthree() throws SuperOneException, SuperTwoException { public void methodfour() throws SuperTwoException { public void methodone() throws SubSubException, SubTwoException { public void methodtwo() throws SubSubException { public void methodthree() throws SubSubException, SubThreeException { public void methodfour() throws SuperTwoException { 子类 SubClassOne 继承超类 SuperClassOne

关于子类重定义方法的异常声明 class SuperClassOne { public void methodone() throws SuperOneException { public void methodtwo() throws SubOneException, SuperTwoException { public void methodthree() throws SuperOneException, SuperTwoException { public void methodfour() throws SuperTwoException { 对于如下的声明 : public void methodone() throws SubThreeException { public void methodtwo() throws SubTwoException { 子类 SubClassOne 继承超类 SuperClassOne

class SuperClassOne { public void methodone() throws SuperOneException { public void methodtwo() throws SubOneException, SuperTwoException { public void methodthree() throws SuperOneException, SuperTwoException { public void methodfour() throws SuperTwoException { public void callmethodone() throws SubSubException, SubTwoException { SubClassOne obj = new SubClassOne(); obj.methodone(); public void callmethodone() throws SuperOneException { SubClassOne obj = new SubClassOne(); obj.methodone(); public void callmethodone() { SubClassOne obj = new SubClassOne(); try { obj.methodone(); catch (Exception exc) { public void callmethodone() throws SuperException { SuperClassOne obj = new SubClassOne(); obj.methodone(); 子类 SubClassOne 继承超类 SuperClassOne

如果 则 关于子类重定义方法的异常声明 子类重定义方法同时实现了某些接口的方法 子类方法声明抛出的每个异常类必须是 : 超类方法所声明的异常类及其后代类 组成的异常类 集合和 所有 接口方法声明的异常类及其后代类 组成的异常类集合 的交集中的某一个异常类

class SuperClassOne { public void methodone() throws SuperOneException { public void methodtwo() throws SubOneException, SuperTwoException { public void methodthree() throws SuperOneException, SuperTwoException { public void methodfour() throws SuperTwoException { interface InterfaceOne { public void methodone( ) throws SubOneException; public void methodtwo( ) throws SuperOneException; public void methodthree() throws SuperOneException; public void methodfour( ) throws SubOneException; interface InterfaceTwo { public void methodone( ) throws SubSubException; public void methodtwo( ) throws SuperTwoException; public void methodthree( ) throws SuperOneException; class SubClassTwo extends SuperClassOne implements InterfaceOne, InterfaceTwo { public void methodone() throws SubSubException { public void methodtwo() { public void methodthree() throws SubSubException, SubTwoException {

class SuperClassOne { public void methodone() throws SuperOneException { public void methodtwo() throws SubOneException, SuperTwoException { public void methodthree() throws SuperOneException, SuperTwoException { public void methodfour() throws SuperTwoException { interface InterfaceOne { public void methodone( ) throws SubOneException; public void methodtwo( ) throws SuperOneException; public void methodthree() throws SuperOneException; public void methodfour( ) throws SubOneException; interface InterfaceTwo { public void methodone( ) throws SubSubException; public void methodtwo( ) throws SuperTwoException; public void methodthree( ) throws SuperOneException; class SubClassTwo extends SuperClassOne implements InterfaceOne, InterfaceTwo { public void methodone() throws SubSubException { public void methodtwo() { public void methodthree() throws SubSubException, SubTwoException { public void methodfour()

class SuperClassOne { public void methodone() throws SuperOneException { public void methodtwo() throws SubOneException, SuperTwoException { public void methodthree() throws SuperOneException, SuperTwoException { public void methodfour() throws SuperTwoException { interface InterfaceOne { public void methodone( ) throws SubOneException; public void methodtwo( ) throws SuperOneException; public void methodthree() throws SuperOneException; public void methodfour( ) throws SubOneException; interface InterfaceTwo { public void methodone( ) throws SubSubException; public void methodtwo( ) throws SuperTwoException; public void methodthree( ) throws SuperOneException; class SubClassTwo extends SuperClassOne implements InterfaceOne, InterfaceTwo { public void methodone() throws SubSubException { public void methodtwo() { public void methodthree() throws SubSubException, SubTwoException { //public void methodfour()

关于子类重定义构造方法的异常声明 由于 子类构造方法的第一条语句必须是调用超类的构造方法 ; 因此 无法将调用超类构造方法的语句放入 try 语句块中以捕获超类构造方法抛出的异常 ; 所以 超类构造方法声明抛出的异常类必须在子类构造方法中也声明抛出 ; 除此之外 子类构造方法也可声明抛出其它异常类 ;

关于子类重定义构造方法的异常声明 // 超类 class SuperClassTwo { public SuperClassTwo() throws SubOneException { public SuperClassTwo(int x) throws SuperTwoException { // 子类 class SubClassThree extends SuperClassTwo { public SubClassThree() throws SuperOneException { public SubClassThree(int x) throws SuperTwoException, SubOneException { super(x);

规则总结 关于调用方法 重定义方法的异常声明 Java 编译器对异常声明检查的规则可表述为 : 子类中重定义的方法如果要声明抛出异常类类型 T, 则必须对超类以及它实现的接口中相应的每个方法, 都要能找到该方法声明抛出的某个异常类类型 S, 使得 T 是 S 的子类型 如果方法 A 调用方法 B, 则对方法 B 所声明抛出每个异常类类型 T, 方法 A 都要捕获或者声明抛出某个异常类类型 S, 使得 T 是 S 的子类型

程序断言 程序断言机制 在程序中加入的用于描述需求的表达式 ; 断言的作用 : 保证程序的正确性与健壮性 帮助程序员精确陈述程序各个组成部分的性质 ; 断言可用于形成程序的文档 可以利用一些软件工具从带有断言的程序中抽取出需求说明 ; 支持程序的动态调试 程序断言在运行过程中可以动态地检测 ; 构成异常处理的基础 当检测某一程序断言不成立时, 程序将引发一个异常 ;

Java 中的断言机制 Java 语言并没有提供完善的程序断言机制 ; 仅在 Java 2 SDK 1.4 版本以上, 开始支持实现部分检测断言 ; 基本形式如下 : assert ConditionExpression assert 是新增的保留字 ; ConditionExpression 是布尔表达式, 用来表达所要检测的条件 ; Java 语言新增了一个错误类 AssertionError, 它是类 Error 的子类, 用来标识程序不满足断言中的布尔表达式而抛出的异常

Java 中的断言机制 断言 :assert ConditionExpression 等价于 if (! ConditionExpression) { throw new AssertionError() 断言 :assert ConditionExpression : InitialExpression 等价于 if (! ConditionExpression) { throw new AssertionError(InitialExpression)

public class SquareRoot { // 功能 : 返回 x 的平方根, 要求精度为 epsilon 说出它的执行过程 // 要求 : x >= 0 and epsilon >= 0.000001 // 保证 : sqrt * sqrt - x <= epsilon public static double sqrt(double x, double epsilon) { // 前置条件 assert (x >= 0) : " 参数为负数 "; assert (epsilon >= 0.000001) : " 精度要求过高 "; // 用牛顿法求平方根 double root = 1; while (Math.abs(root * root - x) > epsilon) { root = (x / root + root) / 2; // 后置条件 assert Math.abs(root * root - x) <= epsilon : " 精度不足 "; return root; public static void main(string[] args) { System.out.println("sqrt(5, 0.01)=" + sqrt(5, 0.01));

在 Java 2 SDK 1.4 版本下使用如下命令编译 : > javac source 1.4 SquareRoot.java > java ea SquareRoot 运行上述程序将产生如下输出 : sqrt(5, 0.01)=2.238095238095238

public class SquareRoot { // 功能 : 返回 x 的平方根, 要求精度为 epsilon 说出它的执行过程 // 要求 : x >= 0 and epsilon >= 0.000001 // 保证 : sqrt * sqrt - x <= epsilon public static double sqrt(double x, double epsilon) { // 前置条件 assert (x >= 0) : " 参数为负数 "; assert (epsilon >= 0.000001) : " 精度要求过高 "; // 用牛顿法求平方根 double root = 1; while (Math.abs(root * root - x) > epsilon) { root = (x / root + root) / 2; // 后置条件 assert Math.abs(root * root - x) <= epsilon : " 精度不足 "; return root; public static void main(string[] args) { System.out.println("sqrt(5, 0)=" + sqrt(5, 0));

Exception in thread "main" java.lang.assertionerror: 精度要求过高 at SquareRoot.sqrt(SquareRoot.java:8) at SquareRoot.main(SquareRoot.java:20)

public class SquareRoot { // 功能 : 返回 x 的平方根, 要求精度为 epsilon 说出它的执行过程 // 要求 : x >= 0 and epsilon >= 0.000001 // 保证 : sqrt * sqrt - x <= epsilon public static double sqrt(double x, double epsilon) { // 前置条件 assert (x >= 0) : " 参数为负数 "; assert (epsilon >= 0.000001) : " 精度要求过高 "; // 用牛顿法求平方根 double root = 1; while (Math.abs(root * root - x) > epsilon) { root = (x / root + root) / 2; // 后置条件 assert Math.abs(root * root - x) <= epsilon : " 精度不足 "; return root; public static void main(string[] args) { System.out.println("sqrt(-7, 0.1)=" + sqrt(-7, 0.1));

Exception in thread "main" java.lang.assertionerror: 参数为负数 at SquareRoot.sqrt(SquareRoot.java:7) at SquareRoot.main(SquareRoot.java:21)

Project List 1 某领域的垂直搜索引擎; 2 研究生辅助管理系统; 3 Google Code Search Eclipse 插件 ; 4 局域网文件同步器;

说明 : Project 说明 (1) 以上每个项目均可设立多个独立的开发小组 ; (2) 每位同学最好只参与一个项目的开发小组 ; (3) 选择以上项目的同学, 可以不提交本课程的 Project 作业, 但仍需提交其他作业 ; (4) 关于所有项目的最终成果将在开源软件平台上发布 ( 可以自行创建也可以用国际上的现有平台 ); (5) 所有已发布资源将默认遵循 GNU General Public License(GPL) 协议,;

GNU General Public License (GPL) 协议 GPL 承认软件作品作者的著作权 ( 所有权 ), 同时也要求作者必须允许任何人 ( 或用户, 或 你 ) 享有对其作品使用 复制 修改 衍生 发行的自由权利 ; 作为一个限制条件,GPL 还要求用户不能改变软件的授权协议 ( 即要将 GPL 向各级用户传递下去 ), 要求用户在对该软件作品作出的修改或制作衍生作品并进行再发行时, 都要一贯遵守 GPL 规则 ; 如果执行 GPL 协议的原创软件是自由软件, 则该自由软件经过修改或衍生后的软件也应是自由软件 ; 自由软件在作二进制整体运行时, 不允许一部分软件的源码是开源的, 另一部分的源码是闭源的, 即不允许出现混合源码的现象 GPL 协议还规定, 不得使用其它许可证进行再发布

好好想想, 有没有问题? 谢谢!