设定自己的代码风格--Android学习笔记5

最新推荐文章于 2020-08-06 15:51:21 发布

鹏儿飞飞

最新推荐文章于 2020-08-06 15:51:21 发布

阅读量460

点赞数

分类专栏： Android 文章标签： Android 自定义异常 throw与throws区别自定义Log 自定义Activity管理机制

本文链接：https://blog.csdn.net/qq_25465845/article/details/51242551

版权

Android 专栏收录该内容

15 篇文章 1 订阅

订阅专栏

设定自己的代码风格

一、自定义BaseActivity：

自定义BaseActivity来替换Activity，这样就可以执行一些自己想要的固定操作；比如下面的随时知道正在执行的Activity，以及屏幕密度；

package cpj.com.MyTool;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;

/**
 * Created by cpj on 2016/3/11.
 * 打印当前的活动名称（让他们都继承此类而不是Activity）
 */
public class BaseActivity extends Activity{

    public static final String TAG = "BaseActivity";

    protected void onCreate(Bundle savedInstanceState){
        super.onCreate(savedInstanceState);

        //打印当前的活动
        String str = "当前执行的活动是："+getClass().getSimpleName();
        MyLog.d(TAG, str);//打印当前活动名称

        //打印屏幕的密度值
        float xdpi = getResources().getDisplayMetrics().xdpi;
        float ydip = getResources().getDisplayMetrics().ydpi;
        String str_dp = "当前屏幕的密度值为："+ xdpi+ "  *  "+ ydip;
        Log.d(TAG, str_dp);

        //将当前活动存入List
        ActivityCollector.addActivity(this);
    }

    /**
     * 将马上销毁的一个活动在管理器中移除
     * */
    protected void onDestory(){
        super.onDestroy();
        ActivityCollector.removeActivity(this);
    }

}

二、自定义MyLog：

自定义MyLog来替换Log,这样更方便设置自己的日志打印方式和日志级别控制；当我们不想在Logcat里显示某个级别的日志信息时，只需将当前的日志显示级别提高即可。

package cpj.com.MyTool;

import android.util.Log;

/**
 * Created by cpj on 2016/4/12.
 * 创建自己的日志打印机制，实时控制是否打印
 */
public class MyLog {

    //日志的打印级别
    public static final int VERBOSE = 1;
    public static final int DEBUG = 2;
    public static final int INFO = 3;
    public static final int WARN = 4;
    public static final int ERROR = 5;
    public static final int NOTHING = 6;//不打印任何日志

    //自定义现在的级别
    public static final int LEVEL = DEBUG;

    /*
     * 当自定义的级别小于日志的打印级别时打印，否则屏蔽打印
     * */
    @SuppressWarnings("unused")
	public static void v(String tag, String msg){
        if(LEVEL <= VERBOSE) Log.v(tag, msg);
    }

    public static void d(String tag, String msg){
        if(LEVEL <= DEBUG) Log.d(tag, msg);
    }

    public static void i(String tag, String msg){
        if(LEVEL <= INFO) Log.i(tag, msg);
    }

    public static void w(String tag, String msg){
        if(LEVEL <= WARN) Log.w(tag, msg);
    }

    public static void e(String tag, String msg){
        if(LEVEL <= ERROR) Log.e(tag, msg);
    }

}

/**
 * 使用方法：
 *   MyLog.d("TAG", message);
 * */

三、定义MyToast：

自定义MyToast替换Toast，让提醒代码变的更加简洁点；

package cpj.com.MyTool;

import android.content.Context;
import android.widget.Toast;

/*
 * 打印Toast
 * */
public class MyToast {
	
	private static Context myContext = MyApplication.getContext();//获取当前的上下文

	/**
	 * 功能描述：短时间显示Toast
	 * 
	 * @param {String} msg 需要显示的信息
	 * */
	public static void MyToastShort(String msg){
		 Toast.makeText(myContext, "【Cpj提示】："+msg, Toast.LENGTH_SHORT)
		    .show();
	}
	
	/**
	 * 功能描述：长时间显示Toast
	 * 
	 * @param {String} msg 需要显示的信息
	 * */
	public static void MyToastLong(String msg){
		 Toast.makeText(myContext, "【Cpj提示】："+msg, Toast.LENGTH_LONG)
		    .show();
	}
	
	

}

四、自定义MyApplication：

自定义MyApplication，随时随地找到上下文；

package cpj.com.MyTool;

import android.app.Application;
import android.content.Context;

/**
 * Created by cpj on 2016/4/12.
 * 类作用：管理程序中的全局变量-获取全局Context
 */
public class MyApplication extends Application{

    private static Context context;// 上下文

    /**
     * 方法描述：获取系统级别的Context
     * */
    @Override
    public void onCreate() {
        super.onCreate();
        context = getApplicationContext();
    }

    /**
     * 方法描述：供所有类调用-返回Context
     * */
    public static Context getContext(){
        return context;
    }
}

/**
 * Created by cpj on 2016/4/12.
 * 系统每次启动的时候，就会对Application类进行初始化。
 * 我们可以通过定义自己的MyApplication类来管理程序中的一些全局的状态信息
 * 如：获取全局Context
 * 记得在AndroidManifext.xml中将<Application></Application>指定为此类
 * 调用方法：MyApplication.getContext();
 */

五、自定义ActivityCollector：

自定义ActivityCollector，来统一管理自己的活动，如：一键关闭所有活动等；

package cpj.com.MyTool;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by cpj on 2016/3/11.
 * 随时随地退出程序
 * 按住Home键只是挂起，并没有退出程序。
 * 我们只需做一个专门的集合类对所有的活动就行管理就可以：
 *  1. 用List暂存活动，用addActivity（）向List中添加活动，用removeActivity方法从List中移除活动。
 *     用finishAll（）将List中的所有活动全部销毁。
 */
public class ActivityCollector extends Activity{

    public static List<Activity> activities = new ArrayList<Activity>();

    /**
     * 向List中添加活动
     * */
    public static void addActivity(Activity activity){
        activities.add(activity);
    }

    /**
     * 从List中移除活动
     * */
    public static void removeActivity(Activity activity){
        activities.remove(activity);
    }

    /**
     * 将List中的所有活动全部销毁
     * */
    public static void finishAll(){
        for(Activity activity : activities){
            if(!activity.isFinishing()){//isFinishing()判断活动是否被销毁了
                activity.finish();
            }
        }
    }
}

六、自定义MyExceptions:

自定义MyExceptions，来建立自己的异常处理机制；

package cpj.com.MyTool;

/**
 * Created by cpj on 2016/4/25.
 */
public class MyExceptions extends Exception{

    private String message;//错误信息

    public MyExceptions(String ErrorMessage){
        message = ErrorMessage;
    }

    /**
     * 方法描述：将错误信息以日志格式输出
     * */
    public void logErrorMessage(){
        MyLog.e("【Cpj自定义异常】",message);
    }

    /**
     * 方法描述:打印自己的错误信息栈
     * */
    public void logStackTrace(){

        StackTraceElement[] stacks = new Throwable().getStackTrace();

        StringBuffer sb = new StringBuffer();
        if(stacks.length < 1){
            MyLog.d("【Cpj自定义异常栈】","当前无异常");

        } else {
            sb.append("[\n")
              .append("【异常绝对位置】:" + stacks[0].getClassName()).append("\n")
              .append("【异常线程】:" + Thread.currentThread().getName()).append("\n")
              .append("【异常类名】:" + stacks[0].getFileName()).append("\n")
              .append("【异常方法】:" + stacks[0].getMethodName() + "()").append("\n")
              .append("【异常行数】:" + stacks[0].getLineNumber()).append("行\n")
              .append("]\n");
            MyLog.e("【Cpj自定义异常栈】", sb.toString());
        }
    }

}

自定义异常的使用(自定义Add()方法。如果加数或者被加数为负，则抛出异常)：

package cpj.com.MyException;

import android.os.Bundle;
import android.view.View;
import android.widget.Button;

import cpj.com.MyTool.BaseActivity;

import cpj.com.MyTool.MyExceptions;
import cpj.com.MyTool.MyLog;
import cpj.com.MyTool.MyToast;
import cpj.com.cpjtest.R;

/**
 * Created by cpj on 2016/4/25.
 */
public class MyException extends BaseActivity{

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.myexception);

        //Button的点击事件-MyException
        Button exception_BT = (Button)findViewById(R.id.myException);
        exception_BT.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                try {
                    int c = Add(-1, 2);
                    MyLog.d("【c=】", c+"");

                //抛出自定义异常
                }catch (MyExceptions e){
                    e.logErrorMessage();
                    e.logStackTrace();

                //抛出别的异常
                }catch (Exception e){

                    e.printStackTrace();//指出异常的类型、性质、栈层及出现在程序中的位置

                }finally {
                    MyLog.d("【Finally】", "执行完成");
                    MyToast.MyToastShort("已执行");
                }

            }
        });
    }
    /**
     * 方法描述：1.自定义函数,用于测试异常的抛出,指定此方法有错的话就抛出自定义异常
     *          2.区别throws与throw
     * @param {int} a;
     * @param {int} b;
     *
     * */
    public int Add(int a, int b) throws MyExceptions {

        int c =0;

        if(a<0 || b<0){
            throw new MyExceptions("加数或者被加数不能为负数");
        } else{
            c = a + b;
        }

        return c;
    }
}

执行结果：（Logcat的打印）

附：throws、throw与try...catch 的区别与用法：

1. 基本定义：

①.throws 关键字通常被应用在声明方法时，用来指定方法可能抛出的异常;多个异常可以使用逗号分
②.throw关键字通常用于方法体中，并且抛出一个异常对象。程序中执行到throw语句时立刻终止，它后面

的语句都不执行。通过throw抛出异常后，如果想在上一级代码中来捕获并处理异常，则需要在抛出异常的方法中使用。throws关键字在方法的声明中指明要抛出的异常，如果要捕捉抛出的异常，则必须使用try...catch。

③.try...catch关键字用于捕获异常并处理异常；

2. throws与throw的区别：

①.用户程序自定义的异常和应用程序特定的异常,必须借助于 throws 和 throw 语句来定义抛出异常。

②.throws是对一个异常的声明；一般应用在声明方法时；
如；上面的定义Add方法时，写到：Add(int a, int b) throws MyExceptions ；
throw 可看做是一个抛出异常的语句；也就是说某条语句需要抛出异常；

如：上面的，如果是负数，那我就抛出异常：throw new MyExceptions("加数或者被加数不能为负数")

③.throws语句用在方法声明后面，表示再抛出异常，由该方法的调用者来处理。

throw语句用在方法体内，表示抛出异常，由方法体内的语句处理。

④.throws说明你有那个可能，倾向(这个方法可能存在异常)。

throw的话，那就是你把那个倾向变成真实的了(这条语句就是要抛出异常)。

⑤.throws与throw两者都是消极处理异常的方式，只是抛出或者可能抛出异常，但他们并没有着手想办法去处理这种异常；而真正的处理异常的是函数上层调用者try...catch。

如：try{
//无异常时执行
}catch(Exception e){
//如果有异常那我在这里想办法处理
}

鹏儿飞飞

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
设定自己的代码风格--Android学习笔记5

设定自己的代码风格一、自定义BaseActivity：自定义BaseActivity来替换Activity，这样就可以执行一些自己想要的固定操作；比如下面的随时知道正在执行的Activity，以及屏幕密度；package cpj.com.MyTool;import android.app.Activity;import android.os.Bundle;i
复制链接

扫一扫