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

设定自己的代码风格

一、自定义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){

//如果有异常那我在这里想办法处理

}