throw 和 throws的区别
throw是是用在函数上，而throws是使用在函数内
throw后面跟的是异常对象，而throws跟的是异常类可以 多个

对异常的分类：
1.编译时被检测到的异常。
  （值得去处理的异常，或者是希望得到调用者处理，并不影响运算意向）
2.编译时不被检测到的异常（运行时异常RuntimeException以及他的子类）
  （不值得去处理的，交给jvm去处理，出现这种异常假如处理的会影藏异常影响了
  运算意向，eg ：角标越界、内存溢出、除0运算、空指针）

2. 如果父类方法抛出多个异常，那么子类只能抛出父类异常的子集。

3. 如果父类或接口的方法中没有异常，那么子类覆盖方法时，也不能抛只能自行处理。

class  Demo
{
     public static void main(String[] args)
     {
          try{
               Fu f = new Zi();
               f.method1();
          }catch(AException e){
               /*
               只能处理已知的异常，对于未知的异常不能处理，
               因为在代码编写时，只会处理父类的异常
               对于未知的子类中存在的异常在早先写好的异常处理的代码是不包括处理子类的异常。    
               */
          }
     }
}
class Fu{
     public void method1() throws AException{
          throw new AException();
     }
}
class Zi{
     public void method1() throws CException,BException{
          throw new BException();
     }
}
Exception
    AException
        CException
    BException

总结：

     异常：

           是什么？是对问题的描述，将问题进行对象的封装。

     异常体系结构：

          Throwable

               |--Error

               |--Exception

                    |--RuntimeException

     异常体系的特点：异常体系中的所有类以及建立的对象都具有可抛性，

                  也就是说可以被throw 和 throws关键字所操作。只有异常体系具备这个特点。

     throw 和 throws的区别：

          throws是定义在函数上，用于抛出异常类，可一次性抛出多个异常。

          throw是定义在函数内，用于抛出异常对象。

          当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，否则会编译失败

          注意：RuntimeException除外，也就是说，函数内如果抛出了RuntimeEception异常，

          可以不用声明。

          如果函数声明了异常，调用者需要进行处理，处理方法：try 或者 throws

     异常有两种：

          编译时被检测的异常

               该编译时，如果没有处理，编译会失败，该异常被标识，代表这可以被处理

          运行时异常

               编译时，不需要处理，编译不会进行检查

               该异常的发生，建议不处理，让程序停止，对代码进行修正

     注意：

          finally中定义的关闭资源的代码，因为资源必须释放。

          但是System.exit(0);finally中的代码不会被执行。

     自定义异常：

          定义继承exception或者runtimeexception

               1.为了让该自定义类具备可抛性。

               2.让该类具备操作异常的共性方法。

          当要定义自定义异常的信息时，可以适应父类已经定义好的功能。

          异常信息传递给父类的构造方法。

          

          按照java的面向对象的思想，将程序中出现的特有问题进行封装 。

     异常的好处：

          1. 将问题进行了封装

          2. 将正常流程代码和问题处理代码分离，方便阅读。

     异常的处理原则：

          1. 处理方式有两种： try 和 catch

          2. 调用到排除异常的功能时，抛出多少个异常，就去处理几个

          3. 多个catch，父类的catch被放到继承该异常的下面。

          4. catch内，需要定义针对性的处理方式，不要简单的定义printStackTrace

          5.当捕获的异常，本功能处理不了时，可以继续在catch中抛出。

          6. 如果该异常处理不了，但并不属于该功能的相关异常。

                可以将异常转化后，再抛出和该功能相关的异常。

          7. 或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去。

               当调用者知道，并处理。也可以将捕获的异常处理后，转换为新异常。抛出

               eg： 汇款的例子    先处理，再告知调用者（通过异常传递信息）

     异常的注意事项：

          1.在子父类覆盖时：

               1. 子类抛出的异常必须是父类异常的子类或者子集。

               2. 如果父类或者接口没有异常抛出时，子类覆盖出现异常必须自行处理（try）

               

编译 javac -d 编译路径（后存放的位置） 文件.java    

执行 java 包名.文件

jar.exe  打jar包

 jar -cvfm classse.jar（归档文件名） 文件1 文件2 ..