异常

异常

一、概念【理解】

1. 异常：程序运行过程中出现的非正常的情况。
2. 异常处理：当异常出现时，执行预先准备好的程序。
3. 异常处理必要性：减少用户的损失、同时也减少给用户带来的不必要的麻烦；也可以利用异常处理给与用户一些提示。

二、异常的分类【理解：面试重点】

1. Throwable：Java语言中的异常或是错误的父类，位于 java.lang 包中。
   (1) 构造方法
   a. Throwable() ：无参数的构造方法
   b. Throwable(String message)：带有异常信息的构造方法
   (2) 成员方法：
   a. String getMessage()：获取字符串类型异常信息
   注意：为用户做提示信息而设置的方法。
   b. void printStackTrace()：打印输出方法调用过程中产生的栈详细异常信息。
   注意：此方法为编程人员调试程序而设置的方法。
2. Error：是Throwable的子类，代表错误
   注意：Error通常是仅靠程序本身无法恢复的严重错误
   例如：JVM内存不足或是方法调用过程中栈溢出(java.lang.StackOverflowError栈溢出)、
   OutOfMemoryError(堆溢出)
3. Exception:是Throwable的子类，代表异常
   (1) RuntimeException：运行时异常、未检查异常,和RuntimeException 有直接或间接继承关系的异常类称为运行时异常
   a. 特点：编译器不检测此类异常，编译通过，但是运行报错
   b. 处理：运行时异常可处理也可以不处理,此类通过严谨代码可以避免
   c. 常见的运行时异常：
   ① ArrayIndexOutOfBoundsException(数组下标越界)
   ② StringIndexOutOfBoundsException(字符串下标越界)
   ③ IndexOutOfBoundsException(集合中下标越界)
   ④ java.lang.NullPointerException(空指针异常)
   ⑤ java.lang.ClassCastException(类型转换异常)
   ⑥ java.lang.NumberFormatException(数字格式转换异常)
   (2) 非RuntimeException：非运行时异常、已检查异常,和 RuntimeException没有任何继承关系的异常类称为非运行时异常
   a. 特点：编译器检测此类异常，编译报错
   b. 处理：非运行时异常一旦出现，必须处理
   c. 例如：Class.forName(“Student”)；// 区分于语法错误

三、异常产生的原因 【重点】
(1) 自动产生异常：
a. 产生原因：程序运行过程中，遇到错误的代码，自动产生异常。
b. 结果：程序中一旦出现异常，程序不能继续执行之后的代码，则程4序被终止掉。
(2) 手动产生异常：【开发应用重点】
a. 关键字： throw
b. 语法：throw new 异常类名(“异常信息”);
c. 位置：定义在方法内部
d. 结果：作用效果类似于return语句，终止当前方法、函 数；程序运行时因异常而被终止掉。

public class TestRuntimeException3 {    
	public static void main(String[] args) {        
		System.out.println("-----main ---start---");        
		m1();
		System.out.println("-----main ---end---");    
	}        
	public static void m1() {        
		System.out.println("-----m1---start----");        
		m2();        System.out.println("-----m1----end-----");    
	}      
	public static void m2() {        
		System.out.println("----m2----start---");                // 手动产生异常(抛出异常)        
		throw new RuntimeException("程序因异常而 被终止");        
		//      System.out.println("----m2----end---");            
	}         
	public static int test() {        
		return 0;
		//      System.out.println("-----");    
	}
}
	

四、异常的传递：【理解】
Java中的异常沿着方法的调用链进行反方向进行传递，终传递给JVM。

五、异常的处理【开发应用重点】

1. 消极处理异常(声明异常)
   (1) 关键字：throws
   (2) 位置：在方法声明处
   (3) 语法：
   修饰符 返回值类型 方法名(形参列表)throws 异常的类名1,异常类名2{
   // 方法的实现部分
   }
   (4) 注意：消极处理异常时，可以利用其父类型的异常进行处理
   (5) 结果：消极处理异常只是推卸责任，终将责任推卸给 JVM，程序终还是因异常而被终止。
   (6) 作用：消极处理异常可以让非运行时异常在编译时通过。

public class TestThrows {    
	public static void main(String[] args)throws Exception{ 
		System.out.println("----main---start--1");//1        
		m1(2);
		System.out.println("----main---end--2");//2    
	}        
	public static void m1(int n)throws ClassNotFoundException,IOException{        
		System.out.println("----m1---start---3");//3        
		m2(n);        
		System.out.println("----m1---end---4");//4    
	}        
	public static void m2(int n)throws ClassNotFoundException,EOFException,FileNotFoun dException{// 推卸责任        
		System.out.println("----m2---start---5");//5                
		if(n==1)  throw new RuntimeException();//运行时异常        
		// 非运行时异常，编译报错 ，必须处理        
		if(n==2) throw new ClassNotFoundException();                
		if(n==3) throw new EOFException();// 非运行时异常        
		// 非运行时异常
		if(n==4) throw new FileNotFoundException();                
		System.out.println("----m2---end---6");//6    
	} 
}

2. 积极处理异常
   (1) 语法

try{    
	// 可能出现异常的语句 }
	catch(异常类名 e){    
	// 异常出现执行的语句 
}

(2) 注意：
a. try…catch结构，一旦异常出现try…catch 才起作用
b. try后面可以跟多个 catch结构，一旦try中出现异常，则从上往下依次进行匹配catch，直到匹配成功
c. catch中可以利用父类型捕获：本类+所有的子类型的异常，体现多态
d. 子类型 的 catch 需要定义在父类型的 catch前面
e. catch中 只能定义 try中可能出现的非运行时异常；
注意:catch中可以定义任意的运行时异常，即使try中不可能出现此类运行时异常

(3) finally ：必须执行语句

语法：

try{    
	// 可能出现异常的语句 
}catch(异常类名 e){    
	// 异常出现时，执行的语句 
}finally{   
	 // 不管有没有异常，必须执行的语句     
}

注意：开发时，通常不要将 return定义在finally中，finally 通常用于关闭资源，例如IO流等
(4) 常见的结构小结：
try{}catch(){}
try{}catch(){}catch(){}
try{}catch(){}finally{}
try{}catch(){}catch(){}finally{}
以下结构遇到认识：
try{}finally{} // 这种做法目的是保证某些代码放在finally中必须执行
try{ try{}catch(){} }catch(){}
try{}catch(){ try{}catch(){} }
try{}catch(){}finally{ try{}catch(){} }
注意：finally要么和 try一起，要么 try…catch一起，但是不能单独使用
(5) 面试：【面试中重点】

写出 final、finalize、finally的区别。
a. final：修饰符，可以用于修饰变量、方法、类
final修饰的变量作用范围内的常量，允许一次赋值，不允许修改
final修饰方法：允许子类继承使用，但是不允许子类覆盖
final修饰的类：不允许子类继承，即没有子类
b. finalize：方法名，此方法是Object类中的，在垃圾回收器回收垃圾对
象，jvm自动调用的方法
c. finally：积极处理异常时结构内容，必须执行的语句定义 finally中。
常用的结构：try{}catch(){}finally{} / try{}finally{}
开发时应用场景：关闭资源的语句定义在finally中，利用IO流.

六、自定义异常类 【开发偶尔会应用】

1. 定义一个类继承Exception或是其子类，如果定义的类继承了RuntimeException或是RuntimeException的子类，则此异常为运行时异常；如果此类和 RuntimeException没有任 何继承关系，则异常类为非运行时异常
2. 提供两个构造方法：
   a. 无参数的构造方法
   b. 有参数的构造方法，参数类型为 String，接收异常信息利用super(message); 设置异常信息

public class TestMyException {    
	public static void main(String[] args) {                
		Scanner sc = new Scanner(System.in);        
		System.out.println("请输入您的密码：");        
		String password = sc.next();        
		checkPassword(password);            
	}    
	// 检测密码    
	public static void checkPassword(String psw) {        
		try {            
			if(psw.length()!=6) {                
				//抛出异常，并且带有 "此密码必须为6位" 异常信息                
				//抛出 关于密码检测异常
				throw new CheckedPasswordException("此密码必须为6位");            
			}                        
			System.out.println("密码输入正确....");            
			System.out.println("请继续一下的操 作...");        
		}catch(CheckedPasswordException e) { 
			//          String message = e.getMessage();
			//为用 户做提示信息 
			//          System.err.println(message);            
			e.printStackTrace();        
		}    
	} 
}
class CheckedPasswordException extends Exception{    
	public CheckedPasswordException() {}    
	public CheckedPasswordException(String message) {        
		super(message);    
	} 
}

七、方法覆盖(也称为 重写：override)【终极版：面试+开发重 点】

1. 子类的方法名、形参列表、返回值类型和父类相同
2. 子类的访问修饰符和父类相同或是比父类更宽
3. 子类不能抛出比父类更多、更宽的异常