传智播客——毕向东25--第10天总结-9

1.异常 finally：
finally
{一定会被执行的代码块 }
public void method()throws NoException
{
    连接数据库
    数据库操作：//throw new NoException();
    关闭数据库：//关闭资源

    try
    {
        连接数据库
        数据操作
    }
    catch (SQLException e)
    {
        数据库的异常处理；
        throw new NoException();
    }
 finally
 {
        关闭数据库；
 }
}
2.异常处理的其他语句格式：
 a.try....catch
 b.try....catch....finally
 c.try....finally
 注意：catch是用于处理异常，如果没有catch就代表异常没有被处理过，必须在函数上声明；（RuntimeException异常类除外）
 
 3.异常覆盖时的特点：
   a.子类在覆盖父类时，如果父类的方法跑出异常，那么子类的覆盖方法，只能跑出父类的异常或该异常的子类
   b.如果父类跑出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集
   c.如果父类或接口的方法中没有异常抛出，那么子类在覆盖方法时也不可以跑出异常、如果子类方法发生了异常，就必须要进行try处理，绝对不能抛。
  class AException extends Exception
  {......}
  class BException extends Exception
  {......}
  class CException extends Exception
  {......}
  class Fu
  {
   void show()throws AException
   {......}
  }
  class Test
  {
   void function(Fu f)
   {
    try
    {
         f.show();
    }
    catch (AException)
    {......}
   }
  }
  class Zi extends Fu
  {
       void show()throws AException
   {......}
  }
  class Demo
  {
       public static void main(String[] args)
       {
           Test t=new Test();
          t.function(new Zi());
       }
  }
异常总结：
  a.异常体系：
      Throwable
      |---Error
   |---Exception
           |---RuntimeException
   b.throw和throws的用法区别：
      throw定义在函数内，用于抛出异常对象
   throws定义在函数上，用于抛出异常类，可以抛出多个，用逗号个隔开
   c.当函数内容有throw抛出异常对象，并且未进行try处理时，必须要在函数上声明，否则编译失败；（RuntimeException除外）
   d.异常处理语句：
   try
   {
       需要被检测的代码；
   }
   catch (异常类 变量)
   {
    处理异常的代码；
   }
   finally
   {
    一定会执行的代码；
   }
  注意：finally有一种情况不会执行：System.exit(0);
  e.自定义异常类：
  定义类继承Exception或者RuntimeException
  可用父类定义好的构造函数
    class MyException extends Exception
    {
         MyException (String message)
         {
               super(message);
         }
    }
 f.遗产的处理原则：
      1.处理方法：try和throws
   2.调用到跑出异常功能时，跑出几个就处理几个

void test()throws BException   //声明B异常
{
      try
      {
             throw new AException();
      }
     catch (AException e)
     {
            throw new BException(); //抛出B异常
     }
}

4.包 package
  包名所有字母小写
  关键字：package pack；
  package pack；
  class PackageDemo
  {
         public static void main(String[] args)
          {
              System.out.println("Hello PackageDemo");
          }
  }

  >javac -d c:\myclass PackageDemo.java
  >java pack.PackageDemo
 
 包与包之间的访问
 protected：受保护的（只能子父类之间）

package pack;
class PackageDemo
{
        public static void main(String[] args)
         {
             packa.DemoA d=new Packa.DemoA();
            d.show();
         }
}
package packa;
public class DemoA extends packb.DemoB
{
      public void show()
      {
           System.out.println("DemoA run");
           method();
     }
}
package packb;
public class DemoB
{
       protected void method()
       {
            System.out.println("DemoB run")
       }
}
编译时从调用者开始编译：DemoB--DemoA--Demo

                      public      protected      default      private
同一个类中       ok             ok              ok              ok                 
同一个包中       ok             ok              ok                           
子类                  ok             ok                                  
不同包中           ok

导入import：
      为了简化类名的书写，使用一个关键字，import
例：import packb.*;//import 导入的是packb包中的类

创建jar包：
  >jar -cf hh.jar packa packb
查看jar包中的文件：
>jar -tf hh.jar 
>jar -tf a.jar   >c:\1.txt   //导到>c:\1.txt中