JAVA学习===throw以及try,catch结构

throw 人为编码抛出异常
    - new RuntimeException()
    - new RuntimeException("异常的提示信息");
    
throws--用在方法签名中，用于声明该方法可能抛出的异常，要求谁调用谁处理这个异常。
主方法上也可以使用throws抛出。如果在主方法上使用了throws抛出，就表示在主方法里面
可以不用强制性进行异常处理，如果出现了异常，就交给JVM进行默认处理，则此时会导致程
序中断执行。
    public void pp() throws Exception{}
    
try/catch结构的问题：一个try结构后面可以跟无数个catch结构
    try {
            ss = sc.nextLine();
            age = Integer.parseInt(ss);
    } catch (NumberFormatException e) {
    //异常类型的判定不是最佳匹配，而是逐一匹配，一旦匹配成功，则不会继续进行匹配
    //必须小在前大在后
            System.out.println(ss);
            System.out.println("数据格式错误!");
        } catch (Exception e) {
            System.out.println("其它问题!");
        }
        
    允许在catch中声明多个类型
        注意：多个异常类型不要出现父子异常，如果需要写父不写子即可
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int age = -1;
        String ss = null;
        try {
            ss = br.readLine();
            age = Integer.parseInt(ss);
        } catch (NumberFormatException | IOException e) {
            System.out.println("其它问题!");
        }
        System.out.println(age);
        
强调：catch只匹配成功一次即可，注意不是最佳匹配

catch结构中的e是用于指代陷阱代码中的异常对象
- getMessage():String用于获取有关异常事件的信息,一般是异常信息的描述，
例如【For input string: "123.456"】

- toString():String，输出格式为【java.lang.NumberFormatException:
For input string: "123.456"】

- printStackTrace():void用来跟踪异常事件发生时执行堆栈的内容，注意：这
里的输出默认采用错误流System.err进行输出，如果还使用了System.out进行输
出，则不能保证显示顺序

捕获异常后允许初步处理后，继续向上抛出
try{
    int k=0;
    system.out.println(10/k);
} catch(ArithmeticException e){
    System.out.println(e);
    e=new ArithmeticException("就是不告诉你");  //注意按照Java变量的规则，这里的类型不能变，所以可以new当前类型，也可以子类型
    throw e;
}catch(NullPointerException e){
    System.out.println(e);
}

但是使用多异常时则不能修改e对象
try{
    int k=0;
    System.out.println(10/k);
}catch(ArithmeticException | NullPinterException e){  要求异常类型之间不能有继承关系,如果有继承关系应该只写大异常类型即可
    System.out.println(e);
    e=new ArithmeticException("就是不告诉你");  //语法报错
    throw e;
}    

样例代码：
可以使用定义多个catch语句捕获不同的异常，采用不同的异常处理方法。但是一般不建议使用
catch作为程序处理分支
    catch可以消费掉异常，这个异常不会再提交运行时环境处理，除非人为抛出

public class Test3 {
    //因为人为抛出的异常throw new Exception是非运行时异常，所以必须进行处理throws Exception
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        String ss = sc.nextLine();
        try {
            int age = Integer.parseInt(ss);
            System.out.println("输入值为:"+age);
        } catch (RuntimeException e) {
            System.out.println("出现的问题为："+e.getMessage());
            throw new Exception(e.getMessage());  //重新封装异常对象，继续向上抛出
        }
        sc.close();
    }
}

finally语句为异常处理提供一个统一的出口，使得在控制流程转到程序的其他部分以前，能够
对程序的状态作统一的管理
    无论try所指定的程序块是否抛出异常，finally所指定的代码都要执行。
    try可以没有catch而直接使用finally，当然在方法上声明抛出
    
    try{... }catch(Exception e){... } finally{...}
    
    public void pp()throws Exception{
        try{....} finally{...}
    }    

    通常在finally语句中可以进行资源的清除工作，例如关闭打开的文件，删除临时文件等。
    注意Java的垃圾回收机制只能回收再堆内存中对象所占用的内存，而不会回收任何物理资源
    （如数据库连接、网络连接和磁盘文件等）

特殊情况导致finally执行出现问题
    - 在前边的代码中使用System.exit(int)退出应用
          System.exit(int  status)这个方法是用来结束当前正在运行中的java虚拟机。
      - status是非零参数，那么表示是非正常退出。
          - System.exit(0)是正常退出程序，而System.exit(1)或者说非0表示非正常退出程序。    
      - 程序所在的线程死亡或者cpu关闭
    - 如果在finally代码块中的操作又产生异常，则该finally代码块不能完全执行结束
    
考核点：finally块和return
    try{
        int k=100;
        return 100;
    } catch(Exception e){
        return 99;
    } finally{
        return 88;
    }
    
    最终执行的返回值是finally里面的88，不管是否出现异常
    
    不建议这种写法，因为具备二义性
    int res=-1;
    try{
        ....
        res=100;
    } catch(Exception e){
        ...
        res=98;
    } finally{
        ...
        res=88;
    }
    return res;
 
 
自动关闭的写法
    依赖finally执行资源回收操作
    public class Test2 {
        public static void main(String[] args) {
            Reader r = null;
            try {
                r = new FileReader("d:/aaa.txt");
                int temp = -1;
                while ((temp = r.read()) != -1) {
                    System.out.print((char) temp);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    if (r != null)
                        r.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    JDK1.7引入简化写法
    public class Test3 {
        public static void main(String[] args) throws Exception {
            try (Reader r = new FileReader("d:/aaa.txt");) {
                int temp = -1;
                while ((temp = r.read()) != -1) {
                    System.out.print((char) temp);
                }
            }
        }
    }
    这里引入了Closeable和AutoCloseable接口，可以自动关闭资源。不需要使用finally编程关闭

容易出现的一个编码问题：隐藏异常
    try{
        陷阱代码;
    } catch(Exception e){
        空实现;
    }
    
最佳异常相关编程实践
1、不要在fianlly中使用return
2、不要在finally中抛出异常。
3、减轻finally的任务，不要在finally中做一些其它的事情，finally块仅仅用来释放资源是最合适的。
4、将尽量将所有的return写在函数的最后面，而不是try … catch … finally中
5、不要过度使用异常，不要把异常当做不同的逻辑分支对待
6、不要使用过于庞大的try块
7、避免使用catch all语句  try{}catch(Throwable t){}
8、坚决不要忽略捕获的异，坚决不允许catch块中内容为空

自定义异常    
public class AccountException extends Exception {
    public AccountException() {
        super("账户余额不足!");
    }

需要编写的程序：

- 一个无参构造函数

其余的方法可以使用IDE工具自动生成

- 一个带有String参数的构造函数，并传递给父类的构造函数。
- 一个带有String参数和Throwable参数，并都传递给父类构造函数
- 一个带有Throwable 参数的构造函数，并传递给父类的构造函数。

2、在方法适当的位置生成自定义异常的实例，并使用throw语句抛出
public void zhuan(Account source, Account target, long mount) throws AccountException {//告知调用方，这个方法可能会出现这个问题，要求调用方法进行处理
    // 因为定义AccountException的父类为Exception，所以这个异常属于受检型异常，所以必须进行处理，try/catch或者throws
    if (source.getBalance() < mount)
        throw new AccountException();
    ... ...
}

3、在方法的声明部分用throws语句声明该方法可能会抛出的异常或者使用try/catch结构直接
进行处理或者自定义异常为运行时异常
- 使用运行时异常是可以简化调用方编程，但是也可能导致调用方根本不知道这里可能会出现异常

    public int pp(String str){    //可以使用throws声明抛出，也可以不做声明
        return Integer.parseInt(str);
    }

4、注意：方法重写时需要抛出比原来方法一致或者更少的异常