Java高级编程04（异常Exception）

异常：

在程序运行过程中出现的错误。 异常就是程序运行过程出现了不正常的现象导致程序的中断。 在java中， 把各种异常现象进行了抽象形成了异常类
异常主要分为： 错误，一般性异常，运行时异常

错误： 如果应用程序中出现了Error，那么将无法恢复,只能重新启动应用程序，最典型的Error异常是：OutOfMemoryError

一般性异常（编译时异常）：
这种异常必须显示的处理不显示处理java程序异常，编译将无法通过。编译器强制普通异常必须try…catch处理，或用throws声明继续抛给上层调用方法处理，所以普通异常也称为checkd异常。

运行时异常（RuntimeException）：
这种系统异常可以处理，也可以不处理，所以编译器不强制用try…catch处理或throws声明抛出。如果出现了运行时异常一般都是程序员自己的问题，健壮的程序一般不会出现这种异常

异常的处理：
运行时异常不需要预处理，通过规范代码可以避免产生这种异常。编译时异常必须预处理，否则编译报错，有两种预处理方式：
1.捕获处理
2.抛出处理

异常的捕获处理：
1. try/catch/finally
异常的捕获和处理需要采用try和catch来处理，具体格式如下：

   try{
       
   }catch(){
      
   }catch(){//catch块可以有多个
      
   }finally{
      
   }

try中包含了可能产生异常的代码，try后面的cathc,cathc可以有一个或多个，catch中是需要捕获的异常。
当try中出现异常时，出现异常下面的代码不会执行，会马上跳转到相应的catch中，如果没有异常则不会跳转到catch 中。finally代码块是不管是否出现异常，finally里面的代码都会执行，finally和catch可以分开使用，但finally必须和 try一起使用。例如：

   try{                
   
   }catch(){
  
   }
   
   try{
   
   }finally{
   
   }

package com.scy.exception;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ExceptionDemo2 {

	public static void main(String[] args) {
		testException1();
	}
	
	
	//try--catch异常捕获1
	public static void testException1(){
		//try {
			//1.对可能出现异常的代码进行检测
			//2.如果try代码块中某条语句出现异常，
			//就立即跳转到对应的catch中，try后边代码
			//不再执行
			//3.当try块中出现了多个检测异常需要处理，
			//可以通过多个catch子句分别进行处理。
			
		//}catch(ClassNotFoundException e1){
			//如果出现异常类型1 
			//则用该代码块处理。在开发阶段，一般异常处理
			//要么打印错误信息（e1.printStackTrace();）
			//要么输出运行日志，保存日志文件。（logger.error）
			
		//}catch(Exception e2){
			//如果捕获异常类型2
			//类型2与类型1之间有继承关系，要先捕获子异常
			//后捕获父异常。
			//如果没有继承关系，然后按照先后顺序
				
		//}finally {
			//不管是否发生异常，该子句继续执行
			//一般在该子句中常常用于释放系统资源。
		//}
		
		int i1=100;
		int i2 = 0;
		try {
			System.out.println("执行1");
			int i3 = i1/i2;
			System.out.println("继续执行2");
			
		} catch (ArithmeticException e) {
			
			System.out.println("除数不能为0");
			e.printStackTrace();
			
		}finally {
			System.out.println("继续执行3");
		}
		
		
	}
	//try--catch异常捕获2
	public static void testException2(){
		try {
			/*
			 * 异常的捕获一般都是有小到大的顺序。
			 * 先捕获子异常，再捕获父异常
			 */
			FileInputStream fis = 
					new FileInputStream("test01.txt");
			fis.close();
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
			
		}catch (IOException e) {
			e.printStackTrace();
		}
		/*} catch (IOException e) {
			e.printStackTrace();
			
		}catch (FileNotFoundException e) {
			e.printStackTrace();
		}*/
	}
}

throws 异常捕获

在定义方法体中如果有编译时异常需要预处理可以捕获处理，也可以抛出处理。
处理异常时，使用throws抛出处理
1.谁调用这个方法，谁负责处理这个异常
2.在定义方法，把异常抛出就是为了提醒方法的使用者，有异常需要预处理。
处理异常时：
1.一般情况下在调用其他方法是，如果被调用的方法中有编译时异常需要预处理，选择捕获处理。因为你调用了该方法，就需要负责处理。
2.在定义方法时，如果方法体中有编译异常需要处理 可以选择捕获，也可以选择抛出。如果在方法体中用throws语句抛出一个异常对象，所在的方法应该使用throws 声明该对象

public class ExceptionDemo3 {
	public static void main(String[] args) {
		try {
			testException();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}	
	}

	private static void testException() throws ClassNotFoundException {
		Class.forName("com.mysql.jdbc.Driver");
		
		//1.注册驱动
		try {
			Class.forName("com.mysql.jdbc.Driver");
		} catch (ClassNotFoundException e) {
			System.out.println("类找不到！");
			e.printStackTrace();
		}
	}
}

自定义异常
       通常继承于Exception或RuntimeException，到底继承那个应该看具体情况来定。
        自定义异常类可以有自己的变量和方法来传递错误代码或传递其它异常相关信息。实际工作中，都会自定义异常类来处理异常。
        throw 语句用在方法体内，表示抛出异常，由方法体内的语句处理。 该关键字是向外抛出异常的动作，所以它抛出的是一个异常的实例，执行throw一定是抛出了某种异常。
        throw一般用于抛出自定义 异常。

自定义编译时异常，继承Exception

package com.scy.exception;

/*
 * 自定义异常 （编译时异常） 继承Exception
 */
public class MyCheckException  extends Exception {

	//无参构造方法
	public MyCheckException() {
		super();
		// TODO Auto-generated constructor stub
	}
	//有参构造方法
	public MyCheckException(String message) {
		super(message);
		// TODO Auto-generated constructor stub
	}
}

自定义运行时异常，继承RuntimeException

package com.scy.exception;

/**
 * 运行时异常  
 */
public class MyRuntimException  extends RuntimeException{

	//无参构造
	public MyRuntimException() {
		super();
		// TODO Auto-generated constructor stub
	}
	//有参构造
	public MyRuntimException(String message) {
		super(message);
		// TODO Auto-generated constructor stub
	}
}

使用自定义异常

package com.scy.exception;

/**
 * 使用自定义异常
 * @author Administrator
 *
 */
public class UseMyExceptionClass {

	public static void main(String[] args) {
		//testException1();
		testException2();
		//int i = 10/0;
		
	}
	
	//使用chechedException异常
	private static void testException1() {
		try {
			method1(10, 0);
		} catch (MyCheckException e) {
			/*
			 * 必须拦截，拦截后建议给出拦截意见，如果不给出处理，就属于隐藏了该异常
			 * 系统将不给出任何提示，使程序调试非常困难
			 */
			System.out.println(e.getMessage());
		}
	}
	//使用运行时异常
	private static void testException2() {
		
		method2(10, 0);
		
	}
	
	//编译时异常使用案例
	public static void method1(int value1,int value2) throws MyCheckException{
		if(value2 == 0) {
			throw new MyCheckException("方法1：自定义编译异常，除数不能为0");
		}
		int value3 = value1 / value2;
		System.out.println(value3);
	}
	
	//运行时异常使用案例
	public static void method2(int value1,int value2) {
		if(value2 == 0) {
			//抛出运行异常方法，可以不用throws进行声明，但也可以显示声明
			throw new MyRuntimException("方法2：自定义运行异常，除数不能为0");
		}
		int value3 = value1 / value2;
		System.out.println(value3);
	}
}

运行结果：

异常相关的面试题

1 谈谈你Java异常处理机制的理解？

Java对异常进行了分类，不同类型的异常分别用不同的Java类表示，所有异常的根类为 java.lang.Throwable，Throwable下面又派生了两个子类：Error和Exception。

Error： 表示应用程序本身无法克服和恢复的一种严重问题。

Exception： 表示程序还能够克服和恢复的问题，其中又分为系统异常和普通异常。

系统异常
系统异常是软件本身缺陷所导致的问题，也就是软件开发人员考虑不周所导致的问题，软件使用者无法克服和恢复这种问题，但在这种问题下还可以让软件系统继续运行或者让软件死掉，例如，数组下标越界（ArrayIndexOutOfBoundsException），空指针异常（NullPointerException）、类转换异常（ClassCastException）。

普通异常
普通异常是运行环境的变化或异常所导致的问题，是用户能够克服的问题，例如，网络断线，硬盘空间不够，发生这样的异常后，程序不应该死掉。

Java为系统异常和普通异常提供了不同的解决方案，编译器强制普通异常必须try…catch处理或用throws声明继续抛给上层调用方法处理，所以普通异常也称为checked异常，而系统异常可以处理也可以不处理，所以编译器不强制用try…catch处理或用throws声明，所以系统异常也称为unchecked异常。
2 throw 和 throws 的区别？

throw
        throw 语句用在方法体内，表示抛出异常，由方法体内的语句处理。
        throw是具体向外抛出异常的动作，所以它抛出的是一个异常实例，执行throw一定是抛出了某种异常。
        throw一般用于抛出自定义异常。
throws
        throws语句是用在方法声明后面，表示如果抛出异常，由该方法的调用者来进行异常的处理。
        throws主要是声明这个方法会抛出某种类型的异常，让它的使用者要知道需要捕获的异常的类型。
        throws表示出现异常的一种可能性，并不一定会发生这种异常。

3 final、finally、finalize 的区别？
final
       用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，被其修饰的类不可继承。
finally
       异常处理语句结构的一部分，表示总是执行。
finalize
        finalize 是Object 类的一个方法，所以Java对象都有这个方法，当某Java对象没有更多的引用指向的时候，会被垃圾回收器回收，该对象被回收之前，由垃圾回收器来负责调用此方法，通常在该方法中进行回收前的准备工作。该方法更像是一个对象生命周期的临终方法，当该方法被系统调用则代表该对象即将“死亡”，但是需要注意的是，我们主动行为上去调用该方法并不会导致该对象“死亡”，这是一个被动的方法（其实就是回调方法），不需要我们调用。

4 Java中异常分为哪些种类？
       按照异常需要处理的时机，分为编译时异常(也叫受控异常)也叫 CheckedException 和运行时异常(也叫非受控异常)也叫 UnCheckedException。Java认为Checked异常都是可以被处理的异常，所以Java程序必须显式处理Checked异常。如果程序没有处理Checked 异常，该程序在编译时就会发生错误无法编译。这体现了Java 的设计哲学：没有完善错误处理的代码根本没有机会被执行。

       对Checked异常处理方法有两种：

当前方法知道如何处理该异常，则用try…catch块来处理该异常。
当前方法不知道如何处理，则在定义该方法时声明抛出该异常。

       对于运行时异常，只有当代码在运行时才发行的异常，编译的时候不需要try…catch。
       比如：除数是0和数组下标越界等，其产生频繁，处理麻烦，若显示申明或者捕获将会对程序的可读性和运行效率影响很大。所以由系统自动检测并将它们交给缺省的异常处理程序。当然如果你有处理要求也可以显示捕获它们。
5 error和exception的区别？
       Error类和Exception类的父类都是Throwable类，他们的区别如下：
        Error类一般是指与虚拟机相关的问题，如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢出等。对于这类错误的导致的应用程序中断，仅靠程序本身无法恢复和预防，遇到这样的错误，建议让程序终止。
       Exception类表示程序可以处理的异常，可以捕获且可能恢复。这种异常是由与程序设计的不完善而出现的问题，遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。
        Exception类又分为未检查异常（UnCheckedException）和受检查的异常(CheckedException)。
        运行时异常ArithmeticException，IllegalArgumentException编译能通过，但是一运行就终止了，程序不会处理运行时异常，出现这类异常，程序会终止。
       而受检查的异常，要么用 try…catch 捕获，要么用throws字句声明抛出，交给它的父类处理，否则编译不会通过。

6 说出最常见的5个RuntimeException？

常见的异常有：

java.lang.NullPointerException 空指针异常；出现原因：调用了未经初始化的对象或者是不存在的对象

java.lang.ClassCastException 数据类型转换异常

java.lang.ClassNotFoundException 指定的类找不到；出现原因：类的名称和路径加载错误；通常都是程序试图通过字符串来加载某个类时可能引发异常

java.lang.NoSuchMethodException 方法不存在异常

java.lang.NumberFormatException 字符串转换为数字异常；出现原因：字符型数据中包含非数字型字符

java.lang.IndexOutOfBoundsException 数组角标越界异常，常见于操作数组对象时发生

java.lang.IllegalArgumentException 方法传递参数错误

java.lang.NoClassDefFoundException 未找到类定义错误

SQLException SQL 异常，常见于操作数据库时的 SQL 语句错误

java.lang.InstantiationException 实例化异常