题目
- 简述Java Error类与Exception类的区别。
- 简述异常处理的两种方式，并举例说明区别。
- 选取RuntimeException类的五个子类，编写抛出并捕获上述子类异常的程序。( 例如算术异常，空指针异常，类转换异常，数组越界异常等)。
- 仿照例7.9，自定义一个异常类，并在某场景下抛出该异常对象。
1. 简述Java Error类与Exception类的区别。
Java采用面向对象的方式进行异常处理，Error和Exception是平行类，继承于Throwable类。Error是所有错误类的祖先，Exception是所有异常类的祖先。
Error不是程序需要捕获和进行处理的，当Error发生时，程序自动停止；Exception有许多子类，这些子类在JDK中也是按照包的形式组织。当异常发生时，虚拟机系统根据异常的类型，产生相应的异常对象，程序中应对这些异常对象进行相应的 处理。这些异常对象可查看JDK帮助。
2. 简述异常处理的两种方式，并举例说明区别。
- 声明抛出处理：声明抛出也分为隐式和显式两种方式。
- 隐式声明抛出：异常类型是RuntimeException或者是其子类，程序可以对异常不作任何声明与处理。
- 显式声明抛出：对异常进行声明处理，当编译遇到该类型的异常时就会抛出。注意：当子类覆盖父类的方法时，子类抛出的异常类型应和父类抛出的异常相同或为其子类，不能为其父类。也就是子类抛出的异常范围应该更小、更精确。
隐式声明抛出
package bookcode.ex7.part7_5;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class ioEXception {
private static int[] x;
public static void main(String[] args) {
// 隐式
System.out.println(x[0]);
String foo = args[1];
System.out.println("foo = " + foo);
}
}
/* 发生异常时并没有在main()方法中进行任何抛出异常的处理操作，直接main()的Java虚拟机中去处理异常，抛出以下异常：
Exception in thread "main" java.lang.NullPointerException
at bookcode.ex7.part7_5.ioEXception.main(ioEXception.java:12)*/
显式声明抛出
package bookcode.ex7.part7_5;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class ioEXception {
public static void main(String[] args) throws IOException {//显式声明抛出
BufferedReader keyin = new BufferedReader(new InputStreamReader(System.in));
String c1;
int i = 0;
String[] e = new String[10];
while (i < 10) {
c1 = keyin.readLine();
e[i] = c1;
i++;
}
}
}
- 捕获处理
package bookcode.ex7.part7_5;
public class ioEXception {
public static void main(String args[]) {
try {
int a[] = new int[2];
System.out.println("Access element three :" + a[3]);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Exception thrown :" + e);
}
System.out.println("Out of the block");
}
}
3. 选取RuntimeException类的五个子类，编写抛出并捕获上述子类异常的程序。( 例如算术异常，空指针异常，类转换异常，数组越界异常等)。
算数异常
package bookcode.ex7.partTest;
public class arithmeticException {
public static void main(String args[]){
int a, b, c;
a = 9;
b = 0;
c = 8;
System.out.println(a / b + c);
}
}
空指针异常
package bookcode.ex7.partTest;
public class nullException {
private static int[] x;
public static void main(String args[]){
System.out.println(x[0]);
}
}
类转换异常
package bookcode.ex7.partTest;
public class classCastException {
static class One {
public void foo() {
System.out.println("One");
}
}
static class Two extends One {
public void foo() {
System.out.println("Two");
}
public void dosth(){
System.out.println("Two again");
}
}
public static void main(String[] args) throws Exception{
One t = new Two(); //向上转型，即父类引用指向子类对象，此时子类对象的类型为父类的类型
t.foo();
t.dosth();//编译错误
t = (Two)t;
t.dosth();//编译错误
((Two) t).dosth();//编译成功
}
}
数组越界
package bookcode.ex7.partTest;
public class listException {
public static void main(String args[]){
String foo = args[1];
System.out.println("foo = " + foo);
}
}
空栈异常
package bookcode.ex7.partTest;
import java.util.Stack;
public class stackException {
public static void main(String args[]){
Stack stack = new Stack();
Object ob = stack.pop();
}
}
4. 仿照例7.9，自定义一个异常类，并在某场景下抛出该异常对象。
以下实例是一个银行账户的模拟，通过银行卡的号码完成识别，可以进行存钱和取钱的操作。
package bookcode.ex7.part7_5;
//自定义异常类，继承Exception类
public class InsufficientFundsException extends Exception
{
//此处的amount用来储存当出现异常（取出钱多于余额时）所缺乏的钱
private double amount;
public InsufficientFundsException(double amount)
{
this.amount = amount;
}
public double getAmount()
{
return amount;
}
}
package bookcode.ex7.part7_5;
//此类模拟银行账户
public class CheckingAccount {
//balance为余额，number为卡号
private double balance;
private int number;
public CheckingAccount(int number) {
this.number = number;
}
//方法：存钱
public void deposit(double amount) {
balance += amount;
}
//方法：取钱
public void withdraw(double amount) throws InsufficientFundsException {
if (amount <= balance) {
balance -= amount;
} else {
double needs = amount - balance;
throw new InsufficientFundsException(needs);
}
}
//方法：返回余额
public double getBalance() {
return balance;
}
//方法：返回卡号
public int getNumber() {
return number;
}
}
下面的 BankDemo 程序示范了如何调用 CheckingAccount 类的 deposit() 和 withdraw() 方法。
package bookcode.ex7.part7_5;
public class selfException {
public static void main(String [] args)
{
CheckingAccount c = new CheckingAccount(101);
System.out.println("Depositing $500...");
c.deposit(500.00);
try
{
System.out.println("
Withdrawing $100...");
c.withdraw(100.00);
System.out.println("
Withdrawing $600...");
c.withdraw(600.00);
}catch(InsufficientFundsException e)
{
System.out.println("Sorry, but you are short $"
+ e.getAmount());
e.printStackTrace();
}
}
}