Java基础之异常

Throwable：

        Throwable 类是 Java 语言中所有错误或异常的超类；
        Exception是所有异常类的父类；

        异常：
编译时期异常：只要出现的不是运行时期异常,统称为编译时期（开发者必须处理）；
                        例：日期的文本格式---解析   java.util.Date类型：ParseException解析异常；
运行时期异常：RuntimeException；

                        编译通过了，但是开发者代码不严谨(NullPointerExceptino等等)；
                注意事项：子类继承父类的时候的注意事项 ；
                        1> 子类重写父类的方法的时候，子类的方法的抛出的异常必须要么是父类的方法异常一样，要么是父类方法异常的子类；
                        2> 子类重写父类方法的时候，如果父类中的这个方法没有抛出异常，那么子类重写的这个方法也不能抛出异常，只能try...catch；

        编译时期异常和运行时期异常的区别?
                编译时期：开发者必须进行显示处理，不处理，编译不能通过；
                运行时期异常：无需进行显示处理，可以像编译时期一样进行处理；

        异常还可以分为：
                捕捉异常：捕捉异常由try，catch和finally三部分构成；
                        try语句块：用来存放可能发生异常的Java语句；
                        catch程序块：用来激发被捕捉的异常；
                        finally语句块：是异常处理结构的最后执行部分，无论try语句块中的代码如何退出，都将执行finally语句块；
                                注意：只有在前面的代码中出现System.exit()，程序直接退出，不执行finally中的语句；
                               面试题：如果catch里面有return 语句，finally中的代码还会执行，是在return语句之前执行还是return后执行?
                                解答：finally中代码是一定会执行的，是在return前；
                                举例：

public class FinallyTest {
	
	public static void main(String[] args) {
		System.out.println(getInt());
	}

	private static int getInt() {
		int a ;
		try {
			a = 10 ;
			System.out.println(a/0);
			a = 20 ;
		}catch(Exception e) {
			a= 30 ;			
			return a ;
			/**
			 * try的代码出现问题了,执行catch中的语句,30赋值a,
			 * return 30(已经形成了一个回路径)finally代码一定会执行(除非Jvm) a = 40 ,在fianlly外面
			 * 有return a: a记录回路径的那个a,返回30
			 */
		}finally {
			//除非jvm退出了
			a = 40 ;
			
		}
		return a;//30
	}
}

                抛出异常：使用throws关键字，通常被应用在方法声明时，用来指定方法可能跑出的异常；

                        注意：多个异常可以使用逗号隔开；

捕捉异常：

        处理单个异常：
                 举例：

public class ExceptionDemo2 {
	
	public static void main(String[] args) {
		
		int a = 10 ;
		int b = 0 ;
		try {
			//捕获到
			//出现问题的代码
			System.out.println(a/b);
		}catch(ArithmeticException e) {  //ArithmeticException e = new ArithmeticException() ;
			//用输出语句来处理异常
			System.out.println("初始不能0");
			//e.printStackTrace();
		}
		
		System.out.println("over");
		
	}
}

        处理多个异常：

                使用多个catch的应用；

                举例：

public class ExceptionDemo3 {
	
	public static void main(String[] args) {
		
		method1();  //处理一个异常
                method2();  //处理两个异常使用两个try...catch...
                method3();  //处理两个异常，使用try...catch...catch...catch...
	}

	private static void method3() {
		int a = 10 ;
		int b = 0 ;
		int[] arr = {1,2,3} ;
		try {
			//产生一个异常对象
			System.out.println(arr[3]);
			System.out.println(a/b); 
			System.out.println("代码可能到这一步出现了问题,怎么办?");
		}catch(ArrayIndexOutOfBoundsException e) {
			System.out.println("访问了数组中不存在的角标");
		}catch(ArithmeticException e) {
			System.out.println("除数不能为0");
		}catch(Exception e) { //爷爷 (最大的类一定在最后一个异常 extends		RuntimeException extends exception
			System.out.println("程序出问题了....");
		}
	}
	
	//两个异常的处理
	//分别try...catch
	private static void method2() {
		
		int a = 10 ;
		int b = 0 ;
		
		try {
			System.out.println(a/b);
		}catch(ArithmeticException e) {
			System.out.println("除数不能为0");
		}
		
		int[] arr = {1,2,3} ;
		try {
			System.out.println(arr[3]);
		}catch(ArrayIndexOutOfBoundsException e) {
			System.out.println("访问数组中不存在的角标...");
		}
	}

	//一个异常的处理
	private static void method1() {
		int a = 10; 
		int b = 0 ;
		
		try {
			System.out.println(a/b);
		}catch(ArithmeticException e) {
			System.out.println("除数不能为0");
		}
		
	}
}

        JDK7之后出现的一个catch中有多个异常：

        举例：

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

		//jdk7以后的方式
		//注意:catch中多个异常类属于同一个级别
		int a = 10 ;
		int b = 0 ;
		int[] arr = {1,2,3} ;
		try {
			//可能有问题
			System.out.println(a/b);
			System.out.println(arr[3]);
		}catch(ArithmeticException | ArrayIndexOutOfBoundsException e) {
			System.out.println("程序出问题了...");
		}
	}
}

Throws中的throw关键字：

         throw关键字通常用于方法体中，并且抛出一个异常对象(throw new 异常类名() :匿名对象的方式)；
        特点：
                1> 程序在执行到throw语句是立即停止，它后面的语句都不执行；
                2> 如果throw抛出异常后，如果想在上一级代码中捕获并处理异常，则需要在抛出异常的方法中使用throws关键字在方法的声明中也要抛出异常；

                3> 如果要捕捉throw抛出的异常，则必须使用try-catch语句块；

        面试题：
throws和throw的区别?
  throws：
                        1> 也是表示抛出异常,它后面跟的异常类名,并且可以多个异常类名中间逗号开；
  举例：public void show() throws IoException,ClassNotFoundException{...}
  2> 在方法上抛出,由调用者处理；
  3> 它表示抛出异常的可能性；
  throw：    
                        1> 抛出的一个异常对象；
          2> 在语句体中抛出的,由语句体进行处理；
  3> 它表示抛出异常的肯定性；

        举例：

class MyException extends Exception{
	
	String message;

	MyException(String ErrorMessage) {
		message = ErrorMessage;
	}

	public String getMessage() {
		return message;
	}
}

public class ExceptionDemoThrow {

	static int quotient(int x,int y) throws MyException{
		if(y<0) {
			throw new MyException("除数不能是负数");
		}
		return x/y;
	}
	
	public static void main(String[] args) {
		try {
			int result=quotient(3, -1);
		}catch(MyException e){
			System.out.println(e.getMessage());
		}catch(ArithmeticException e) {
			System.out.println("除数不能为0");
		}catch(Exception e) {
			System.out.println("程序发生了其他的异常");
		}
	}
}