《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