JAVA第八课 异常、日志

异常

异常机制其实是帮助我们找到程序中的问题，异常的根类是 java.lang.Throwable ，其下有两个子类： java.lang.Error 与 java.lang.Exception

Error

JVM监管范围外的，JVM无法处理的：可以捕获，但无法解决

Exception

既可以捕获也可以解决

1. CheckedException:编译异常：强制处理
2. RuntimeException：运行时异常：不强制处理

三种处理方式

1. 程序逻辑：RuntimeException
2. 捕获：直接处理
3. 抛出：给别人处理

异常的处理

抛出异常throw

throw new 异常类名(参数);
throw new NullPointerException("要访问的arr数组不存在");   throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");

public class ThrowDemo {     
     public static void main(String[] args) {        
     //创建一个数组          
     int[] arr = {2,4,52,2};         
     //根据索引找对应的元素          
     int index = 4;         
     int element = getElement(arr, index);           
     System.out.println(element);        
     System.out.println("over");     
}     
/**    
* 根据 索引找到数组中对应的元素     
*/     
     public static int getElement(int[] arr,int index){          
          //判断  索引是否越界          
          if(index<0 || index>arr.length‐1){              
          /*             
          判断条件如果满足，当执行完throw抛出异常对象后，
          方法已经无法继续运算。这时就会结束当前方法的执行，
          并将异常告知给调用者。这时就需要通过异常来解决。               
           */              
          throw new ArrayIndexOutOfBoundsException("哥们，角标越界了~~~");        
         }         
         int element = arr[index];         
         return element;     
     } 
 }

声明异常throws

声明异常：将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理（稍后讲 解该方式），那么必须通过throws进行声明，让调用者去处理。
关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).
声明异常格式：

修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{} 

public class ThrowsDemo2 {     
        public static void main(String[] args) throws IOException {            
              read("a.txt");    
        }       
        public static void read(String path)throws FileNotFoundException, IOException {         
             if (!path.equals("a.txt")) {
             //如果不是 a.txt这个文件              
             // 我假设  如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常  throw                
             throw new FileNotFoundException("文件不存在");         
             }         
             if (!path.equals("b.txt")) {             
                  throw new IOException();         
             }     
        } 
}

捕获异常try…catch

如果异常出现的话,会立刻终止程序,所以我们得处理异常:

1. 该方法不处理,而是声明抛出,由该方法的调用者来处理(throws)。
2. 在方法中使用try-catch的语句块来处理异常。
   try-catch的方式就是捕获异常。
   捕获异常：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。
   捕获异常语法如下

try{      
     编写可能会出现异常的代码 
}catch(异常类型  e){     
     处理异常的代码     
     //记录日志/打印异常信息/继续抛出异常 
     

finally 代码块

finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行 不到。而fifinally就是解决这个问题的，在fifinally代码块中存放的代码都是一定会被执行的。
try…catch…finally:自身需要处理异常,最终还得关闭资源。
注意:fifinally不能单独使用。
在我们之后学习的IO流中，当打开了一个关联文件的资源，最后程序不管结果如何，都需要把这个资源关闭掉。

日志

1. 导入jar包：log4.jar
2. 考入配置文件：log4j.properties src根目录
3. 创建类的成员变量：
   例如创建Validator验证类
   private static Logger log=Logger.getLogger(Validator.class)
4. private logger log=Logger.getLogger(类名.class)
   log.info(String val); 正常信息
   log.error(ex.getMessage());异常信息

import org.apache.log4j.Logger;

public class Validator {
    //logger验证器，调用Logger的getLogger静态方法
    private static Logger log = Logger.getLogger(Validator.class);

    /**
     * 验证参数字符串是不是符合数据特征
     *
     * @param val
     * @return
     */
    public static boolean isNaN(String val) {
        if (null == val) {
            return true;
        }
        if (-1 == val.indexOf(".")) {
            return !isInt(val);
        }
        String[] arr = val.split("\\.");
        if (arr.length > 2) {
            return true;
        }
        for (String s : arr) {
            if (!isInt(s)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 验证参数是否符合整数特征
     *
     * @param val
     * @return
     */
    public static boolean isInt(String val) {
        for (char c : val.toCharArray()) {
            if (c < '0' || c > '9') {
                return false;
            }
        }
        return true;
    }

    //模仿System.arrayCopy
    public static void arrayCopy(int[] src, int startPos, int[] dest, int beginIndex, int length) throws Exception {
        if (null == src || null == dest) {
            throw new NullPointerException("src or dest null pointer");
        }
        if (startPos < 0 || startPos > src.length) {
            throw new ArrayIndexOutOfBoundsException("array src index out of bounds:startPos" + startPos);
        }
        if (beginIndex < 0 || beginIndex > dest.length) {
            throw new ArrayIndexOutOfBoundsException("array dest index out of bounds:beginIndex" + beginIndex);
        }
        if (src.length - startPos < length || dest.length - beginIndex < length) {
            throw new ArrayIndexOutOfBoundsException();
        }
        for (int count = 0; count < length; count++) {
            dest[beginIndex + count] = src[startPos + count];
        }
    }

    public static void test() {
        int[] src = {1, 3, 5, 6, 7, 78, 88};
        int[] dest = new int[20];
        try {
            arrayCopy(src, 0, dest, 10, src.length);
            //正确日志信息打印
            log.info("拷贝成功");
        } catch (Exception ex) {
            //错误日志信息的打印
            log.error(ex.getMessage());
        }
        for (int i : dest) {
            System.out.println(i);
        }
    }

    public static void main(String[] args) {
        test();
    }
}