黑马程序员——异常

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

异常：

     异常是指程序出现了不正常的情况。

 

异常的基本结构如下图：

 

 

 通过观察结构图可得知：

 Throwable类：是Java 语言中所有错误或异常的超类，就是异常本身。

     Error类：表示程序出现严重异常，这是我们所不能处理的。

 Exception类：表示此类异常指出了合理的应用程序想要捕获的条件。

             

在Exceprion类下，我们又分为两种类型的异常：

     1、RuntimeException类，运行时期异常。此类异常出现，可处理，也可不处理。这往往是代码不够严谨造成的，只需要修正代码即可。比如：除数为0，数组访问越界等问题。

     2、非RuntimeException类，编译时期异常。此类异常是必须要处理的，因为不处理，编译是不能通过的。比如：IO流和反射中有很多异常，必须处理才能工作。

注意：

    在Exceprion类中，每一个子类都不一定是在同一个包下。如上结构图所示。

 

 

异常处理：

        

既然Exceprion类异常需要处理，那怎么处理呢？

 

一、JVM默认处理：

    JVM会把异常的名称，原因及出现的问题等信息输出在控制台。同时程序也会结束，而后面的程序无法继续执行。

 

public class ExceptionDemo {
	public static void main(String[] args) {
		method();
	}

	public static void method() {
		int num = 10;
		System.out.println(num / 0);//运行期异常，因为除数不能为零，程序终止
		
		System.out.println("end");//该语句无法执行
	}
	/**
	 * 输出结果： 
	 *            Exception in thread "main" java.lang.ArithmeticException: / by zero
	 *                    at Test01.ExceptionDemo.method(ExceptionDemo.java:10)
	 *                    at Test01.ExceptionDemo.main(ExceptionDemo.java:5)
	 */
}

 

二、自己处理：

    自己处理有三种方法：

1、使用try{}catch(){}finally{}语句。自己编写处理代码，后面的程序可继续执行。 

 

   try{}catch(){}finally{}语句可以处理单个异常也可以处理多个异常：

  

        A、处理单个异常：

public class ExceptionDemo {
	public static void main(String[] args) {
		method();
	}

	public static void method() {
		int num = 10;
		try {//try语句里面是可能出现异常的代码
			
			System.out.println(num / 0);
			
		} catch (ArithmeticException ae) {//catch语句里是针对异常的处理，catch(异常名称 变量名)
			System.out.println("除数不能为零！");
			
		}finally{//finallyu语句里面的代码始终都会执行，不管前面是否出现异常
			System.out.println("finally");
		}
		System.out.println("end");//后面的代码仍可以执行
	}
	/**
	 * 输出结果：
	 *             除数不能为零！
	 *             finally
	 *             end
	 */
}

   

        B、处理多个异常：

public class ExceptionDemo {
	public static void main(String[] args) {
		method();
	}

	public static void method() {
		int num = 10;
		int[] arr = new int[2];
		try {//try语句里面是可能出现异常的代码
			
			//那个异常在前面，就只处理该异常，后面的异常直接忽略
			System.out.println(arr[2]);
			System.out.println(num / 0);
			
		} catch (ArithmeticException ae) {//catch语句里是针对异常的处理，catch(异常名称 变量名)
			System.out.println("除数不能为零！");
			
		}catch(ArrayIndexOutOfBoundsException ae){
			System.out.println("数组访问越界！");
		}finally{//finallyu语句里面的代码始终都会执行，不管前面是否出现异常
			System.out.println("finally");
		}
		System.out.println("end");//后面的代码仍可以执行
	}
	/**
	 * 输出结果：
	 *             数组访问越界！
	 *             finally
	 *             end
	 */
}

 

   try{}catch(){}finally{}异常处理语句的总结：

        A、只要有try{}在前，后面可以跟catch{}或者finally{}任意一个。

        B、catch{}和finally{}必须在有try{}的时候才能使用。

        C、finally{}语句只要存在，里面的代码就一定会执行。

        D、异常处理的变形：

                      a、try{}catch(){}finally{}

                      b、try{}catch(){}

                      c、try{}catch(){}catch(){}

                      d、try{}catch(){}catch(){}finally{}

                      e、try{}finally{}

 

    后面两个方法分别是throws和throw两个抛异常的关键字，在介绍方法之前先说明以下这两个关键字的区别：

          A、

            throws：在方法声明上，后面跟的是异常的类名，可以跟多个。

             throw：在方法内申明，后面跟的是异常对象名，只能跟一个。

          B、

            throws：此方法声明的异常，只是一种可能性。

             throw：此方法声明的异常，肯定有一个异常。

      

      两个方法共同特点：谁调用谁处理。

 

如果，throw在方法里抛出了一个编译期异常，它自己是没有办法处理的，这时就要throws在方法声明上把这异常抛出去给调用者处理。

所以说，throw只要抛出的是编译期异常，那么就一定需要throws把异常抛出去。

 

2、使用throws关键字：在方法上声明，告诉调用者，此方法可能有异常。

public class ExceptionDemo {
	public static void main(String[] args) {
		//谁调用，谁处理
		try{
		method();
		}catch(ArithmeticException ae){
			System.out.println("除数不能为零！");
		}
	}
                                          //在方法上申明，后面跟异常名
	public static void method() throws ArithmeticException{
		int num = 10;
		System.out.println(num / 0);
	}
	/**
	 * 输出结果： 
     *             除数不能为零！
	 */
}

 

3、使用throw关键字：在方法内声明，告诉调用者，此方法有一个异常。

public class ExceptionDemo {
	public static void main(String[] args) {
		//谁调用，谁处理
		try{
		method();
		}catch(Exception ae){
			ae.printStackTrace();
		}
	}
                                          //方法申明上，用throws再抛出去
	public static void method() throws Exception{
		int num = 10;
		try{
		System.out.println(num / 0);
		}catch(ArithmeticException ae){
			                     //抛的是编译器异常
			throw new Exception("异常来啦！");
		}
	}
	/**
	 * 输出结果： 
                   java.lang.Exception: 异常来啦！
	                        at Test01.ExceptionDemo.method(ExceptionDemo.java:19)
	                        at Test01.ExceptionDemo.main(ExceptionDemo.java:7)

	 */
}

 

 

注意：如果每个方法在调用时都是throws给其它方法处理，那么到了main方法里面抛出去，那就是JVM默认处理。

      

 

 ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------