Java基础 -＞ 异常（try-catch，throws，throw）

API
模块  java.base
软件包  java.lang
Class Throwable
java.lang.Object
java.lang.Throwable
实现的所有接口
Serializable
已知直接子类：
Error ， Exception

异常的处理
异常“抛”：程序出现异常就会在异常代码处生成一个异常类的对象并抛出，抛出对象以后，之后的代码就不在执行。
异常“抓”：处理异常的方式：
try：可能产生异常的代码
catch：捕获异常
finally：无论是否有异常都要执行的代码
throw：抛出异常，手动抛出异常
throws：声明异常，声明有方法可能会抛出异常

①try-catch-finally ②throws

①try-catch-finally格式：

/*
 * 	格式：
 * 		try{
 * 			//可能出现异常的代码
 * 		}catch(异常类型 变量名1){
 * 			//处理异常的方式1
 * 		}catch(异常类型 变量名2){
 * 			//处理异常的方式2
 * 		}
 * 		......
 * 		finally{
 * 			//一定会执行的代码
 * 			//finally是可选的，可以选择不写finally{}
 * 		}
 */
public class YiChang {
	public int exception1() {
		String a = "10";
		a = "asd";
		try {
			//可能出现异常的代码
			//try中声明的变量出了try就不能用了，如：num
			int num = Integer.parseInt(a);
			System.out.println("异常");
			
			//如果前面没有异常就返回1，否则从异常处结束进入catch[]，不会再执行后面的代码。
			//如果后面有必须要执行的代码，可以把这些代码放在finally里，避免异常执行不到。并且finally里的的代码可以嵌套try-catch-finally再判断一次异常
			return 1；
		}catch(Exception e) {
				//Exception包含了所有异常类型，是所有异常的父类
				//处理异常的方式
				//常调用的方法:① String getMesssge();
			System.out.println(e.getMessage());
			
				//			  ②printStackTrace();经常用
			e.printStackTrace();
			System.out.println("xxx出现异常，请检查修改");
			
			//这里还可以写代码，如
			//返回2之前看看有没有finally，有先执行finally（这个是必须执行的）再返回。
			return 2；
		}finally{
			System.out.println("xxx出现异常，请检查修改");
			
			//如果finally里也有一个return 那么就执行finally，再退出异常结构之前必须执行finally，再退出。
			//return是一个返回，这里返回就不会再执行return 2;了
			//return 3;
		}
}

附：
API--
java.lang.Throwable

	 String getMessage() 
	          返回此 throwable 的详细消息字符串。 
	          System.out.println(e.getMessage());
	          
	 void printStackTrace() 
	     	  将此 throwable 及其追踪输出至标准错误流。 
	     	  e.printStackTrace();
	     	  
	  String toString() 
          	  返回此 throwable 的简短描述。 
          	  System.out.println(e.toString());

②throws

不处理异常，只是抛出异常，告诉你有异常，并不会处理
throws也是配合try-catch使用的

/*
 * 	格式：（throws 异常类型）//直接写throws Exception
 * 
 * 	其他地方调用写异常的方法时野同样要加上throws Exception
 */
class YiChang {
	public void exception1() throws Exception {
		String a = "10";
		a = "asd";
		int num = Integer.parseInt(a);
		System.out.println("异常");
		
	}
}

异常有一定传递性：
子类重写的方法有异常，那么父类也有异常，抛出异常也要加throws。
父类没有抛出异常（thorws），就用try-catch-finally去处理异常。

总结

操作：
try抛出异常对象，catch中处理异常之后可以继续运行代码，不会终止程序
相反throws只是抛出异常，不处理异常，抛出就会停止程序。
除非在异常的代码内使用try-catch-finally之后才能继续执行程序
在父类中处理一次，整个程序第一次出现异常的地方用try-catch-finally处理，在第一次异常的代码中又存在其他的方法调用，就在这些方法中用throws抛出。

class YiChang2{
	public void name() {
		try {
			方法1();
			方法2();
			方法3();
		}catch (Exception e) {
			// TODO: handle exception
			System.out.println("xxx出现异常，请检查修改");
		}
	}
	
	public void 方法1() throws Exception {
		
	}
	public void 方法2() throws Exception {
		
	}
	public void 方法3() throws Exception {
		
	}
}
	

附加1：

手动写异常：例
注：throw是手动写抛出异常，throws是处理异常

	if() {
	
	}else {
		//直接返回异常对象，反正就是错了，也不用想其他的了
		throw  new Exception()；
	}

public class finallytest {
	public static void main(String[] args)  {
		try {
			new YiChang2().name(-10);
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
		
	}		
}
	
/*
 * 	手动写异常：步骤：
 * 		1	throw new exception();
 * 		2	在方法声明处加throws Exception
 * 		3	在调用方法处写try-catch处理异常
 */
class YiChang2{
	int i;
	public void name(int i) throws Exception{
		if(i > 0) {
			this.i = i;
		}else {
			//手动写异常
			throw  new Exception("YiChang2.name()这里出问题啦");
			//throw new RuntimeException("YiChang2.name()这里出问题啦");
			//不同点，Exception方法需在该方法后加throws Exception。
			//RuntimeException（运行时异常），不需要
		}
		
	}
	
}

附加2

异常类可以自定义，使用throw的时候都要直接写一个异常类。

class YiChang2 extends Exception{
	//参照 Exception类去重写方法，构造器
｝
之后可以throw new  YiChang2 ();就是自己自定义的异常类