java编程思想第12章笔记
1.概念
异常指的是在程序运行过程中发生的异常事件，通常是由硬件问题或者程序设计问题所导致的。在Java等面向对象的编程语言中异常属于对象。
早期的C语言的异常处理机制，通常是我们人为的对返回结果加一些标志来进行判定，比如发生错误返回什么标志，正常情况下我们又是返回什么标记，而这些都不是语言本身所赋予我们的，这种机制的问题在于，C语言的异常处理机制全是我们人为的定义，这样就会造成业务逻辑的主线受到异常处理的牵制，或者说是我们难免会将注意力转移，并且造成业务逻辑与异常处理之间有很大程度上的缠绕。
2. 基本异常
异常清醒是指阻止当前方法或者作用域继续执行的问题.
在java中异常同样也是对象, 使用new可以在堆上创建异常对象
举个异常最常见的例子好了, 我们都知道除数是不能为零的, , 所以做除法之前要做一个必要的检查, 检查除数不能为零, 否则将抛出异常
另一种情况就是当使用一个对象的时候, 这个对象可能为null, 并没有初始化, 遇到这样的情况就需要抛出异常:
if (t == null)
throw newNull PointerExcept();
2.1 异常参数
所有标准的异常类都有两个构造器, 一个是默认构造器, 另一个是字符串为参数, 以便能把相关信息方法异常对象的构造器
3 捕获异常
3.1 try块
如果在方法内部抛出了异常, 那么这个方法将在抛出异常的过程中结束, 如果不想方法结束, 需要将可能产生异常的代码放入try代码块中, 如果产生异常就会被try块捕获
3.2 异常处理程序
当异常抛出后, 需要被处理, 处理需要在catch块中进行, 对于每个catch自居, 接收一个且仅接收一个特殊类型的的参数的方法, catch块就是异常处理程序, 且异常处理程序必须紧跟try
4 创建自定义异常
自定义的异常类必须继承异常类, 最简单的就是继承Exception类了, 来看一个简单的示例:
class SimpleException extends Exception {}
public class InheritingExceptions {
public void f() throws SimpleException {
System.out.println("Throw SimpleException from f()");
throw new SimpleException();
}
public static void main(String[] args) {
InheritingExceptions sed = new InheritingExceptions();
try {
sed.f();
} catch (SimpleException e) {
System.out.println("Caught it");
}
}
}
Throw SimpleException from f()
Caught it
下面的例子将结果打印到了控制台上了, 更好的做法是答应道System.err, 因为System.out可能会被重定向, 同时这个例子也展示了一个接受字符串参数的构造器:
class MyException extends Exception {
public MyException() {}
public MyException(String msg) {
super(msg);
}
}
public class FullConstructors {
public static void f() throws MyException {
System.out.println("Throwing MyException from f()");
throw new MyException();
}
public static void g() throws MyException {
System.out.println("Throwing MyException from g()");
throw new MyException("Originated in g()");
}
public static void main(String[] args) {
try {
f();
} catch (MyException e) {
e.printStackTrace(System.out);
}
try {
g();
} catch (MyException e) {
e.printStackTrace(System.out);
}
}
}
输出结果:
Throwing MyException from f()
MyException
at FullConstructors.f(FullConstructors.java:11)
at FullConstructors.main(FullConstructors.java:20)
Throwing MyException from g()
MyException: Originated in g()
at FullConstructors.g(FullConstructors.java:15)
at FullConstructors.main(FullConstructors.java:25)
说一下这个printStackTrace()方法, 这个方法将打印"从方法调用出知道异常跑出处"的方法调用序列, 这里是将信息发送到了System.out, 无参数版本就是答应道标准错误流
4 异常与记录日志
使用java.util.Logging工具可以将输出记录到日记中, 基本的使用如下:
import java.util.logging.*;
import java.io.*;
class LoggingException extends Exception {
private static Logger logger = Logger.getLogger("LoggingException");
public LoggingException() {
StringWriter trace = new StringWriter();
printStackTrace(new PrintWriter(trace));
logger.severe(trace.toString());
}
}
public class LoggingExceptions {
public static void main(String[] args) {
try {
throw new LoggingException();
}catch (LoggingException e) {
System.err.println("Caught " + e);
}
try {
throw new LoggingException();
} catch (LoggingException e) {
System.err.println("Caught " + e);
}
}
}
输出如下
十二月 01, 2016 9:14:31 下午 LoggingException
严重: LoggingException
at LoggingExceptions.main(LoggingExceptions.java:16)
Caught LoggingException
十二月 01, 2016 9:14:31 下午 LoggingException
严重: LoggingException
at LoggingExceptions.main(LoggingExceptions.java:23)
Caught LoggingException
静态的Logger.getLogger()方法创建了一个String参数相关的Logger对象, 通常与错误相关的类名一致, 这个Logger对象会将其输出发送到System.err.
severe()方法表示级别, 很明显, severe表示严重的
但是更常见的情况是我们需要捕获和记录别人编写的异常, 比如说这样:
import java.util.logging.*;
import java.io.*;
public class LoggingException2 {
private static Logger logger = Logger.getLogger("LoggingException2");
static void logException(Exception e) {
StringWriter trace = new StringWriter();
e.printStackTrace(new PrintWriter(trace));
logger.severe(trace.toString());
}
public static void main(String[] args) {
try {
throw new NullPointerException();
} catch (NullPointerException e) {
logException(e);
}
}
}
输出结果为:
十二月 01, 2016 9:24:49 下午 LoggingException2 logException
严重: java.lang.NullPointerException
at LoggingException2.main(LoggingException2.java:14)
当然可以进一步自定义异常, 比如加入额外的构造器和成员, 得到更强大的功能.
5.异常说明
使用throws关键字, 紧跟在方法后面, 就像上面的程序例子一样, 说明了这个方法可能会抛出的异常类型, 这就是异常说明
6. 捕获所有的异常
可以只使用一个异常处理程序来捕获所有类型的异常, 因为异常类型的基类都是Exception;
catch(Exception e) {
System.out.println("Caught an Exception");
}
6.1 栈轨迹
printStackTrace()方法所提供的信息可以通过getStackTrace()方法来直接访问, 这个方法返回一个由栈轨迹中的元素所构成的数组, 其中每一个元素表示栈中的一帧, 元素0是栈顶元素, 并且是调用序列中最后一个被调用的方法, 数组中的最后一个元素是调用序列中的第一个方法
下面是一个简单的演示程序:
public class WhoCalled {
static void f() {
try {
throw new Exception();
} catch(Exception e) {
for(StackTraceElement ste : e.getStackTrace()) {
System.out.println(ste.getMethodName());
}
}
}
static void g() {
f();
}
static void h() {
g();
}
public static void main(String[] args) {
f();
System.out.println("--------------------------------------");
g();
System.out.println("--------------------------------------");
h();
}
}
输出结果:
f
main
--------------------------------------
f
g
main
--------------------------------------
f
g
h
main
6.2 重新抛出异常
有时候需要将刚捕获的异常重新抛出, 尤其是使用Exception捕获所有异常的时候, 可以直接把它重新抛出, 重新抛出异常会把异常抛给上一级环境中的异常处理程序, 此外异常对象的所有信息都得以保存.
如果只是重新把当前的异常对象抛出, 那么printStrackTrace()方法现实的将是原来异常抛出点的调用栈信息, 并非重新抛出点的信息.
public class Rethrowing {
public static void f() throws Exception {
System.out.println("Originating the exception in f()");
throw new Exception("thrown from f()");
}
public static void g() throws Exception {
try {
f();
} catch (Exception e) {
System.out.println("Inside g(), e.printStackTrace()");
e.printStackTrace(System.out);
throw e;
}
}
public static void h() throws Exception {
try {
g();
} catch (Exception e) {
System.out.println("inside h(), e.printStackTrace()");
e.printStackTrace(System.out);
// throw (Exception) e.fillInStackTrace();
throw e;
}
}
public static void main(String[] args) {
try {
g();
} catch (Exception e) {
System.out.println("main : printStackTrace()");
e.printStackTrace(System.out);
}
try {
h();
} catch (Exception e) {
System.out.println("main : printStackTrace()");
e.printStackTrace(System.out);
}
}
}
首先执行这个结果
Originating the exception in f()
Inside g(), e.printStackTrace()
java.lang.Exception: thrown from f()
at Rethrowing.f(Rethrowing.java:4)
at Rethrowing.g(Rethrowing.java:9)
at Rethrowing.main(Rethrowing.java:29)
main : printStackTrace()
java.lang.Exception: thrown from f()
at Rethrowing.f(Rethrowing.java:4)
at Rethrowing.g(Rethrowing.java:9)
at Rethrowing.main(Rethrowing.java:29)
Originating the exception in f()
Inside g(), e.printStackTrace()
java.lang.Exception: thrown from f()
at Rethrowing.f(Rethrowing.java:4)
at Rethrowing.g(Rethrowing.java:9)
at Rethrowing.h(Rethrowing.java:19)
at Rethrowing.main(Rethrowing.java:36)
inside h(), e.printStackTrace()
java.lang.Exception: thrown from f()
at Rethrowing.f(Rethrowing.java:4)
at Rethrowing.g(Rethrowing.java:9)
at Rethrowing.h(Rethrowing.java:19)
at Rethrowing.main(Rethrowing.java:36)
main : printStackTrace()
java.lang.Exception: thrown from f()
at Rethrowing.f(Rethrowing.java:4)
at Rethrowing.g(Rethrowing.java:9)
at Rethrowing.h(Rethrowing.java:19)
at Rethrowing.main(Rethrowing.java:36)
去掉注释并且将throw e;注释掉, 结果是:
Originating the exception in f()
Inside g(), e.printStackTrace()
java.lang.Exception: thrown from f()
at Rethrowing.f(Rethrowing.java:4)
at Rethrowing.g(Rethrowing.java:9)
at Rethrowing.main(Rethrowing.java:29)
main : printStackTrace()
java.lang.Exception: thrown from f()
at Rethrowing.f(Rethrowing.java:4)
at Rethrowing.g(Rethrowing.java:9)
at Rethrowing.main(Rethrowing.java:29)
Originating the exception in f()
Inside g(), e.printStackTrace()
java.lang.Exception: thrown from f()
at Rethrowing.f(Rethrowing.java:4)
at Rethrowing.g(Rethrowing.java:9)
at Rethrowing.h(Rethrowing.java:19)
at Rethrowing.main(Rethrowing.java:36)
inside h(), e.printStackTrace()
java.lang.Exception: thrown from f()
at Rethrowing.f(Rethrowing.java:4)
at Rethrowing.g(Rethrowing.java:9)
at Rethrowing.h(Rethrowing.java:19)
at Rethrowing.main(Rethrowing.java:36)
main : printStackTrace()
java.lang.Exception: thrown from f()
at Rethrowing.h(Rethrowing.java:23)
at Rethrowing.main(Rethrowing.java:36)
对比第二个结果比第一个结果少了倒数三四行, fillInStackTrace方法会将栈轨迹清空并填充当前栈轨迹
6.3 异常链
常常会想要在捕获一个异常之后抛出另一个异常, 并想吧原始异常的信息保存下来, 这样称为异常链, throwable中initCause()方法可以接受一个cause对象作为参数, 这个cause就是用来表示原始异常的, 这样通过把原始异常传递给新的异常, 是的即使在当前位置创建并抛出了新的异常, 也能通过这个异常链追踪到最初发生异常的地方.
下面看一个可以动态的扩展字段的dome:
class DynamicFieldsException extends Exception{}
public class DynamicFields {
private Object[][] fields;
public DynamicFields(int initialSize) {
fields = new Object[initialSize][2];
for (int i = 0;i < initialSize; i++) {
fields[i] = new Object[] {null, null};
}
}
public String toString() {
StringBuilder result = new StringBuilder();
for(Object[] obj : fields) {
result.append(obj[0]);
result.append(":");
result.append(obj[1]);
result.append("\n");
}
return result.toString();
}
// 判断是否存在该字段, 存在返回下标, 如果不存在该字段返回-1
private int hasField(String id) {
for (int i = 0; i < fields.length; i++) {
if (id.equals(fields[i][0])) {
return i;
}
}
return -1;
}
// 返回该字段标志符的下标, 如果不存在就抛出异常
private int getFieldNumber(String id) throws NoSuchFieldException {
int fieldNum = hasField(id);
if (fieldNum == -1) {
throw new NoSuchFieldException();
}
return fieldNum;
}
// 动态的扩展
private int makeField(String id) {
for (int i = 0; i < fields.length; i++) {
if (fields[i][0] == null) {
fields[i][0] = id;
return i;
}
}
Object[][] temp = new Object[fields.length +1][2];
for (int i = 0; i < fields.length; i++) {
temp[i] = fields[i];
}
for (int i = fields.length; i < temp.length; i++) {
temp[i] = new Object[] {null, null};
}
fields = temp;
return makeField(id);
}
// 得到该字段标识符的对应的字段值
public Object getField(String id) throws NoSuchFieldException {
return fields[getFieldNumber(id)][1];
}
// 设置字段
public Object setField(String id, Object value) throws DynamicFieldsException {
// 字段值为空的话
if (value == null) {
DynamicFieldsException dfe = new DynamicFieldsException();
// 将此throwable的case初始化为指定值
dfe.initCause(new NullPointerException());
throw dfe;
}
int fieldNumber = hasField(id);
// 如果该字段对应字段标识符不存在的话
if (fieldNumber == -1) {
fieldNumber = makeField(id);
}
Object result = null;
try {
result = getField(id);
} catch (NoSuchFieldException e) {
throw new RuntimeException(e);
}
fields[fieldNumber][1] = value;
return result;
}
public static void main(String[] args) {
DynamicFields df = new DynamicFields(3);
System.out.println(df);
try {
df.setField("d", "A value for d");
df.setField("number", 47);
df.setField("number2", 48);
System.out.println(df);
df.setField("d", "A new value for d");
df.setField("number3", 11);
System.out.println(df);
System.out.println("df.getField(\"d\")" + df.getField("d"));
Object field = df.setField("d", null); // 产生异常
} catch (NoSuchFieldException e) {
e.printStackTrace(System.out);
} catch (DynamicFieldsException e) {
e.printStackTrace(System.out);
}
}
}
运行后的输出结果为:
null:null
null:null
null:null
d:A value for d
number:47
number2:48
d:A new value for d
number:47
number2:48
number3:11
df.getField("d")A new value for d
DynamicFieldsException
at DynamicFields.setField(DynamicFields.java:64)
at DynamicFields.main(DynamicFields.java:94)
Caused by: java.lang.NullPointerException
at DynamicFields.setField(DynamicFields.java:65)
... 1 more