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

  1 //101-finally的使用&102-finally的使用场景
  2 /*
  3 需求：有一些特定的代码，无论异常是否发生，都需要执行，
  4 因为异常会引发程序的跳转，导致有些语句执行不到，无法满足这个需求。
  5 异常捕获处理时，java提供了解决方案。
  6 try catch finally.
  7 finally:就是解决这个问题的。这个代码块中存放的代码都是一定会被执行的。
  8 
  9 应用场景：
 10 定义一个功能，往数据库中添加数据。
 11 void add(Data data)throws NoAddException
 12 {
 13     //1,连接数据库。
 14     try{
 15     //2，添加数据。//很有可能在添加数据时，发生了异常情况，很可能发生了异常情况：throw new SQLException();程序就会跳转就执行不到断开连接，
 16                     //而断开连接必须要执行，因为不执行断开功能，
 17                     //那么连接资源会浪费。无论是否发生问题都需要执行断开连接的动作，从而释放资源。
 18     }catch(sqlException e)
 19     {
 20         //解决数据库的问题。
 21         //同时将问题告诉调用者。
 22         //throw new NotAddException();
 23     }
 24     finally
 25     {
 26         //3，断开连接。
 27     }
 28 
 29 //总结：finally到底什么时候用，
 30 只要程序中使用到了具体的资源(数据库，IO资源，网络连接（socket）等）
 31 需要释放，都必须定义在finally中。你这定义程序时，只要问题发生与否，
 32 指定程序都需要执行时，就定义在finally里面。
 33 }
 34 */
 35 class NoShowException extends Exception
 36 {
 37     NoShowException()
 38     {
 39         super();
 40     }
 41     NoShowException(String message)
 42     {
 43         super(message);
 44     }
 45 }
 46 
 47 class Demo
 48 {
 49     void show(int num)throws NoShowException
 50     {
 51         if(num<0)
 52             throw new NoShowException(num+",数值是非法的");
 53         System.out.println("show run...."+num);
 54     }
 55 }
 56 class ExceptionDemo10
 57 {
 58     public static void main(String[] args) 
 59     {
 60         /*
 61         Demo d = new Demo();
 62         //因为调用到了声明异常的show方法，所以调用者要给出处理的方式，
 63         //要么继续声明，要么捕获。
 64         try
 65         {
 66             d.show(-5);
 67 
 68             
 69         }
 70         catch (NoShowException ex)
 71         {
 72             System.out.println(ex.toString());//打印的是异常名称+异常信息。
 73             //如果异常发生，处理完毕后，希望功能结束。
 74             return;
 75 
 76 
 77             //注意：有一种情况发生，finally也不执行，
 78 //            System.exit(0);//退出jvm.
 79         }
 80         finally
 81         {
 82             System.out.println("hello");
 83         }
 84         System.out.println("over");
 85         */
 86         Test t = new Test();
 87         int num = t.show(-4);
 88         System.out.println("num="+num);
 89     }
 90 }
 91 
 92 class Test
 93 {
 94     int show(int num)
 95     {
 96         try
 97         {
 98             if(num<0)
 99                 throw new RuntimeException();
100             return 4; 
101         }
102         catch (Exception e)
103         {
104             System.out.println(e.toString());
105             return 200;
106         }
107         finally
108         {
109             System.out.println("finally run");
110             return 100;
111         }    
112     }
113 }

 1 //103-trycatchfinally的组合方式。
 2 /*
 3 try catch finally几种组合方式；
 4 
 5 1，
 6 try catch: 对代码进行异常检测，并对检测的异常传递给catch处理。
 7             异常捕获处理。
 8 
 9 void show()//不用throws
10 {
11     try{
12     throw new Exception();
13     }catch(Exception e)
14     {
15     
16     }
17 }
18 2
19 try finally:  对代码进行异常检测，检测到异常后因为没有catch所以一样会被默认jvm抛出。
20               异常是没有捕获处理的。但是功能所开启的资源需要进行关闭，所以有finally.
21               关闭资源。
22 
23 
24 void show()//需要throws
25 {
26     try{
27     throw new Exception();
28     }finally
29     {
30     
31     }
32 }
33 
34 3，
35 try catch finally
36 检测异常，并传递给catch处理，并定于资源释放，
37 
38 4，try catch1 catch2 catch3....
39 */
40 
41 class  
42 {
43     public static void main(String[] args) 
44     {
45         System.out.println("Hello World!");
46     }
47 }

 1 //104-异常在覆盖中的细节。
 2 /*
 3 异常在继承或者实现中的使用细节：
 4 1,子类在覆盖父类方法时，如果父类的方法声明异常，
 5 子类只能声明父类异常或者该异常的子类，或者不声明。
 6 2，当父类方法声明多个异常时，子类覆盖时只能声明多个异常的子集。
 7 3，当被覆盖的方法没有异常声明时，子类覆盖时是无法声明异常的。
 8     举例：父类存在这种情况，接口也有这种情况。
 9     问题：接口中没有声明异常，而实现的子类覆盖方法时却发生了异常，怎么办？
10         无法进行throws声明，只能进行catch的捕获。万一问题处理不了呢？可以在
11         catch中继续throw抛出，但是只能将异常转换成RuntimeException抛出。
12 
13     Interface Inter
14     {
15         public void show();
16     }
17     class Demo implements Inter
18     {
19         public void show()//不能进行throws声明。把编译时异常转换成运行时异常。
20         {
21             try{
22             throw new Exception();
23             }catch(Exception e)
24             {
25                 code..//自己的处理方式。
26                 //不能处理时，转换。
27                 throw new RuntimeException("");//告知调用者问题所在。
28             }
29         }
30     }
31 Exception
32     |-AException
33         |-AAException
34     |-BException
35 
36 
37 
38 */
39 class AException extends Exception
40 {
41 }
42 class BExcepiton extends Exception
43 {
44 }
45 class AAExcepiton extends AException
46 {
47 }
48 
49 
50 class Fu
51 {
52     void show()throws AException
53     {
54 
55     }
56 }
57 
58 class Tool
59 {
60     void method(Fu f)
61     {
62         try
63         {
64             f.show();
65         }
66         catch (AException ex)//AException ex = new AAException();
67         {
68         }
69 
70     }
71 }
72 Tool t = new Tool();
73 //t.method(new Fu());
74 t.method(new Zi());
75 
76 
77 class Zi extends Fu
78 {
79     void show()throws AAException
80     {
81 
82     }
83 }
84 
85 class ExceptionDemo12 
86 {
87     public static void main(String[] args) 
88     {
89         Zi z = new Zi();
90         try
91         {
92             z.show();
93         }
94         catch (AException e)
95         {
96         }
97     }
98 }

  1 package mypack;//包名中的所有字母都小写。
  2 /*
  3 对于多个类为了便于管理（类的同名情况），所以Java提供了解决方案。
  4 包机制：落实到操作系统上，就是文件夹。对Java的文件进行分文件管理。
  5 
  6 包的定义：使用关键字package。
  7 
  8 包的作用：
  9     1，对类文件进行管理。
 10     2，给类文件提供了名称空间。
 11 
 12 对带有package定义的java文件进行指定类文件位置的编译方式。
 13 javac -d 目录 源文件
 14 
 15 如果目录选择的不是当前目录，想要访问包中类。
 16 通过设置classpath.  set classpath=包所在的父目录
 17 
 18 =====================================================
 19 包与包之间的访问：
 20 PackageDemo1.java:24: 错误: 找不到符号
 21                 DemoA d = new DemoA();
 22                 ^
 23   符号:   类 DemoA
 24   位置: 类 PackageDemo1
 25 PackageDemo1.java:24: 错误: 找不到符号
 26                 DemoA d = new DemoA();
 27                               ^
 28   符号:   类 DemoA
 29   位置: 类 PackageDemo1
 30 
 31 
 32 原因是：类名写错，有了包的类，类名：包名.类名。这才是类的全名称。
 33 解决：使用DemoA，必须写packa.DemoA.
 34 
 35 ================================================================
 36 PackageDemo1.java:41: 错误: 程序包packa不存在
 37                 packa.DemoA d = new packa.DemoA();
 38                      ^
 39 PackageDemo1.java:41: 错误: 程序包packa不存在
 40                 packa.DemoA d = new packa.DemoA();
 41                                          ^
 42 2 个错误
 43 
 44 原因：packa这个包没有找到，在当前目录下。
 45 解决：应该告诉jvm这个程序包的位置. set classpath.
 46 
 47 ====================================================================
 48 PackageDemo1.java:41: 错误: DemoA在packa中不是公共的; 无法从外部程序包中对其进行访问
 49                 packa.DemoA d = new packa.DemoA();
 50                      ^
 51 PackageDemo1.java:41: 错误: DemoA在packa中不是公共的; 无法从外部程序包中对其进行访问
 52                 packa.DemoA d = new packa.DemoA();
 53                                          ^
 54 2 个错误
 55 
 56 原因：DemoA这个类在packa这个包中权限不够。
 57 解决：提升DemoA的权限。提升到哪个权限。到public.
 58 
 59 ============================================================================
 60 PackageDemo1.java:66: 错误: show()在DemoA中不是公共的; 无法从外部程序包中对其进行访问
 61                 d.show();
 62                  ^
 63 1 个错误
 64 
 65 原因：show方法的权限不够，
 66 解决：show用public修饰。
 67 
 68 总结；
 69 包与包之间的类在访问时，被访问的类以及成员都必须被public修饰。
 70 
 71 注意；被public修饰的类或者接口，所属的java文件名必须和类或者接口名称一致。
 72 
 73 包与包之间继承，父类可以给其他包中的子类提供一个特殊的权限protected,只有
 74 继承为子类后，才可以访问的权限。
 75 
 76             public        protected        default        private
 77 一个类中      ok           ok              ok          ok
 78 一个包中      ok           ok              ok          
 79 子类中        ok           ok
 80 不同包中      ok
 81 
 82 包与包之中访问只有两种权限可以用，public  protected（该权限只能给不同包中的子类使用。）
 83 
 84 =================================================================================
 85 包的出现导致类的名称过长，导致书写不方便，咋办？
 86 可以通过关键字来解决，import 导入。
 87 import作用简化类名书写。省略包名。
 88 
 89 特殊情况一：
 90 packa\packaa\DemoAA
 91      \DemoA.class
 92 import packa.*;//仅仅指的是使用的类所属的包是packa下的。不会导入packa中子包中的类。
 93 如果要使用DemoAA
 94 import packa.packaa.*;
 95 new DemoAA();
 96 
 97 特殊情况二：//不同包中有了相同名称的类。使用该类时，必须指定包名。
 98 packa\Demo.class
 99 packb\Demo.class
100 
101 import packa.Demo;
102 import packb.Demo;
103 
104 new packa.Demo();
105 */
106 //import packa.DemoA;    //import packa.*不建议这样写。
107 import packa.*;
108 
109 class PackageDemo1
110 {
111     public static void main(String[] args) 
112     {
113     //    packa.DemoA d = new packa.DemoA();
114         DemoA d = new DemoA();
115         d.show();
116 
117         //packfu.DemoFu d1 = new packfu.DemoFu();
118         //d1.showFu();
119         System.out.println("Hello World!");
120     }
121 }

 1 package packa;
 2 
 3 public class DemoA extends packfu.DemoFu
 4 {
 5     public void show()
 6     {
 7         showFu();
 8         System.out.println("demoa show run");
 9     }
10 }

1 package packfu;
2 public class DemoFu 
3 {
4     /*public*/protected/*保护*/ void showFu()
5     {
6         System.out.println("demofu show run");
7     }
8 }

 1 /*
 2 Jar包：java中的压缩包。
 3 
 4 直接将jar包导入到classpath路径中即可。
 5 
 6 */
 7 package pack;
 8 
 9 class  JarDemo
10 {
11     public static void main(String[] args) 
12     {
13         System.out.println("Hello jar!");
14     }
15 }
16 
17 //day13/pack/JarDemo.class ---jar--->day13/haha.jar/pack/JarDemo.class