Android-Log使用介绍

Log.v() －－－－－－－－－－－－－－－－－－－－ VERBOSE

Log.d() －－－－－－－－－－－－－－－－－－－－ DEBUG

Log.i() －－－－－－－－－－－－－－－－－－－－ INFO

Log.w() －－－－－－－－－－－－－－－－－－－－ WARN

Log.e() －－－－－－－－－－－－－－－－－－－－ ERROR

1. Log.v 的调试颜色为白色的，任何消息都会输出，这里的v代表verbose啰嗦的意思，平时使用就是Log.v("","");
2. Log.d的输出颜色是蓝色的，仅输出debug调试的意思，但他会输出上层的信息，过滤起来可以通过DDMS的Logcat标签来选择.
3. Log.i的输出为绿色，一般提示性的消息information，它不会输出Log.v和Log.d的信息，但会显示i、w和e的信息
4. Log.w的意思为橙色，可以看作为warning警告，一般需要我们注意优化Android代码，同时选择它后还会输出Log.e的信息。
5. Log.e为红色，可以想到error错误，这里仅显示红色的错误信息，这些错误就需要我们认真的分析，查看栈的信息了。

示例

static final String LOG_CAT =  "Abe Logcat" ;

Log. v( LOG_CAT ,  "This is Verbose.") ;
Log. d( LOG_CAT ,  "This is Debug.") ;
Log. i( LOG_CAT ,  "This is Information") ;
Log. w( LOG_CAT ,  "This is Warnning.") ;
Log. e( LOG_CAT ,  "This is Error.") ;

Log封装

public class ABLog {

    private static boolean  sIsDebug =  true;  //判断是会否输出Log
    private static int  sCurLogLevel = Log. VERBOSE ;  //输出级别

    private static StackTraceElement[]  sCurrentThread= null;
    private static String  sTagName= "" ;
    private static String  sMsgT= "" ;
    private static String  sMsgC= "" ;

    private static final int  PRINT_STACK_NUM =  10 ;
    private static final String  MARK =  "AB-" ;

    /**
     * Log.e信息，默认不显示，函数调用队列
     *  @param  msg  消息
     */
    public static void  e(String msg) {
        if (! sIsDebug)  return;
        if ( sCurLogLevel > Log. ERROR)  return;

        initTrace(msg , false) ;
        Log. e( sTagName ,  sMsgT +  sMsgC) ;
    }

    /**
     * Log.w信息，默认不显示，函数调用队列
     *  @param  msg  消息
     */
    public static void  w(String msg) {
        if (! sIsDebug)  return;
        if ( sCurLogLevel > Log. WARN)  return;

        initTrace(msg , false) ;
        Log. w( sTagName ,  sMsgT +  sMsgC) ;
    }

    /**
     * Log.i信息，默认不显示，函数调用队列
     *  @param  msg  消息
     */
    public static void  i(String msg) {
        if (! sIsDebug)  return;

        if ( sCurLogLevel > Log. INFO)  return;

        initTrace(msg , false) ;
        Log. i( sTagName ,  sMsgT +  sMsgC) ;
    }

    /**
     * Log.d信息，默认不显示，函数调用队列
     *  @param  msg  消息
     */
    public static void  d(String msg) {
        if (! sIsDebug)  return;
        if ( sCurLogLevel > Log. DEBUG)  return;

        initTrace(msg , false) ;
        Log. d( sTagName ,  sMsgT +  sMsgC) ;
    }

    /**
     * Log.v信息，默认不显示，函数调用队列
     *  @param  msg  消息
     */
    public static void  v(String msg) {
        if (! sIsDebug)  return;
        if ( sCurLogLevel > Log. VERBOSE)  return;

        initTrace(msg , false) ;
        Log. v( sTagName ,  sMsgT +  sMsgC) ;
    }


    /**
     * Log.e信息
     *  @param  msg  消息
     *  @param  isPrintStack  是否显示函数调用队列
     */
    public static void  e(String msg , boolean isPrintStack) {
        if (! sIsDebug)  return;
        if ( sCurLogLevel > Log. ERROR)  return;

        initTrace(msg , isPrintStack) ;
        Log. e( sTagName ,  sMsgT +  sMsgC) ;
    }

    /**
     * Log.w信息
     *  @param  msg  消息
     *  @param  isPrintStack  是否显示函数调用队列
     */
    public static void  w(String msg , boolean isPrintStack) {
        if (! sIsDebug)  return;
        if ( sCurLogLevel > Log. WARN)  return;

        initTrace(msg , isPrintStack) ;
        Log. w( sTagName ,  sMsgT +  sMsgC) ;
    }

    /**
     * Log.i信息
     *  @param  msg  消息
     *  @param  isPrintStack  是否显示函数调用队列
     */
    public static void  i(String msg , boolean isPrintStack) {
        if (! sIsDebug)  return;

        if ( sCurLogLevel > Log. INFO)  return;

        initTrace(msg , isPrintStack) ;
        Log. i( sTagName ,  sMsgT +  sMsgC) ;
    }

    /**
     * Log.d信息
     *  @param  msg  消息
     *  @param  isPrintStack  是否显示函数调用队列
     */
    public static void  d(String msg , boolean isPrintStack) {
        if (! sIsDebug)  return;
        if ( sCurLogLevel > Log. DEBUG)  return;

        initTrace(msg , isPrintStack) ;
        Log. d( sTagName ,  sMsgT +  sMsgC) ;
    }

    /**
     * Log.v信息
     *  @param  msg  消息
     *  @param  isPrintStack  是否显示函数调用队列
     */
    public static void  v(String msg , boolean isPrintStack) {
        if (! sIsDebug)  return;
        if ( sCurLogLevel > Log. VERBOSE)  return;

        initTrace(msg , isPrintStack) ;
        Log. v( sTagName ,  sMsgT +  sMsgC) ;
    }

    /**
     * 初始化
     *  @param  msg  消息
     *  @param  isPrintStack  是否初始化函数调用队列信息
     */
    private synchronized static void  initTrace(String msg , boolean isPrintStack) {
        int curentIndex =  4 ;  //getStackTrace数组中，0~3元素，需要跳过（自行debug）
        int printStackNumber = isPrintStack ?  PRINT_STACK_NUM :  0 ;
        sCurrentThread = Thread. currentThread().getStackTrace() ;

        String className =  sCurrentThread[curentIndex].getFileName() ;
        int endIndex = className.lastIndexOf( ".") ;
        sTagName =  MARK + (endIndex <  0 ? className : className.substring( 0 , endIndex)) ;
        sMsgT =  "[" + className +  ":" +  sCurrentThread[curentIndex].getLineNumber() +  ":"
                +  sCurrentThread[curentIndex].getMethodName() +  "()]---" ;
        sMsgC =  "msg:[" + msg +  "] \n " ;
        if (printStackNumber >  0) {
            StringBuilder sb =  new StringBuilder() ;
            sb.append( "callTraceStack:[") ;
            for ( int i = curentIndex ; i < curentIndex + printStackNumber && i <  sCurrentThread. length ; i++) {
                sb.append( " \n <--" +  sCurrentThread[i].getFileName() +  ":" +  sCurrentThread[i].getLineNumber() +  ":"
                        +  sCurrentThread[i].getMethodName() +  "()") ;
            }
            sb.append( "]") ;
            sMsgC += sb.toString() ;
        }
    }
}