练习代码（六）通过异常处理错误

来源：互联网发布：淘宝标题优化时间编辑：程序博客网时间：2024/05/19 13:25

小白做课后习题，有不对的地方或者不好的地方多多包容。

1. 编写一个类，在其main() 方法的 try 块里抛出一个Exception 类的对象。传递一个字符串参数给Exception 的构造器。在 catch 子句里捕获此异常对象，并且打印字符串参数。添加一个finally 子句，打印一条信息以证明这里确实得到了执行。

public class Test {
public static void main(String[] args){
try{
throw new Exception("Java");
}catch(Exception e){
System.err.println(e.getMessage());
e.printStackTrace();
}finally{
System.err.println("finally");
}
}
}

输出结果：

Java
java.lang.Exception: Java
at yichang.Test.main(Test.java:6)
finally

2. 使用extends 关键字建立一个自定义异常类，为这个类写一个接受字符串参数的构造器，把此参数保存在对象内部的字符串引用中。写一个方法打印此字符串。写一个try-catch 子句，对这个新异常进行测试。

public class TestException extends Exception{
private String s;
TestException(String s){
super(s);
this.s = s; }
public void f(){
System.out.println("s="+s);
}
public static void main(String[] args){
try{
throw new TestException("Java");
}catch(TestException e){
e.f();
e.printStackTrace();
}
}
}

输出结果：

s=Java
yichang.TestException: Java
at yichang.TestException.main(TestException.java:12)

3.定义一个类，令其方法抛出在练习2里定义的异常。不用异常说明，看看能否通过编译。然后加上异常说明，用 try-catch 子句测试该类和异常。

class TestException extends Exception{
private String s;
TestException(String s){
super(s);
this.s = s; }
public void f(){
System.out.println("s="+s);
}
}
public class Test{
public void f() throws TestException{
throw new TestException("Java");
}
public static void main(String[] args){
Test t = new Test();
try{
t.f();
}catch(TestException e){
System.out.println(e.getMessage());
e.printStackTrace();
}
}
}

输出结果：

Java
yichang.TestException: Java
at yichang.Test.f(Test.java:13)
at yichang.Test.main(Test.java:18)

4. 定义一个对象引用并初始化为null ，尝试用此引用调用方法。把这个调用放在 try-catch 子句里以捕获异常。

class TestException extends Exception{
private String s;
TestException(String s){
super(s);
this.s = s; }
public void f(){
System.out.println("s="+s);
}
}
public class Test{
public void f() throws TestException{
throw new TestException("Java");
}
public static void main(String[] args){
Test t = null;
try{
t.f();
}catch(TestException e){
System.out.println(e.getMessage());
e.printStackTrace();
}
}
}

输出结果：

Exception in thread "main" java.lang.NullPointerException
at yichang.Test.main(Test.java:18)

5.为一个类定义两个方法：f() 和 g() 。在g（）里，抛出一个自定义的新异常。在f（）里调用g，捕获它抛出的异常，并且在catch子句里抛出另一个异常（自定义的第二种异常），在main（）方法里测试代码。

class Exception1 extends Exception{}
class Exception2 extends Exception{}
public class Dome5 {
public static void f() throws Exception2 {
try{
g();
}catch(Exception1 e){
System.err.println("Exception1");
e.printStackTrace();
throw new Exception2();
}
}
public static void g() throws Exception1{
throw new Exception1();
}
public static void main(String[] args){
try{
f();
}catch(Exception2 e){
System.err.println("Exception2");
e.printStackTrace();
}
}
}

输出结果：

Exception1
yichang.Exception1
at yichang.Dome5.g(Dome5.java:15)
at yichang.Dome5.f(Dome5.java:7)
at yichang.Dome5.main(Dome5.java:19)
Exception2
yichang.Exception2
at yichang.Dome5.f(Dome5.java:11)
at yichang.Dome5.main(Dome5.java:19)

6. 定义三种新的异常类型。写一个类，在一个方法中抛出这三种异常。在main（）方法里调用这个方法，仅用一个catch子句捕获这三种异常。

class First extends Exception{}
class Second extends Exception{}
class Third extends Exception{}
public class Dome {
public static void f() throws First,Second,Third{}
public static void main(String s){
try{
f();
}catch(Exception e){
e.printStackTrace();
}
}
}

输出结果：

7. 建立一个三层的异常继承体系，然后创建基类A，它的一个方法能抛出异常体系的基类异常。让B继承A，并且覆盖这个方法，让它抛出第二层的异常。让C继承B，再次覆盖这个方法，让它抛出第三层的异常。在main（）里创建一个C类型的对象，把它向上转型为A，然后调用这个方法。

class Exception1 extends Exception {}
class Exception2 extends Exception1 {}
class Exception3 extends Exception2 {}

class A {
public void f() throws Exception1 {
throw new Exception1();
}
}

class B extends A {
public void f() throws Exception2 {
throw new Exception2();
}
}

class D extends B {
public void f() throws Exception3 {
throw new Exception3();
}
}

public class D {
public static void main(String args[]) {
A a = new D();
try {
a.f();
} catch(Level1Exception e) {
System.out.println("Caught " + e);
}
}
}

0 0