java的异常学习

异常 Exception 

代码示例

//异常处理函数。
public class TestDemo {
    public static void main(String args[]) {
        System.out.println("1. 除法计算开始。");
        try {
            System.out.println("2. 除法计算：" + (10/ 0));	// 此处产生异常
            // 异常产生之后的语句将不再执行，此处在try中产生异常，所以下面的输出不会执行
            System.out.println("发生异常后，这个不应该执行");
        } catch (Exception e) {								// 处理所有异常类型
            e.printStackTrace();
        } finally {
            System.out.println("### 不管是否出现异常我都执行！") ;
        }
        System.out.println("3. 除法计算结束。");
    }
}

//运行结果：
1. 除法计算开始。
java.lang.ArithmeticException: / by zero
	at com.interview.javabasic.throwable.TestDemo.main(TestDemo.java:8)
### 不管是否出现异常我都执行！
3. 除法计算结束。

java的异常继承关系：

//异常继承关系
java.lang.Object
  |- java.lang.Throwable
         |- java.lang.Error
         |- java.lang.Exception

可以发现，所以异常都是 Throwable 的子类，Throwable 只有两个子类：
（1）Exception：指的时程序运行中产生的异常，用户可以通过程序处理；
（2）Error：指的时jvm错误，那么用户不能够进行处理；

// Throwable 类，
public class Throwable extends Object implements Serializable

RuntimeException 类；

//继承关系：
java.lang.Object
   java.lang.Throwable
      java.lang.Exception
         java.lang.RuntimeException

//定义：
public class RuntimeException extends Exception

//常见的子类：
ArithmeticException,ClassCastException,NullPointerException,等：


//使用 RuntimeException 定义的异常表示这些异常可能时一些简单的问题，可以不需要强制性进行异常处理。

自定义异常类

自定义的异常类一般继承：Exception 或者 RuntimeExcetion 这两个类；代码示例：

//自定义异常
class CustomException extends Exception {			// 此异常类要强制处理
    public CustomException(String msg) {
        super(msg);					 // 调用父类构造
    }
}

public class AddExceptionDemo {
    public void throwAddException() throws CustomException{
        throw new CustomException("数值传递的过大！");
    }
    public static void main(String args[]) {
        AddExceptionDemo addExceptionDemo = new AddExceptionDemo();
        try {
            addExceptionDemo.throwAddException();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


//运行的结果：
com.interview.javabasic.throwable.AddException: 数值传递的过大！
	at com.interview.javabasic.throwable.AddExceptionDemo.throwAddException(AddExceptionDemo.java:11)
	at com.interview.javabasic.throwable.AddExceptionDemo.main(AddExceptionDemo.java:16)

//异常处理的流程：
public class ExceptionHandleMechanism {
    public static int doWork (){
        try {
            int i = 10/0;
            System.out.println("i="+1);
        } catch (ArithmeticException e){
            System.out.println("ArithmeticException" + e);
            System.out.println("xxxxxxxxxx");
            return returnTo0();  
        } catch (Exception e){
            System.out.println("Exception" + e);
            return returnTo1();
        } finally {
            System.out.println("finally"); // 在返回之前执行。
        //    return returnTo2();
        }
        return returnTo2();
    }
	
	public static int returnTo0(){
		System.out.println("to0");
		return 0;
	}
	
	public static int returnTo1(){
		System.out.println("to1");
		return 1;
	}
	
	public static int returnTo2(){
		System.out.println("to2");
		return 2;
	}
 
    public static void main(String[] args) {
        System.out.println("执行后的值为：" + doWork());
        System.out.println("Mission Complete!");
    }
}

//运行的结果：
ArithmeticExceptionjava.lang.ArithmeticException: / by zero
xxxxxxxxxx
to0
finally
执行后的值为：0
Mission Complete!

try...catch 的性能

// 性能比较
public class ExceptionPerformance {
    public static void testException(String[] array){
        try{
            System.out.println(array[0]);
        } catch (NullPointerException e){
            System.out.println("array cannot be null");
        }
    }
    public static void testIf(String[] array){
        if(array != null){
            System.out.println(array[0]);
        } else {
            System.out.println("array cannot be null");
        }
    }

    public static void main(String[] args) {
        long start = System.nanoTime();
        testException(null); // cost:715200
        //testIf(null);  // cost:590700
        System.out.println("cost:"+(System.nanoTime()-start));
    }
}

//运行结果
可以看出，if 的性能要比 try...catch 的性能要好一些。