亲宝软件园·资讯

展开

JAVA 通过异常处理错误 JAVA基础--怎样通过异常处理错误

郑斌Blog 人气:0

《Thinking in Java》上对这章的讲解不少,可见重要性,学习和总结一些主要的记录下来。

一、创建自定义异常

package Exception; 
 class SimpleException extends Exception{}
 
 public class InheritingException{
  
  public void f() throws SimpleException {
   System.out.println("Throw SimpleException from f()");
   throw new SimpleException();
  }
  
  public static void main(String[] args) {
   InheritingException sed = new InheritingException();
   try {
    sed.f();
   } catch (SimpleException e) {
    e.printStackTrace();
   }
  }
  
 }

输出:

Throw SimpleException from f()
Exception.SimpleException
at Exception.InheritingException.f(InheritingException.java:10)
at Exception.InheritingException.main(InheritingException.java:19)

  throw与throws的区别与详情

  编译器创建了默认构造器,它将自动调用基类的默认构造器。

  对异常来说,最重要的部分就是类名,其它也没用,可以增加一个带参的构造方法。

  比如NullPointerException:

 public class NullPointerException extends RuntimeException {
  private static final long serialVersionUID = 5162710183389028792L;
 
  /**
  * Constructs a {@code NullPointerException} with no detail message.
  */
  public NullPointerException() {
   super();
 }

  /**
  * Constructs a {@code NullPointerException} with the specified
   * detail message.
  *
  * @param s the detail message.
  */
  public NullPointerException(String s) {
   super(s);
  }
 }

二、捕获异常

  1)try块

    如果在方法内部抛出了异常(或者在方法内部调用的其他方法抛出了异常),这个方法将在抛出异常的过程中结束。

    要是不希望方法就此结束,可以在方法内设置一个特殊的块来捕获异常。

try{
 //exceptions 
}

   2)异常处理程序

    异常处理程序紧跟在try块之后,以关键字catch表示:

try{
 //exceptions 
} catch(Type1 id1) {
 //Type1 
} catch(Type2 id2) {
 //Type2
}

    当异常被抛出时,异常处理机制将负责搜寻参数与异常类型相匹配的第一个处理程序。然后进入catch子句执行,此时认为异常得到了处理。

    注意,只有匹配的catch子句才能得到执行,这与switch语句不同。

   3)栈轨迹

    printStackTrace()方法所提供的信息可以通过getStackTrace()方法来直接访问,这个方法将返回一个由栈轨迹中的元素所构成的数组,其中每一个元素都表示

  栈中的一帧。元素0是栈顶元素,并且是调用序列中的最后一个方法调用。数组中最后一个元素和栈底是调用序列中的第一个方法调用。

 public class WhoCalled {
  static void f() {
   try {
    throw new Exception();
   } catch (Exception e) {
    for(StackTraceElement ste : e.getStackTrace()) {
     System.out.println("line: " + ste.getLineNumber() + " method: " + ste.getMethodName());
    }
   }
  }
  static void g() {f();}
  static void h() {g();}
  public static void main(String[] args) {f();g();h();}
 }

  程序输出:

line: 5 method: f
line: 14 method: main
line: 5 method: f
line: 12 method: g
line: 14 method: main
line: 5 method: f
line: 12 method: g
line: 13 method: h
line: 14 method: main

三、Java标准异常

  Throwable这个Java类被用来表示任何可以作为异常被抛出的类。

  Throwable对象可分为两种类型:

1  Error用来表示编译时和系统错误。

2  Exception是可以被抛出的基本类型,程序员关心的基类型通常是Exception。

四、RuntimeException

if(t == null) {
 throw new NullPointerException(); 
}

  如果对Null引用进行调用,Java会自动抛出NullPointerException异常,所以上述代码是多余的,它属于Java的标准运行时检测的一部分:

public class NeverCaught {
  static void f() {
   throw new RuntimeException();
  }
  static void g() {f();}
  public static void main(String[] args) {
   g();
  }
 }

输出:

Exception in thread "main" java.lang.RuntimeException

at Exception.NeverCaught.f(NeverCaught.java:6)

at Exception.NeverCaught.g(NeverCaught.java:10)

at Exception.NeverCaught.main(NeverCaught.java:14)

  从输出可以发现,RuntimeException是一个特例,对于这种异常类型,编译器不需要异常说明,其输出被报告给了System.err。

  如果RuntimeException没有被捕获而直达main(),那么在程序退出前将调用异常的printStackTrace()方法。

  *注意:

    只能在代码中忽略RuntimeException(及其子类)类型的异常,其它异常类型的处理都是由编译器强制实施的。

  1)常见的五种RuntimeException

NullPointerException - 空指针引用异常

ClassCastException - 类型强制转换异常

IllegalArgumentException - 传递非法参数异常

ArithmeticException - 算术运算异常

ArrayStoreException - 向数组中存放与声明类型不兼容对象异常

IndexOutOfBoundsException - 下标越界异常

NegativeArraySizeException - 创建一个大小为负数的数组错误异常

NumberFormatException - 数字格式异常

SecurityException - 安全异常

UnsupportedOperationException - 不支持的操作异常

五、使用finally进行清理

 class ThreeException extends Exception {}
 public class FinallyWorks {
  static int count = 0;
  public static void main(String[] args) {
   while(true) {
    try {
     if(count++ == 0) {
      throw new ThreeException();
     }
     System.out.println("No exception");
    } catch (ThreeException e) {
     System.out.println("ThreeException");
    } finally {
     System.out.println("In finally clause");
     if(count == 2) 
      break;
    }
   }
  }
 }

  这个程序给了我们一些思路(确实。。),如果把try块放在循环里,就建立了一个“程序继续执行之前必须要到达”的条件。

  还可以加入一个static类型的计数器或者别的装置,使循环在放弃之前能够尝试一定的次数。这将使程序的健壮性更上一个台阶(好叼的样子)。

  1)finally用来做什么

    当要把除内存之外的资源恢复到它们的初始状态时,就要用到finally子句。

  2)在return中使用finally

    因为finally子句总是会执行的,所以在一个方法中,可以从多个点返回,并且可以保证重要的清理工作仍旧会执行:

class ThreeException extends Exception {}
 public class FinallyWorks {
  static int count = 0;
  public static void main(String[] args) {
   while(true) {
    try {
     if(count++ == 0) {
      throw new ThreeException();
     }
     System.out.println("No exception");
     return;
    } catch (ThreeException e) {
     System.out.println("ThreeException");
    } finally {
     System.out.println("In finally clause");
     if(count == 3) 
      break;
    }
   }
  }
 }

第一次循环,首先执行第7行,符合条件,抛出异常,执行catch块,最后执行finally清理,不符合第16行判断,继续循环

第二次循环,不符合第7行判断,抛出异常,并return,但依旧执行finally清理,不符合第16行判断,但try块中已经执行return,所以程序结束,输出:

ThreeException
In finally clause
No exception
In finally clause

  3)Java异常的缺憾:异常丢失

 public class ExceptionSilencer {
  public static void main(String[] args) {
  try {
    throw new RuntimeException();
   } finally {
    return;
   }
  }
 }

加载全部内容

相关教程
猜你喜欢
用户评论