《day13--异常的进阶和包的使用》

 //101-finally的使用&102-finally的使用场景
 /*
 需求：有一些特定的代码，无论异常是否发生，都需要执行，
 因为异常会引发程序的跳转，导致有些语句执行不到，无法满足这个需求。
 异常捕获处理时，java提供了解决方案。
 try catch finally.
 finally:就是解决这个问题的。这个代码块中存放的代码都是一定会被执行的。

 应用场景：
 定义一个功能，往数据库中添加数据。
 void add(Data data)throws NoAddException
 {
     //1,连接数据库。
     try{
     //2，添加数据。//很有可能在添加数据时，发生了异常情况，很可能发生了异常情况：throw new SQLException();程序就会跳转就执行不到断开连接，
                     //而断开连接必须要执行，因为不执行断开功能，
                     //那么连接资源会浪费。无论是否发生问题都需要执行断开连接的动作，从而释放资源。
     }catch(sqlException e)
     {
         //解决数据库的问题。
         //同时将问题告诉调用者。
         //throw new NotAddException();
     }
     finally
     {
         //3，断开连接。
     }

 //总结：finally到底什么时候用，
 只要程序中使用到了具体的资源(数据库，IO资源，网络连接（socket）等）
 需要释放，都必须定义在finally中。你这定义程序时，只要问题发生与否，
 指定程序都需要执行时，就定义在finally里面。
 }
 */
 class NoShowException extends Exception
 {
     NoShowException()
     {
         super();
     }
     NoShowException(String message)
     {
         super(message);
     }
 }

 class Demo
 {
     void show(int num)throws NoShowException
     {
         if(num<0)
             throw new NoShowException(num+",数值是非法的");
         System.out.println("show run...."+num);
     }
 }
 class ExceptionDemo10
 {
     public static void main(String[] args)
     {
         /*
         Demo d = new Demo();
         //因为调用到了声明异常的show方法，所以调用者要给出处理的方式，
         //要么继续声明，要么捕获。
         try
         {
             d.show(-5);

         }
         catch (NoShowException ex)
         {
             System.out.println(ex.toString());//打印的是异常名称+异常信息。
             //如果异常发生，处理完毕后，希望功能结束。
             return;

             //注意：有一种情况发生，finally也不执行，
 //            System.exit(0);//退出jvm.
         }
         finally
         {
             System.out.println("hello");
         }
         System.out.println("over");
         */
         Test t = new Test();
         int num = t.show(-4);
         System.out.println("num="+num);
     }
 }

 class Test
 {
     int show(int num)
     {
         try
         {
             if(num<0)
                 throw new RuntimeException();
             return 4;
         }
         catch (Exception e)
         {
             System.out.println(e.toString());
             return 200;
         }
         finally
         {
             System.out.println("finally run");
             return 100;
         }
     }
 }

 //103-trycatchfinally的组合方式。
 /*
 try catch finally几种组合方式；

 1，
 try catch: 对代码进行异常检测，并对检测的异常传递给catch处理。
             异常捕获处理。

 void show()//不用throws
 {
     try{
     throw new Exception();
     }catch(Exception e)
     {

     }
 }
 2
 try finally:  对代码进行异常检测，检测到异常后因为没有catch所以一样会被默认jvm抛出。
               异常是没有捕获处理的。但是功能所开启的资源需要进行关闭，所以有finally.
               关闭资源。

 void show()//需要throws
 {
     try{
     throw new Exception();
     }finally
     {

     }
 }

 3，
 try catch finally
 检测异常，并传递给catch处理，并定于资源释放，

 4，try catch1 catch2 catch3....
 */

 class
 {
     public static void main(String[] args)
     {
         System.out.println("Hello World!");
     }
 }

 //104-异常在覆盖中的细节。
 /*
 异常在继承或者实现中的使用细节：
 1,子类在覆盖父类方法时，如果父类的方法声明异常，
 子类只能声明父类异常或者该异常的子类，或者不声明。
 2，当父类方法声明多个异常时，子类覆盖时只能声明多个异常的子集。
 3，当被覆盖的方法没有异常声明时，子类覆盖时是无法声明异常的。
     举例：父类存在这种情况，接口也有这种情况。
     问题：接口中没有声明异常，而实现的子类覆盖方法时却发生了异常，怎么办？
         无法进行throws声明，只能进行catch的捕获。万一问题处理不了呢？可以在
         catch中继续throw抛出，但是只能将异常转换成RuntimeException抛出。

     Interface Inter
     {
         public void show();
     }
     class Demo implements Inter
     {
         public void show()//不能进行throws声明。把编译时异常转换成运行时异常。
         {
             try{
             throw new Exception();
             }catch(Exception e)
             {
                 code..//自己的处理方式。
                 //不能处理时，转换。
                 throw new RuntimeException("");//告知调用者问题所在。
             }
         }
     }
 Exception
     |-AException
         |-AAException
     |-BException

 */
 class AException extends Exception
 {
 }
 class BExcepiton extends Exception
 {
 }
 class AAExcepiton extends AException
 {
 }

 class Fu
 {
     void show()throws AException
     {

     }
 }

 class Tool
 {
     void method(Fu f)
     {
         try
         {
             f.show();
         }
         catch (AException ex)//AException ex = new AAException();
         {
         }

     }
 }
 Tool t = new Tool();
 //t.method(new Fu());
 t.method(new Zi());

 class Zi extends Fu
 {
     void show()throws AAException
     {

     }
 }

 class ExceptionDemo12
 {
     public static void main(String[] args)
     {
         Zi z = new Zi();
         try
         {
             z.show();
         }
         catch (AException e)
         {
         }
     }
 }

 package mypack;//包名中的所有字母都小写。
 /*
 对于多个类为了便于管理（类的同名情况），所以Java提供了解决方案。
 包机制：落实到操作系统上，就是文件夹。对Java的文件进行分文件管理。

 包的定义：使用关键字package。

 包的作用：
     1，对类文件进行管理。
     2，给类文件提供了名称空间。

 对带有package定义的java文件进行指定类文件位置的编译方式。
 javac -d 目录 源文件

 如果目录选择的不是当前目录，想要访问包中类。
 通过设置classpath.  set classpath=包所在的父目录

 =====================================================
 包与包之间的访问：
 PackageDemo1.java:24: 错误: 找不到符号
                 DemoA d = new DemoA();
                 ^
   符号:   类 DemoA
   位置: 类 PackageDemo1
 PackageDemo1.java:24: 错误: 找不到符号
                 DemoA d = new DemoA();
                               ^
   符号:   类 DemoA
   位置: 类 PackageDemo1

 原因是：类名写错，有了包的类，类名：包名.类名。这才是类的全名称。
 解决：使用DemoA，必须写packa.DemoA.

 ================================================================
 PackageDemo1.java:41: 错误: 程序包packa不存在
                 packa.DemoA d = new packa.DemoA();
                      ^
 PackageDemo1.java:41: 错误: 程序包packa不存在
                 packa.DemoA d = new packa.DemoA();
                                          ^
 2 个错误

 原因：packa这个包没有找到，在当前目录下。
 解决：应该告诉jvm这个程序包的位置. set classpath.

 ====================================================================
 PackageDemo1.java:41: 错误: DemoA在packa中不是公共的; 无法从外部程序包中对其进行访问
                 packa.DemoA d = new packa.DemoA();
                      ^
 PackageDemo1.java:41: 错误: DemoA在packa中不是公共的; 无法从外部程序包中对其进行访问
                 packa.DemoA d = new packa.DemoA();
                                          ^
 2 个错误

 原因：DemoA这个类在packa这个包中权限不够。
 解决：提升DemoA的权限。提升到哪个权限。到public.

 ============================================================================
 PackageDemo1.java:66: 错误: show()在DemoA中不是公共的; 无法从外部程序包中对其进行访问
                 d.show();
                  ^
 1 个错误

 原因：show方法的权限不够，
 解决：show用public修饰。

 总结；
 包与包之间的类在访问时，被访问的类以及成员都必须被public修饰。

 注意；被public修饰的类或者接口，所属的java文件名必须和类或者接口名称一致。

 包与包之间继承，父类可以给其他包中的子类提供一个特殊的权限protected,只有
 继承为子类后，才可以访问的权限。

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

 包与包之中访问只有两种权限可以用，public  protected（该权限只能给不同包中的子类使用。）

 =================================================================================
 包的出现导致类的名称过长，导致书写不方便，咋办？
 可以通过关键字来解决，import 导入。
 import作用简化类名书写。省略包名。

 特殊情况一：
 packa\packaa\DemoAA
      \DemoA.class
 import packa.*;//仅仅指的是使用的类所属的包是packa下的。不会导入packa中子包中的类。
 如果要使用DemoAA
 import packa.packaa.*;
 new DemoAA();

 特殊情况二：//不同包中有了相同名称的类。使用该类时，必须指定包名。
 packa\Demo.class
 packb\Demo.class

 import packa.Demo;
 import packb.Demo;

 new packa.Demo();
 */
 //import packa.DemoA;    //import packa.*不建议这样写。
 import packa.*;

 class PackageDemo1
 {
     public static void main(String[] args)
     {
     //    packa.DemoA d = new packa.DemoA();
         DemoA d = new DemoA();
         d.show();

         //packfu.DemoFu d1 = new packfu.DemoFu();
         //d1.showFu();
         System.out.println("Hello World!");
     }
 }

 package packa;

 public class DemoA extends packfu.DemoFu
 {
     public void show()
     {
         showFu();
         System.out.println("demoa show run");
     }
 }

 package packfu;
 public class DemoFu
 {
     /*public*/protected/*保护*/ void showFu()
     {
         System.out.println("demofu show run");
     }
 }

 /*
 Jar包：java中的压缩包。

 直接将jar包导入到classpath路径中即可。

 */
 package pack;

 class  JarDemo
 {
     public static void main(String[] args)
     {
         System.out.println("Hello jar!");
     }
 }

 //day13/pack/JarDemo.class ---jar--->day13/haha.jar/pack/JarDemo.class