最近做IO流的练习，总是忘记处理异常，各种头疼，抛啊，踹啊，帮我说下异常的情况和用法吧，谢谢

函数内抛出异常，函数上就要声明；函数上不声明，调用该函数时就try。
注意：RuntimeException及其子类除外。

1、异常：不正常。
        Java在运行时期出现的不正常情况。

2、Java按照面向对象的思想对问题进行描述和封装。
   将问题变成对象，里面包含着问题的名称，信息以及位置等。


3、常见的问题有两种：
        一种是可处理的，
        一种是通常不处理的。
    可以处理的问题都向上抽取到了一个父类中：Exception(异常)
    不可以处理的问题向上抽取到一个父类中：Error(错误)：通常都是由jvm或者系统抛出的严重问题。碰到Error，修正代码。

4、问题都有一些共性，不断的向上抽取。就形成了体系。
   而无论是错误还是异常都有名称，信息，位置等共性内容。
   向上抽取到了Throwable(可抛)。
   异常的体系：
   Throwable
          |--Error
          |--Exception
              |—-RuntimeException(可以不要声明抛出异常)
5、问题的发生是可以抛出的，所以他们的父类是Throwable。
    而且这个体系和其他体系都有不同。是因为这个体系中的类以及其对象都具备着可抛性。
6、什么是可抛性呢？
   就可以被throw或者throws关键字所操作。

7、异常分两种：
        一种是编译时需要被检测的异常。Exception及其子类。
                可以进行针对性的处理。
    一种是编译时不被检测的异常。Exception中的一个特殊子类体系RuntimeException(运行时异常)
                通常不编写处理方式，直接让程序停止，为了让调用者进行代码的修正。
    意味着：我们在自定义异常的时候，
                可以继承Exception，也可以继承RuntimeException。



8、对于针对性处理。
    可以通过java提供的指定的处理代码完成。
   try catch finally

    （1）try{}catch(异常类 变量名){ 异常的处理代码。}finally{ 一定会被执行的代码。}
    （2）另一种没有处理异常但是抛出异常和可以强制关闭资源try{}finally{要关闭的资源}
9、异常处理的基本原则:
   在catch异常时，对方功能声明的是什么异常，catch里就处理什么异常，这样处理才具备针对性。
   如果对方函数声明多个异常，那么就必须有多个catch分别对这些异常进行处理。
   如果出现多catch，父类的catch放在最下面。



10、异常抛出的基本原则：
   功能中用throw关键字抛出了异常，如果没有被catch处理，就必须用throws关键字在函数上进行声明。
   注意：RuntimeException及其子类除外，也就说，
   功能中throw抛出的是RuntimeException和其子类对象，函数上可以不用throws进行声明。

    注意：函数上用throws进行声明的原因：是为了让调用者在调用该功能时，进行定义预先的处理方式。
11、当异常引用于继承时
     如果父类的方法没有声明抛出异常子类必须不要抛出异常，但是如果子类抛出只能自己解决，可以声明为RuntimeException直接结束程序。
         如果父类抛出异常子类只能抛出父类异常的子集。
         
         抛出异常的示例：

         class FuShuException extends Exception
{
        FuShuException()
        {
                super();
        }
        FuShuException(String message)
        {
                super(message);
        }
}

class Demo
{
        int div(int a,int b)throws FuShuException//在函数上用throws关键字标示有可能有问题。
                                                                                        //这样的好处在于可以让调用者预先进行问题的处理。
        {
                if(b==0)
                        throw new ArithmeticException("哎呀！除数为零了。完了！");//抛出的是java已有的异常的对象。
                if(b<0)
                        throw new FuShuException("除数不可以是负数：错误的负数值时："+b);//抛出了自定义异常对象。
                return a/b;
        }
}
class ExceptionDemo2
{
        public static void main(String[] args)throws  FuShuException//主函数调用了有异常的方法，
                                                                                                                                //处理方式是声明继续抛出。抛给了jvm
        {
                Demo d = new Demo();
                int num = d.div(4,-1);
                System.out.println("num="+num);
                System.out.println("Hello World!");
        }
}

异常的用法并不是很难，关键在于记住这几个用法。
最基础的就是

1. try
   
2. {
   
3. 有可能产生异常的一句
   
4. }catch(捕获的异常对象)
   
5. {
   
6. 处理语句
   
7. }finally
   
8. {
   
9. 不管有无异常都要执行的语句
   
10. }

复制代码

以上代码就是捕获异常的基本手法。
其中我感觉有难点的地方就在于这个处理语句上。
处理语句你既可以简单的打印一句话也可以用throw抛出一个异常等等。
如果用throw抛出异常的话又要说道两个关键字：throw和throws。

1）throws只能出现在方法函数头；而throw只能出现在函数体；   
2）throws表示出现异常的一种可能性，并不一定会发生这些异常；

下边通过一个简单的例子进行说明：

1. static void doA() throws Exception1, Exception3 {
   
2. try {
   
3. ……
   
4. } catch(Exception1 e) {
   
5. throw e;
   
6. } catch(Exception2 e) {
   
7. System.out.println("出错了");
   
8. }
   
9. if (a != b)
   
10. throw new Exception3("自定义异常");
    
11. }
    
12. 
    
13. public static void main(String[] args) throws Exception
    
14. {
    
15. doA();
    
16. }
    

复制代码

说明：
代码块……中可能产生异常Exception1、Exception2和Exception3。
如果产生Exception1异常，则捕捉了之后抛出由该方法的调用者去做处理；
如果产生Exception2异常，则该方法自己做了处理(打印出了说出错了)，所以该方法就不会再向外抛出Exception2异常了，
void doA() throws Exception1,,Excpetion3里面的Exception2也就不用写了；
而Exception3异常是该方法的某段逻辑出错，程序员自己作了处理在该段逻辑错误的情况下抛出异常Exception3，则调用者也需要处理。

在主函数中又调用了doA();方法，所以doA()方法中用throws抛出的异常应该在主函数中进行处理，如果主函数不进行处理，可以继续上抛，
将异常抛给Java虚拟机，这样让虚拟机进行处理。

但是如果异常是RuntimeException及其子类的话，不用写throws就可以，因为如果发生此类异常程序将会立即停止运行。