【Android开发-30】Android中获取全局Context和使用Intent传递对象的讲解

1，获取全局Context的技巧

在Android编程中，Context对象常常扮演着重要的角色，例如在弹出Toast、启动活动、发送广播、操作数据库和使用通知等场景下都需要它的支持。然而，在某些情况下，直接获取Context对象并不那么容易。为此，我们需要一些技巧来全局获取Context。

其中一种常见的做法是使用静态变量来保存Context对象。你可以在Application类中定义一个静态变量来保存Context，这样在整个应用程序的生命周期中都可以访问到这个Context对象。这种方式简单易行，但需要注意确保线程安全。

另一种方式是使用单例模式来管理Context。这种方式的优点在于它可以更好地控制Context的生命周期，并且能够避免因内存泄漏等问题导致的错误。

以上两种方法都能有效解决在普通类中获取Context的问题，你可以根据实际需求和项目规模来选择适合的方法。

在Android中，我们可以通过以下方式获取全局的Context：

在Application类中定义一个静态变量来保存Context。

public class MyApplication extends Application {
    private static Context mContext;

    @Override
    public void onCreate() {
        super.onCreate();
        mContext = this;
    }

    public static Context getAppContext() {
        return mContext;
    }
}

在需要获取Context的地方，通过Application类的getAppContext()方法来获取。

Context context = MyApplication.getAppContext();

注意：这种方式只能获取到Application的Context，如果需要在Activity或者其他非Application类中获取到全局的Context，可能需要使用其他方式，例如使用单例模式等。

在Android中，我们可以通过单例模式来获取全局的Context。以下是一个简单的示例：

public class ContextSingleton {
    private static ContextSingleton instance;
    private Context context;

    private ContextSingleton(Context context) {
        this.context = context;
    }

    public static synchronized ContextSingleton getInstance(Context context) {
        if (instance == null) {
            instance = new ContextSingleton(context);
        }
        return instance;
    }

    public Context getContext() {
        return context;
    }
}

然后在需要获取Context的地方，通过以下方式获取：

Context context = ContextSingleton.getInstance(getApplicationContext()).getContext();

这种方式可以确保在整个应用程序的生命周期中，只有一个Context实例存在。

2，Intent传递对象的方法

2.1 在Android中，使用Serializable接口传递对象的完整代码如下：

发送方（SenderActivity.java）：

import android.content.Intent;
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;

public class SenderActivity extends AppCompatActivity {

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

        MyObject obj = new MyObject();
        obj.setName("张三");
        obj.setAge(25);

        Intent intent = new Intent(this, TargetActivity.class);
        intent.putExtra("key", obj);
        startActivity(intent);
    }
}

接收方（TargetActivity.java）：

import android.content.Intent;
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
import java.io.Serializable;

public class TargetActivity extends AppCompatActivity {

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

        Intent intent = getIntent();
        MyObject obj = (MyObject) intent.getSerializableExtra("key");

        // 使用obj对象进行操作
    }
}

其中，MyObject类需要实现Serializable接口：

import java.io.Serializable;

public class MyObject 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;
    }
}

注意：Serializable是序列化的意思，表示将一个对象转化成可存储和可传输的状态。

2.2在Android中，使用Parcelable接口传递对象的完整代码如下：

首先，创建一个实现Parcelable接口的类，例如MyObject：

import android.os.Parcel;
import android.os.Parcelable;

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

    public MyObject(String name, int age) {
        this.name = name;
        this.age = age;
    }

    protected MyObject(Parcel in) {
        name = in.readString();
        age = in.readInt();
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);
        dest.writeInt(age);
    }

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

    public static final Creator<MyObject> CREATOR = new Creator<MyObject>() {
        @Override
        public MyObject createFromParcel(Parcel in) {
            return new MyObject(in);
        }

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

注意：Parcelable 将一个完整的对象进行分解

writeToParcel方法中需要调用Parcel 的writeXxx方法将MyObject字段一一写出。
createFromParcel方法需要取出刚才写出的字段，病创建MyObject对象返回，其中的字段通过Parcel 的readXxx方法读取。注意读取的顺序和写出的顺序完全相同。

然后，在发送方（SenderActivity）中使用Parcelable接口传递对象：

import android.content.Intent;
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;

public class SenderActivity extends AppCompatActivity {

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

        MyObject obj = new MyObject("张三", 25);
        Intent intent = new Intent(this, ReceiverActivity.class);
        intent.putExtra("key", obj);
        startActivity(intent);
    }
}

最后，在接收方（ReceiverActivity）中使用Parcelable接口接收对象：

import android.content.Intent;
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;

public class ReceiverActivity extends AppCompatActivity {

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

        Intent intent = getIntent();
        MyObject obj = intent.getParcelableExtra("key");
        // 使用obj对象进行操作
    }
}