java基础---异常续

异常的捕获和处理

   try{  
        try代码段中包含可能产生异常的代码，有人称为陷阱代码，
        在执行过程中如果出现了异常，则异常之后的java语句不会
        执行。转而执行catch部分的代码
    } catch(SomeException e){  可以写多个
        try后可以跟一个多个catch代码段，针对不同异常执行不同
        的处理逻辑。当异常发生时，程序会中止当前的流程，根据获
        取异常的类型去执行响应的代码段。注意异常类型判定时是从
        上向下逐个判断的。
    }finally{
        finally代码是无论是否发生异常都会执行的代码
    }

基本用法

    Integer kk=null;
    try{
        String str="123.456";
        //由于str参数数据不合法，不是整数，所以这里异常NumberFormatException
        kk=Integer.parseInt(str);
        System.out.println("数据转换结束");//上句出现异常，这里就不会执行
    } catch(Exception e){//出现异常后进行类型判断，如果是这种异常则执行这里的代码段
        System.out.println("出现了错误："+e.getMessage());
        e.printStackTrace();  //在控制台上打印输出调用栈
    }
    System.out.println("转换结果为："+kk);

重点：OOM

        int[] arr = new int[Integer.MAX_VALUE];

        OOM：当JVM因为没有足够的内存来为对象分配空间并且垃圾回收器也已经没有空间可回收时，就会抛出这个error  OutOfMemoryError

OOM产生的原因

        1、分配的少了：比如虚拟机本身可使用的内存（一般通过启动时的VM参数指定）太少

        2、应用用的太多，并且用完没释放，浪费了。此时就会造成内存泄露或者内存溢出。

       内存泄露：申请使用完的内存没有释放，导致虚拟机不能再次使用该内存，此时这段内存就泄露了，因为申请者不用了，而又不能被虚拟机分配给别人用。

       内存溢出：申请的内存超出了JVM能提供的内存大小，此时称之为溢出。

        在Java语言中由于存在了垃圾自动回收机制，所以一般不用去主动释放不用的对象所占的内存，也就是理论上来说，是不会存在内存泄露的。但是，如果编码不当，比如将某个对象的引用放到了全局的Map中，虽然方法结束了，但是由于垃圾回收器会根据对象的引用情况来回收内存，导致该对象不能被及时的回收。如果该种情况出现次数多了，就会导致内存溢出，比如系统中经常使用的缓存机制。Java中的内存泄露，不同于C++中的忘了delete，往往是逻辑上的原因泄露。

最常见的OOM情况有以下三种：

        1、java.lang.OutOfMemoryError: Java heap space ------>java堆内存溢出，

        此种情况最常见，一般由于内存泄露或者堆的大小设置不当引起。对于内存泄露，需要通过内存监控软件查找程序中的泄露代码，而堆大小可以通过虚拟机参数-Xms,-Xmx等修改。

        2、java.lang.OutOfMemoryError: PermGen space ------>java永久代溢出，即

方法区溢出了，一般出现于大量Class或者jsp页面，或者采用cglib等反射机制的情况，因为上述情况会产生大量的Class信息存储于方法区。此种情况可以通过更改方法区的大小来解决，使用类似-XX:PermSize=64m -XX:MaxPermSize=256m的形式修改。另外，过多的常量尤其是字符串也会导致方法区溢出。

        3、java.lang.StackOverflowError ------> 不会抛OOM error，

        但也是比较常见的Java内存溢出。JAVA虚拟机栈溢出，一般是由于程序中存在死循环或者深度递归调用造成的，栈大小设置太小也会出现此种溢出。可以通过虚拟机参数-Xss来设置栈的大小。

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("账户余额不足!");

        

}

需要编写的程序：

1、 一个无参构造函数

其余的方法可以使用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、注意：方法重写时需要抛出比原来方法一致或者更少的异常