标签:throws   throw   trycatchfinally   catch多重继承   
java 之 -----------------   异常 处理 知识点小结
1 异常: 程序在运行时出现的不正常情况!
异常 会提前终止程序。
异常 提高了我们设计的程序的健壮性。
2 异常的由来:
               java 把 程序运行时出现的各种不正常情况!也看做对象!
     也提取出属性和行为进行描述。 成为 异常类。
3 异常的分类:
|----Throwable
     |------error
     |------Exception
               |---- RuntimeException
               |---- 非 RuntimeException
     严重           error
                    不用针对性代码! 有 JVM 处理,非人为!
                    OutOfMemoryError
     不严重        Exception  我们需要进行处理的异常!
                    提高我们带的健壮性!
                    需要 我们处理!
 
4 Java 异常的 内部实现
-      当发生异常的时候,首先JVM 创建异常的对象。 
 -      查看当前的对象的是能处理? 不能的话,
 -      向上抛出,循环上述过程。
 - 直到抛到JVM。JVM 进行处理!
 -      JVM 打印异常信息! 并且中断 程序!
 
 
 
 
异常的处理方式: 
有两种:
|----- 5 捕获
|----- 6 抛出
5  捕获 异常处理格式
- try
 - {
 -      可能发生异常的代码!
 - }
 - catch(异常类 参数名)
 - {
 -      处理异常的代码!
 - }
 - finally
 - {
 -      必须执行的代码!
 - }
 
 
 
6  声明抛出
 
当前代码段
不处理,交给调用者处理异常。
如果调用者不处理的话,继续 throws 。最终由JVM 处理!(不建议)
        出现可能的错误 直接处理!  小心 积少成坑!
 
如图:  处理异常的方法:
 
7  throws 的作用?
 
throws 声明可能发生的异常!
        将 运行时期 可能发生的错误,转移到 编译时期. 
 
更易于 纠正错误。
8   throws  声明之后 (throws 的异常,越细致越好!)  治学
 严谨
     调用者 必须处理!
     有两种处理方式:
    
      方案一:   最好使用 try  catch
               try  捕获
               {}
               catch()  处理异常
               {}
               finally    最终处理
               {}
     方案二:
               继续 throws !  最终由JVM 处理!(不建议)
               出现 可能的错误 直接处理!  小心 积少成坑!
 
9  catch的多重继承:
捕获异常的时候:一定要注意 捕获的异常的 大小关系!
子类的异常 要写在前面,我觉得他的优先级比较高。
有针对性。通常,你把子类的异常全部处理了之后,再去写父类的异常,
就会显得多余。因为,你可能不想 捕获 更多的异常!
 
 
10  throw : 抛出 异常(系统定义的,或者 自定义的!)
11 自定义 异常
     要继承Exception.  因为 继承了才具备可抛性!
     在函数内部使用 throw 抛出异常类对象:需要两种处理方式:
-    1 try{}catch(){}
 -    2 throws
 
自定义的异常:
/*
异常类如果是RuntimeException(运行时异常)或其子类,那么在函数内使用throw抛出,不用在函数上声明抛出,也不用捕获
因为java认为当遇到RuntimeException或其子类异常时,程序就该中断,不该处理
在函数后面声明抛出的异常如果是RuntimeException或其子类,调用者不用处理,编译照样通过
运行时异常通常都是接收用户传过来的参数,是由于用户传了不合理的数据造成的异常,所以程序该停下来修改数据
异常的分类:
1:编译时检测的异常   非RuntimeException或其子类
2:编译时不检测的异常 RuntimeException或其子类
*/
// 自定义的异常
class FuShuException extends Exception
{
	private int num;
	public FuShuException()
	{
	  super();
	}
	public FuShuException(String message)
	{
	  super(message);
	}
	public FuShuException(String message,int num)
	{
		super(message);
		this.num = num;
	}
	public int getNum()
	{
		return num;
	}
}
class MyMath
{
	public int div(int a,int b)throws ArithmeticException// 声明抛出异常,有调用者处理!
	{
       		 if(b==0)
			throw new ArithmeticException("被除数为0了");// 抛出异常
		return a/b;
	}
}
class Demo9
{
	public static void main(String[] args) 
	{
	        MyMath m = new MyMath();
        
		   int num = m.div(3,0);
           System.out.println("num="+num);
		
           System.out.println("over");
	}
}
 
 
12   throw 与 throws 区域?
throw 用在函数内部  
throws 参数签名后(声明抛出)
throw 跟的是异常对象  
throws  跟的是异常类 
 
 
13
异常类如果是RuntimeException(运行时异常)或其子类,
那么在函数内使用throw抛出,不用在函数上声明抛出,也不用捕获
因为java认为当遇到RuntimeException或其子类异常时,程序就该中断,
不该处理。
在函数后面声明抛出的异常如果是RuntimeException或其子类,
调用者不用处理,编译照样通过。
运行时异常通常都是接收用户传过来的参数,是由于用户传了
不合理的数据造成的异常,所以程序该停下来修改数据.
异常的分类:
1:编译时检测的异常   非RuntimeException或其子类
2:编译时不检测的异常 RuntimeException或其子类
学习 知识 需要严谨的态度。你可以不聪明,但是不可以不努力.  只有坚持到最后的人,才能笑的最好。
总结:
面向对象中,我们 与异常 会 形影不离的。异常提高了代码的健壮性。从异常的内部原理,我们能感悟
到一个道理:总有人在默默的奉献(jvm!). 如果,我们一开始就处理了异常,对于我们的代码是很好的交互性。
一般会在 调用的时候直接处理。 throws  是不负责的表现。JVM 中的异常又是有限的,所以,有的时候我们
需要自定义异常,自定义的异常当然要继承 父类Exception。 在处理多重继承的catch 的时候,我们要从小异常下手。这样会更有效的。
 
java 之 -----------------   异常 处理,布布扣,bubuko.com
java 之 -----------------   异常 处理
标签:throws   throw   trycatchfinally   catch多重继承   
原文地址:http://blog.csdn.net/love_javc_you/article/details/38235699