习题解答chapter05

题目

1. 简述Java Error类与Exception类的区别。
2. 简述异常处理的两种方式，并举例说明区别。
3. 选取RuntimeException类的五个子类，编写抛出并捕获上述子类异常的程序。( 例如算术异常，空指针异常，类转换异常，数组越界异常等)。
4. 仿照例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();
        }
    }
}