跟我学JAVA / 第七课：深入Java类——异常处理机制 垃圾回收

2018-03-09

本章我们将学到的知识点：

1、异常处理机制 　　2、垃圾回收

一、异常

在程序运行过程中所发生的破坏了正常的指令流程的事件称为例外。 软件和硬件错误都可能导致他们的产生。例如：

1、用户输入出错 　　2、所需文件找不到 　　3、运行时磁盘空间不够 　　4、内存不够 　　5、算术运算错误 (数的溢出，被零除…) 　　6、数组下标越界

异常：是在程序执行过程中出现的一个事件，它中断了正常指令的运行。

错误：偏离了可接受的代码行为的一个动作或一个实例。

异常例子：

public class HelloWorld {
        public static void main (String args[]) {
           int i = 0;
           String greetings [] = {
         "Hello world!",
         "No, I mean it!",
         "HELLO WORLD!!"
            };
            while (i < 4) {
         System. out. println (greetings[ i]);
         i++;
            }
    }
}

//public class ExceptionDemo{
//
//    public static void main(String[] args){
//           int i = 0;
//           System.out.println(5/i);   
//    }
//}

二、异常处理机制

可分为以下几个步骤：

1）抛出异常：在堆栈中创建一个异常对象。

当方法中有一个错误发生后，该方法创建一个异常对象并把它交给运行系统。异常对象中包含了有关异常的信息，如异常类型、发生错误时的程序状态等。

2）捕获异常：找到异常处理程序。

运行时系统在方法调用堆栈里为被抛出的异常查找处理代码。运行系统从发生错误的方法开始进行回朔，

在方法调用堆栈里向后搜索，直到找到能处理当前发生的异常的处理程序的方法。

3）处理异常：通过方法调用来处理异常。

4）终止或恢复运行：如果运行时系统在方法调用栈查遍了所有的方法（主方法中）而未找到合适的异常处理程序，则运行时系统终止执行。

异常处理的优越性：

与传统的错误处理技术相比，java程序使用异常处理错误有以下优越性：

1、可以把错误代码与常规代码分隔开 　　2、可以在调用栈中传播错误 　　3、可以对错误类型进行分组

异常类及其子类：

所有异常类型都是 Throwable的子类，

Error类用于显示与Java运行时系统本身有关的错误，Error类对象由Java虚拟机生成并抛出；

Exception类是用户程序可能捕获的异常，也是用来创建用户异常类型子类的基类，Exception类对象由应用程序处理或抛出。

1、Throwable类是所有例外类型的父类，不能被直接使用，表示任何可以作为异常被抛出的类。

2、Error用来表示编译时和系统错误，表示恢复不是不可能但很困难情况下的一种严重问题。

比如说内存溢出，它不可能执行程序处理这样的问题，一般是和VM有关的问题。

3、Exception是可以被抛出的基本异常类型，在JAVA类库、用户方法以及运行时故障中都可能抛出Exception型异常。

4、RuntimeException 运行时异常。它表示程序运行正常的话就不会发生这种问题，这种异常不用在程序中把他们列出来，

运行时有问题，会自动被JVM抛出。比如空指针异常，数组超出异常。

5、除了运行时例外之外的其他由Exception 继承来的例外类都是非运行时的例外，例如FileNotFoundException（文件未找到例外）。

Java编译器要求在程序中必须处理这种例外，捕获例外或者声明抛弃例外。

异常处理：

由五个关键字 try、catch、throw、throws 和 finally 处理异常。

异常处理的两种方式：

一、try-catch-finally语句捕获异常

try{
    ……
}catch( Exception e){
    ……
}finally {
   ……
} 

二、方法声明时用throws声明方法体内有异常

捕获异常：

try{    }选定捕获例外的范围，由try所限定的代码块中的语句在执行过程中可能会生成例外对象并抛弃。

catch( ){ } 放置异常处理程序。

1、catch必须紧跟在try之后 　　

2、可有多个catch块，但异常类型必须是层层嵌套的，即先从子类异常，最后才到父类异常。

3、当抛出异常时，异常处理机制将负责搜索参数与异常类型相匹配的第一个处理程序。　　

4、只有匹配的catch子句能执行，和switch不同，不需要break.

5、可通过throwable类提供的方法getMessage（），printStackTrace( ) 来跟踪异常事件发生时执行堆栈的内容。

finally{ }为异常处理提供一个统一的出口或定义跳转流程;该语句永远会被执行。

public class CatchException{
      public static void main (String args[]) {
          String greetings [] = { "Hello world!", "No, I mean it!","HELLO WORLD!" };        
          for(int i=0;i<4;i++){
                 try{
                        //捕获异常
                 System.out.println (greetings[i]);                     
                 }catch(ArrayIndexOutOfBoundsException e){
                       //处理异常
                      System.out.println("ArrayIndexOutOf  Exception!");            
                 }finally{
                       //清理或状态恢复
                 System.out.println("This is always printed!");                
                 }
           }//end for
    } 
}

Throwable类的常用方法：

Throwable类的常用方法

getMessage() 返回异常的原因

getStackTrace() 返回堆栈跟踪情况

printStackTrace() 打印堆栈的标准错误流

printStackTrace(PrintStream s) 打印堆栈的标准打印流

toString() 返回简单描述

public class ExceptionMethodDemo{
    
    public static void main(String args[]){
        
        System.out.println("异常方法使用");
        
        try{
        
            int i=1;
            i=i/0;
            i =i +1;
        
        }catch(Exception e){              
           //System.out.println("getMessage()是："+e.getMessage());           
         //  System.out.println("getStackTrace()是："+e.getStackTrace());
              e.printStackTrace();
         //  System.out.println("toString()是："+e.toString());
         }
    }

}

1、声明异常--throw：

Throws Exception 如果在一个方法中生成了一个例外，但是这一方法并不确切地知道该如何对这一异常事件进行处理，

这时，该方法就应该声明抛弃例外，使得例外对象可以从调用栈向后传播，直到有合适的方法捕获它为止。这是一种消极的异常处理机制。

一般该方法用在调用第三方工具包的时候。

声明一个异常有两种方法： throw throws

可以通过throw关键字在可能出现异常的执行语句后面声明抛出一个异常。

格式： throw ThrowableObject；

ThrowableObject必须为Throwable类或其子类的对象

public class ThrowExceptionDemo{    
    static void compute(int a){       
        System.out.println("调用compute("+a+")");       
        if(a==0){            
           throw new ArithmeticException("使用throw实例化一个异常对象，并抛出 "+a);
        }else{
            a = 9/a;
        }        
        System.out.println("这是正常退出");
    }
    
    public static void main( String args[] ){        
        try{
            compute(1);           
            System.out.println(".........");          
            compute(0);
         }catch(Exception e){
             e.printStackTrace();            
         }        
    }
}

2、声明异常   --throws：

public class ThrowsDemo{
    static void method() throws ArithmeticException{  
        int i=0;
        int j = 2/i;
    }
    
    public static void main(String args[]){
        try{
            method();
        }catch(ArithmeticException e){
            System.out.println("在method方法捕获了异常："+e);
        }
    }
}

在一个方法声明时通过throws关键字在声明异常。例如：

public int read ( ) throws IOException{......}

throws子句中同时可以指明多个例外，之间由逗号隔开。例如：

public static void main(String args[]) throws IOException，IndexOutOfBoundsException {
          ......
}

3、自定义异常类：

声明一个新的异常类，该异常类必须从Java已有定义的异常类继承，如Exception、IOException等。

为新的异常类定义属性和方法，或重载父类的属性和方法，使这些属性和方法能够体现该类所对应的错误的信息。

自定义异常类例子：

public class MyException extends Exception{
    
    private int x;
    
    public MyException( ){   }
    
    public MyException( String msg){  super(msg);  }
    
    public MyException( String msg , int x ){
         super(msg);
         this.x = x;     
    }
    
    public int val(){ return x ;}
    
    public String getMessage(){
         return "Detail Message : "+x+" "+super.getMessage();    
    }
}

三、垃圾处理器：

1、java是通过finalize()方法进行垃圾处理的。

finalize（）方法是在对象被当成垃圾从内存中释放之前调用，而不是变成垃圾前调用。

finalize（）方法不用在程序中启动，JVM会在需要的时候自己启动该方法进行垃圾处理。 有可能直到程序终止，该方法都不会执行。

2、可通过System.gc()方法来强制启动垃圾回收器来处理垃圾。