TIJ学习笔记-异常

向右看齐 2022-08-11 04:59 166阅读 0赞

java异常

参考博客：http://www.cnblogs.com/focusj/archive/2011/12/26/2301524.html

http://tech.ccidnet.com/art/3737/20030721/468063\_1.html

**1. 什么是异常：**

阻止当前方法或作用域继续执行的问题。

**2.  异常分类**

Throwable是一切异常或错误的根类。一切皆可抛。

Error和Exception是Throwable是的两个子类。

Error:应用程序不应试图捕获的严重问题\[编译时和系统错误\]。交由jvm处理。

Exception:可以被抛出的基本类型。它分为两类CheckedException和UncheckedException.

CheckedException需要用try catch显示的捕获。

UncheckedException不需要显示的捕获。

对于可恢复的条件使用CheckedException.对于程序错误，使用UncheckedException(又叫RuntimeException).

**3. 常见RuntimeException**

NullPointerException:空指针异常。

NumberFormatException：继承IllegalArgumentException。

ArrayIndexOutOfBoundsException:数组越界

StringIndexOutOfBoundsException：字符串越界

ClassCastException:类型转换错误

ArithmeticException：算术错误，典型的就是0作为除数的时候。

IllegalArgumentException：非法参数，在把字符串转换成数字的时候经常出现的一个异常。

**4.  异常链**

捕获一个异常后，在抛出另一个异常，并且把原始异常信息保存下来。被称为异常链。用initCause()方法链接其它类型异常。

package com.zhiru;
    /*
     * 异常丢失
     * 异常链：用initCause()构造异常链.
     */
    class ExceptionA extends Exception{
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = 1L;
    
    	public ExceptionA(){
    		super();
    	}
    }
    class ExceptionB extends Exception{
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = 1L;
    
    	public ExceptionB(String str){
    		super(str);
    	}
    }
    class ExceptionC extends Exception{
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = 1L;
    
    	public ExceptionC(String s){
    		super(s);
    	}
    }
    public class MyException {
    
    	public static void f1() throws ExceptionB{
    		throw new ExceptionB("ExceptionB throws");
    	}
    	public static void f2() throws ExceptionC{
    		try{
    			f1();
    		} catch(ExceptionB e){
    			ExceptionC c=new ExceptionC("ExcptionC throwed");
    			c.initCause(e);//构造异常链
    			throw c;
    		}
    	}
    	public static void main(String[]args){
    		try{
    			f2();
    		} catch(ExceptionC e){
    			e.printStackTrace();
    		}
    	}
    }
    /*
     * com.zhiru.ExceptionC: ExcptionC throwed
    	at com.zhiru.MyException.f2(MyException.java:42)
    	at com.zhiru.MyException.main(MyException.java:48)
    */
    /*
     * com.zhiru.ExceptionC: ExcptionC throwed
    	at com.zhiru.MyException.f2(MyException.java:45)
    	at com.zhiru.MyException.main(MyException.java:52)
    Caused by: com.zhiru.ExceptionB: ExceptionB throws
    	at com.zhiru.MyException.f1(MyException.java:39)
    	at com.zhiru.MyException.f2(MyException.java:43)
    	... 1 more
    
     * 
     * */

**5.  finally**

无论try中抛出什么异常，finally中的子句总能被执行。

把除内存之外的资源恢复到它们的初始状态时，使用finally子句.

package com.zhiru;
    
    public class ExceptionSilencer {
    
    	@SuppressWarnings("finally")
    	public static void f(int i) {
    		try {
    			System.out.println("intering...");
    			System.out.println(1);
    			if (i == 1)
    				return;
    			System.out.println(2);
    			if (i == 2)
    				return;
    			System.out.println(3);
    			if (i == 3)
    				return;
    			System.out.println("end");
    			return;
    		} finally {
    			return;
    			// System.out.println("clean up");
    
    		}
    	}
    
    	 public static void main(String[] args) {
    	 // TODO Auto-generated method stub
    	 // try{
    	 // throw new RuntimeException();
    	 // }
    	 // finally{
    	 // return;//在子句中返回，即使抛出异常，但不会输出。
    	 // }
    	 for(int i=1;i<=4;i++)
    	 f(i);
    	
    	 }
    
    }
    /*
     * intering...
    1
    intering...
    1
    2
    intering...
    1
    2
    3
    intering...
    1
    2
    3
    end*/

**6.  return中的finally**

应为finally子句总会执行，所以在类内，从何处return无关紧要。

**7.  异常丢失**

class A extends Exception\{

public String toString()\{

return “A catch”;

class B extends Exception\{

public String toString()\{

return “B catch”;

public class LostException\{

void f() throws A\{

throw new A();