异常处理

异常处理：

　　　　异常（Exception）是程序在执行过程中锁产生的问题；

　　异常分类：

　　　　问题：1）异常（Exception）：（1 运行时异常（未检查异常）：表现形式出现；

　　　　　　　　　　　　　　　　　　 （2 编译异常（检查异常）：（Unhandled exception：编译异常)是在编译期调用某个方法有可能抛出某个或几个异常，需要处理，否则编译不通过；

　　　　　　　2）错误（Error)：程序员不能用代码处理的问题，常是硬件、环境、系统问题；

　　异常的控制流程：

　　　　在java中，异常（Exception）是被一个方法抛出的对象，当一个方法抛出异常时，该方法从调用栈中被弹出，同时产生的异常对象抛给栈中的前一个方法；

　　　　对于异常处理，方法有3种：

　　　　　1、捕获异常，不让它沿着调用栈继续向下抛出；

　　　　　2、捕获异常，并继续向下抛出；

　　　　　3、不捕获这个异常，从而导致方法调用栈中被弹出，异常对象i继续抛给调用栈下面的方法；

　　异常分类：Throwable类：

　　　　　　1）Error→AssertionError

　　　　　　2）Exception→IOException

　　　　　　　　　　　　 →RuntimeException→lllegalArgumentException→NumberFormatException

　　　　　　　　　　　　　　　　　　　　　　  →ArithmeticException

　　　　　　　　　　　　　　　　　　　　　　  →NullPointerException

　　异常处理：1）预判，提前消除异常出现的条件；

　　　　　　　2）异常捕获：try-catch-finally

 

public class ClassC {
    
    public void methodC(){
        System.out.println("methodC begin......");
        while(true){
            try{
                System.out.println("请输入一个正整数：");
                int    input = new Scanner(System.in).nextInt();
                int result = 100 / input;
                System.out.println("result = " + result);
                break;
            }catch(ArithmeticException ae){　　　　　　　　　　　　　　　　// （ArithmeticException ae)——括号内输入异常引用
                System.out.println("不能输入0！");　　　　　　　　　　　　 //　语句块：异常提示语句；
            }catch(InputMismatchException ime){
                System.out.println("只能输入整数！");
            }catch(Exception ex){　　　　　　　　　　　　　　　　　　　　　 //　如果捕获异常与继承关系；父类异常写在后面，子类异常写在前面
                ex.printStackTrace();　　　　　　　　　　　　　　　　　　　//　打印出异常（开发是引用，软件发布后删除）
            }finally{　　　　　　　　　　　　　　　　　　　　　　　　　　　　//　 不管被保护代码发生什么异常，都必须实行的异常；
                System.out.println("methodC end......");
            }
         }
    }
}

　　　　写在最后catch块后面，放在finally当中的都是资源的清理，通道的关闭动作；finally：不管break、continue还是return都无法阻止finally被执行，finally在他们之前先被执行；

　　　　语法上：try—catch—finally  都不能单独存在；

　　　　　　　　try后面必须接catch或finally；

　　　　　　　　try后面：catch或finally两者可同时存在或存在其中一个；

　　　　　　　　catch或finally前面必须写try；

        //针对一道特有面试题
	public int methodAA(){
		int result = 0;
		try{
			result = 5;
			return result;
		}catch(Exception ex){
			result = 6;
		}finally{
			result = 7;
		}	
		return 0;
	}    

最后操作台输出：result = 5；（因为result = 5 预先存入数据段中， finally再被执行result=7，  最后打印result调出赋值是预先存入的5，所以打印出result = 5 ）

　　捕获异常：

　　　　Try程序块里面的语句是按顺序执行的语句；

　　　　当try程序块里面的语句抛出一个异常的时候，程序的控制专项了匹配的catch程序块，catch程序块里面的语句被执行；

　　　　当异常发生后，程序执行将忽略try程序块中剩余的语句，继续执行程序块后面的语句；

　　　　如果在try程序块中没有抛出异常，那么catch块将被忽略没程序将继续执行try-catch下面的语句；

 

　　使用Thows关键字抛出异常对象：

　　　　一个完整的方法申明：访问修饰符  可选修饰符 返回类型 方法名（形参列表）throws 抛出的异常列表；throws还会影响到重写的规范---子类重写方法不能抛出比父类被重写方法更多的异常。(这里的更多不是指异常类型的个数，而是异常类型的范围。)
　　　　当主动抛出的是一个编译时异常的时候，必须要在编译期对本方法的调用者提出警告,所以在方法的申明部分，应该有throws内容,表明本方法有可能发生异常。

public class AClass {

	public void bMethod() throws Exception{
		int choice = new Scanner(System.in).nextInt();
		if(choice > 5){
			throw new Exception();
		}
	}
}

　　

　　　throw 和 throws的辨析：
　　　　1、throw和throws都是关键字，都是属于异常处理部分的；
　　　　2、throw是写在方法体当中的，后面跟的是一个异常对象；
　　　　    throws是写在方法的申明的最后的，后面跟的是一个或多个异常类
　　　　3、当运行到throw这句代码的时候，就会真正发生抛出一个异常对象的动作；
　　　　     throws是在编译期警告本方法的调用者，有可能会发生哪些类型的异常。
　　　　4、当一个方法体当中有throw语句，不一定会有throws，除非throw后面
　　　　　  跟的是编译时异常，那就必须写throws。

　　　　所有抛出异常必须在main方法之前处理，不然抛到main方法时就就到虚拟机中执行；

　　自定义异常：

　　　　三层结构：表示层、业务层、数据访问层（持久层）

　　

//1、自定义异常一定要继承Exception
public class LovoException extends Exception{
	
	public LovoException(){
		
	}
	
	//2、自定义异常至少要有两个带参构造；
	//   一个带异常参，一个带字符串参。
	//   前者用于把其它异常类型转换为自定义异常
	//   后者用于操作非JVM主动抛出的业务异常（比如：工资为负）
	public LovoException(Exception ex){
		super(ex);
	}
	
	public LovoException(Throwable th){
		super(th);
	}
	
	public LovoException(String msg){
		super(msg);
	}
	
	//3、可以给自定义异常提供扩展方法
	public void writeLog(){
		System.out.println("打印日誌");
	}
	
}