首页 > 代码库 > java 之 ----------------- 异常 处理

java 之 ----------------- 异常 处理

java 之 -----------------   异常 处理 知识点小结

异常: 程序在运行时出现的不正常情况
异常 会提前终止程序。
异常 提高了我们设计的程序的健壮性

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 的时候,我们要从小异常下手。这样会更有效的。