异常（个人复习）

异常

一、异常的分类

1.异常的含义

异常时java处理错误的一种机制。

2.异常的语法

处理异常的关键字有: try、catch、finally、thorw、throws

（1）try-catch（用来捕获异常）

格式
try {
代码段
产生异常(异常类型)
}
catch (异常类型 e) {
对异常进行处理的代码段
}
代码段

public class MyException {

	public static void main(String[] args) {
//		try.catch
		try {							//  try监控可能出现异常的代码块
			int a = 1;
			int b = 0;
			int c = a/b;
		} catch (Exception e) {			//  catch捕获异常
		System.out.println("除数不能为0");
			e.printStackTrace();		//	打印栈信息
		}
	}

try{}代表的是受到监控的代码。

catch{}一旦try{}块中的代码段出现异常就会跳到catch块中执行。
try{}和catch{}块是一个整体，不能单独出现，比如单独try{}块或catch{}块，这样是不合法的。

e是产生异常对象的名字

（2）多重catch块

格式
try {
代码段
产生异常(异常类型2)
} catch (异常类型1 e) {
对异常进行处理的代码段
} catch (异常类型2 e) {
对异常进行处理的代码段
} catch (异常类型3 e) {
对异常进行处理的代码段
}
代码段

	public static void main(String[] args) {
		try {
			int a = 10;
			int b = 0;
			int c = a/b;//除数为零

			int[] aa = {1,2,3};
			System.out.println(aa[1]);//数组下标越界
			
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			sdf.parse("1111-11-11");//转换异常
			
			String arr =null;
			System.out.println(arr.equals("abc"));//空指针异常
			
		} 
		catch (Exception e) {
			e.printStackTrace();
		}
//		catch (ArithmeticException e) {
//			e.printStackTrace();	//转换异常
//		}catch (ParseException e) {
//			e.printStackTrace();	//除数为零
//		}catch (ArrayIndexOutOfBoundsException e) {
//			e.printStackTrace();	//数组下标越界
//		}catch (NullPointerException e) {
//			e.printStackTrace();	//空指针异常
//		}
	}

（3）Finally

即使出现了异常依然会执行

finally通常用在：代码中有必须要执行的代码（比如释放资源）的情
况

注意： 同样也有 try{}finally{} 结构。

public static void main(String[] args) {
		/*
		System.out.println("111");
		try{
			System.out.println("222");
			int result = 10/0;
			System.out.println("333");
			
		}catch(Exception e){
			System.out.println("444");
			//return;
		}
		System.out.println("555");
	*/	
		System.out.println("111");
		try{
			System.out.println("222");
			int result = 10/0;
			System.out.println("333");
			
		}catch(Exception e){
			System.out.println("444");
			//return;  
 //即使有return finally的代码也要执行，在return之前执行;
			
		}finally{
		   System.out.println("555");
	    }
}

（4）Throws

当程序中发生异常时，无论是程序运行出现的运行时异常，编译阶段的非运行时异常，还是手工抛出的异常，都可以在程序中使用try{}catch进行处理。但也可以在当前的程序(也就是当前方法中)，不做任何处理。使用throws关键字在方法声明时，进行异常的抛出。交给方法的调用者去处理，当方法的调用者也不知道如何处理，或不想处理时，可以继续向上抛出

格式
类型 方法名（参数列表） throws 异常列表{
代码
}

public static void method() throws ParseException,FileNotFoundException{
		
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		String str = "aaaa-11-11";
		Date d = sdf.parse(str);
		FileInputStream is = new FileInputStream("D:/aaa.txt");
	}

（5）手工抛出异常Throw

手工抛出异常，其效果和程序抛出异常是一样的，只是它是人为地抛出。
抛出异常的格式为：throw ThrowableObject

public static void main(String args[]) {
	System.out.print("Now");
	try {
		System.out.print("is");
		throw new NullPointerException(); // 直接抛出一个异常 ;
		// System.out.print("This will not execute!"); //此句不被执行
	} catch (NullPointerException m) {
		System.out.print("the");
	}
		System.out.print("time. \n");
}

（6）自定义异常

java的面向对象思想将程序中出现的特有问题进行封装。
当jdk内置异常类型不足以满足系统需求时，我们需要自定义异常类型。
使用自定义异常和使用jdk内置异常是一回事。

自定义异常的方式： 继承Exception 或 RuntimeException

//自定义的运行时异常
public class MyException extends RuntimeException{
	/*
	 * 在自定义异常时，完全可以自定义一些属性和方法。但多数时间不需要这样做
	 * */
	public MyException(){
		
	}
	public MyException(String message){
		super(message);
	}

// 自定义一个非运行时异常
public class MyException2 extends Exception {
	  public MyException2(){
		  
	  }
      public MyException2(String message){
		  super(message);
	  }
}

3.异常的体系

Throwable(实现类描述java的错误和异常): 所有异常的根类，所有的异常类都由它继承。
Error(错误): 错误是不能被处理的，因为这是系统内部的错误，运行时报错，系统问题。
Exception(异常): 程序员根据问题描述可处理的异常。
RuntimeException(运行时异常): 可处理的异常，一般不做处理。
非运行异常(受检查异常): 该类异常必须处理。

（1）Throwable类

1.toString() 输出该异常的类名。
2.getMessage() 输出异常的信息，需要通过构造方法传入异常信息（例如病态信息）。
3.printStackTrace() 打印栈信息。

	public static void main(String[] args) {
		Throwable throwable = new Throwable("想吐");
		// tostring()输出该异常的类名
		System.out.println(throwable.toString());
		// getMessage()输出异常的信息
		System.out.println(throwable.getMessage());
		//printStackTrace打印栈
		throwable.printStackTrace();//打印栈
	}

（2）Error（错误）

它指的是一个合理的应用程序不能截获的严重的问题。大多数都是反常的情况。错误是JVM的一个故障。所以，错误是很难处理的，一般的开发人员是无法处理这些错误的。比如内存溢出，栈溢出等。

public class Demo03_Error {
	public static void main(String[] args) {
		fun();   //java.lang.StackOverflowError  Error 不需要使用try catch处理
	}
	public static void fun(){
		fun();
	}
}

（3）Exception（异常）

运行时异常（RunTimeException）

运行时异常，不要求程序必须对它们做出处理。（在程序的编译期不会检查这种异常）

非运行时异常（受检查异常）

如果出现了非运行时异常必须进行处理 throw或者try{}catch(){}处理，否则编译期报错。
1：IOException 使用要导入包import java.io.IOException;
2：ClassNotFoundException
3：FileNotFoundException
4：ParseException