全局获取Context

1.定制自己的Application类

2.在Manifest.xml中进行初始化

3.如果有LitePal则在Application中调用LitePal初始化方法就行

public class MyApplication extends Application {
    private static Context context;

    @SuppressLint("MissingSuperCall")
    @Override
    public void onCreate() {
        context = getApplicationContext();
        LitePalApplication.initialize(context);
    }
    public static Context getContext(){
        return context;
    }
}

1
2
3

<application
       android:name="com.example.application.MyApplication">
</application>

Intent传递数据

Serializable(序列化)

1.让一个类去实现Serializable接口

2.Intent传值

3.调用getSerializableExtra方法接收值

public class Person implements Serializable {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Person person=new Person();
       person.setName("zx");
       person.setAge(18);
       Intent intent=new Intent(FirstActivity.this, SecondActivity.class);
       intent.putExtra("person_data",person);
       startActivity(intent);

1	Person person=(Person) getIntent().getSerializableExtra("person_data");

Parcelable

1.让一个类去实现Parcelable接口

2.重写writeToParcel方法写入数据

3.创建一个常量CREATOR，创建Parcelable.Creator接口的一个实现

4.重写createFromParcel方法对数据进行读取，读取顺序和写出顺序一致

5.同上一个Intent用法基本一致

public class Person implements Parcelable {
    private String name;
    private int age;


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(@NonNull Parcel parcel, int i) {
 parcel.writeString(name);//写出Name
 parcel.writeInt(age);//写出Age
    }
    public static final Parcelable.Creator<Person> CREATOR = new Parcelable.Creator<Person>() {
        @Override
        public Person createFromParcel(Parcel in) {
            Person person=new Person();
            person.name=in.readString();//读取name
            person.age=in.readInt();//读取age
            return person;
        }

        @Override
        public Person[] newArray(int size) {
            return new Person[size];
        }
    };
}

Person person=new Person();
       person.setName("zx");
       person.setAge(18);
       Intent intent=new Intent(FirstActivity.this, SecondActivity.class);
       intent.putExtra("person_data",person);
       startActivity(intent);

1	Person person=(Person) getIntent().getParcelableExtra("person_data");

定制自己的日志工具

1.新建一个日志类

2.项目上线前将level定义为VERBOSE，上线后将其定义为NOTHING

public class LogUtil {
    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 int level=VERBOSE;
    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);
        }
    }



}

调试Android程序

逐行的执行代码，查找bug

DeBug按钮调试

1.在需要调试的部分设置断点

2.点击Debug调试按钮

Attach debugger to Android process按钮调试

1.设置断点

2.直接运行程序

3.点击工具栏中的Attach debugger to Android process进入Debug窗口

创建定时任务

Alarm机制

1.建立一个新的服务

2.在onStartCommand中开启一个新的线程

3.利用AlarmManager进行设定(用setExact替代set，基本可以保证任务可以准时进行)

4.启动定时服务

@Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        //开启一个子线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                //在这里执行具体的逻辑操作
            }
        }).start();
        //获取实例
        AlarmManager manager=(AlarmManager) getSystemService(ALARM_SERVICE);
        int anHour=60*60*1000;
        long triggerAtTime= SystemClock.elapsedRealtime()+anHour;
        //指定定时任务的服务为LongRunningService
        Intent intent1=new Intent(this, LongRunningService.class);
        @SuppressLint("UnspecifiedImmutableFlag") PendingIntent pi=PendingIntent.getService(this,0,intent1,0);
        //调用set方法完成设定
        manager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP,triggerAtTime,pi);

        return super.onStartCommand(intent,flags,startId);
    }

1
2
3

//启动定时服务
Intent intent=new Intent(this, LongRunningService.class);
context.startService(intent);

Doze模式

该模式下受限的功能：

1.网络访问被禁止

2.系统忽略唤醒CPU或者屏幕操作

3.系统不再执行WIFI扫描

4.系统不再执行同步服务

5.Alarm服务将会在下次退出Doze模式时执行(该情况下定时任务会有误差，可以用setAndAllowWhileIdle()或setExactAndAllowWhileIdle()方法解决，这俩方法的区别和set(),setExact()之间的区别一样)

多窗口模式编程

一：改变进入多窗口模式活动会被重建这一默认设置：

在Manifest.xml进行配置：

1	android:configChanges="orientation\|keyboardHidden\|screenSize\|screenLayout"

二：禁用多窗口模式：
1.在或中加入如下属性：(targetSdkVersion>=24时有用)

1	android:resizeableActivity="false"//false为不支持，true为支持，默认为true

2.targetSdkVersion<24时，android规定活动不允许横竖屏切换时，则其也不支持多窗口模式

只需在标签中加入以下配置：

1	android:screenOrientation="portrait"//portrait只支持竖屏，landscape只支持横屏

Lambda表达式

条件：只有一个待实现方法的接口可以使用这样的写法

实例：

Runnable runnable=new Runnable(){
    @Override
    public void run(){
        //添加具体的实现
    }
}
//用Lambda改写
Runnable runnable=()->{
   //代码逻辑
};

//创建接口
public interface MyListener{
    String doSomething(String a,int b);
}
//Lambda写法
MyListener listener=(a,b)->{
    String result=a+b;
    return result;
}
//参数类型可以省略，如果只有一个参数还可以把括号去掉