Android活动对象可以被销毁和重建。因此，您需要使用另一种方法来查看它们或它们创建的任何对象！！！-向上的也就是说，您可以作为静态类引用传递，但对象句柄（Java调用这些“引用”，SmallTalk也是如此；但它们不是C或汇编意义上的引用）稍后可能会无效，因为Android OE的一个“特性”是任何活动都可以在稍后被销毁和重新构建。

最初的问题是“如何在Android中将对象从一个活动传递到另一个活动”，但没有人回答这个问题。当然，您可以序列化（Serializable、Parcelable、to/from JSON）并传递对象数据的副本，这样就可以创建具有相同数据的新对象；但它将不具有相同的引用/句柄。此外，许多其他人提到可以将引用存储在静态存储中。除非Android决定开启销毁您的活动，否则这将起作用。

因此，要真正解决原始问题，您需要一个静态查找，再加上每个对象将在重新创建时更新其引用。例如，如果调用其onCreate，则每个Android活动将重新列出自己。您还可以看到一些人如何使用任务列表按名称搜索“活动”。（系统正在临时销毁此活动实例以节省空间。getRunningTasks，任务列表实际上是每个活动的最新对象实例的专门列表）。

供参考：

停止：该活动被另一个活动完全遮挡（该活动现在位于“后台”）。已停止的活动也仍然活动（活动对象保留在内存中，它维护所有状态和成员信息，但未附加到窗口管理器）。但是，用户不再能看到它，当其他地方需要内存时，系统可能会将其关闭销毁“系统正在临时销毁此活动实例以节省空间。”

因此，消息总线是一个可行的解决方案。它基本上是“双关语”。而不是试图引用对象；然后重新构建设计，使用MessagePassing而不是SequentialCode。调试难度成倍增加；但它让你忽略了这些对操作环境的理解。实际上，每个对象方法访问都是反向的，因此调用者发布一条消息，而对象本身定义了该消息的处理程序。更多的代码，但可以使其在Android OE限制下更加健壮。

如果你想要的只是顶部的“活动”（由于到处都需要“上下文”，所以在Android应用程序中很常见），那么只要调用onResume，你就可以让每个“活动”在静态全局空间中将自己列为“顶部”。然后，AlertDialog或任何需要上下文的东西都可以从那里获取它。此外，使用全局有点讨厌，但可以简化到处上下传递上下文，当然，当您使用MessageBus时，IT无论如何都是全局的。

以上答案几乎都是正确的，但对于那些不理解这些答案的人来说Android有一个强大的类Intent。借助它，您不仅可以在活动之间共享数据，还可以在Android的其他组件之间共享数据（广播接收器，我们使用ContetResolver类无Intent提供的内容服务）。在你的活动中，你建立了意图

Intent intent = new Intent(context,SomeActivity.class);
intent.putExtra("key",value);
startActivity(intent);

在接收活动中

public class SomeActivity extends AppCompactActivity {

    public void onCreate(...){
    ...
          SomeObject someObject = getIntent().getExtras().getParceable("key");
    }
}

为了在活动之间共享，必须在对象上实现Parceable或Serializable接口。很难在对象上实现Parcealbe而不是Serializable接口，这就是为什么android有插件的原因，尤其是针对这一点。下载并使用它。

像这样创建自定义类：

public class Test implements Parcelable {
    String message;

    protected Test(Parcel in) {
        message = in.readString();
    }

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

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

    public String getMessage() {
        return message;
    }

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

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

使用Intent发送数据，如下所示：开始活动之前，必须设置一些数据

Intent intent = new Intent(context, PostDetailsActivity.class);
                intent.putExtra("data", (Parcelable) test);
                ((context)).startActivity(intent);

从以下意图中获取数据：

Test test = (Test) getIntent().getParcelableExtra("data");

你可以尝试使用该类。限制是它不能在一个过程之外使用。

一项活动：

 final Object obj1 = new Object();
 final Intent in = new Intent();
 in.putExtra(EXTRA_TEST, new Sharable(obj1));

其他活动：

final Sharable s = in.getExtras().getParcelable(EXTRA_TEST);
final Object obj2 = s.obj();

public final class Sharable implements Parcelable {

    private Object mObject;

    public static final Parcelable.Creator < Sharable > CREATOR = new Parcelable.Creator < Sharable > () {
        public Sharable createFromParcel(Parcel in ) {
            return new Sharable( in );
        }


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

    public Sharable(final Object obj) {
        mObject = obj;
    }

    public Sharable(Parcel in ) {
        readFromParcel( in );
    }

    Object obj() {
        return mObject;
    }


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


    @Override
    public void writeToParcel(final Parcel out, int flags) {
        final long val = SystemClock.elapsedRealtime();
        out.writeLong(val);
        put(val, mObject);
    }

    private void readFromParcel(final Parcel in ) {
        final long val = in .readLong();
        mObject = get(val);
    }

    /////

    private static final HashMap < Long, Object > sSharableMap = new HashMap < Long, Object > (3);

    synchronized private static void put(long key, final Object obj) {
        sSharableMap.put(key, obj);
    }

    synchronized private static Object get(long key) {
        return sSharableMap.remove(key);
    }
}

使用Serializable实现类。假设这是您的实体类：

import java.io.Serializable;

@SuppressWarnings("serial") //With this annotation we are going to hide compiler warnings
public class Deneme implements Serializable {

    public Deneme(double id, String name) {
        this.id = id;
        this.name = name;
    }

    public double getId() {
        return id;
    }

    public void setId(double id) {
        this.id = id;
    }

    public String getName() {
        return this.name;
    }

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

    private double id;
    private String name;
}

我们正在将名为dene的对象从X活动发送到Y活动。在X活动的某处；

Deneme dene = new Deneme(4,"Mustafa");
Intent i = new Intent(this, Y.class);
i.putExtra("sampleObject", dene);
startActivity(i);

在Y活动中，我们正在获取对象。

Intent i = getIntent();
Deneme dene = (Deneme)i.getSerializableExtra("sampleObject");

就是这样。

根据我的经验，有三种主要的解决方案，各有其缺点和优点：

实施Parcelable实现可串行化使用某种轻量级事件总线库（例如，Greenrobot的EventBus或Square的Otto）

Parcelable-快速且符合Android标准，但它有很多样板代码，并且需要硬编码字符串以供在提取意图值（非强类型）时参考。

可序列化-接近于零样板，但这是最慢的方法，并且在从意图中提取值（非强类型）时还需要硬编码字符串。

事件总线-零样板，最快的方法，不需要硬编码字符串，但它需要额外的依赖项（虽然通常很轻，约40 KB）

我发布了这三种方法的非常详细的比较，包括效率基准。