public class MyClass implements Serializable{
    Here is your instance variable
}

现在要在startActivity中传递该类的对象。只需使用此选项：

Bundle b = new Bundle();
b.putSerializable("name", myClassObject);
intent.putExtras(b);

这在这里有效，因为MyClass实现了Serializable。

不可能序列化任何类型的对象。例如，不能序列化携带代码而不是数据的委托方法或接口。因此，我编写了一个“Box”类，您可以使用它来传递任何类型的数据，而无需序列化。

1-将数据用于预期用途：

Intent I = new Intent(this, YourActivity.class);
CustomClass Date = new CustomClass();
Box.Add(I, "Name", Data);

2-用于从意向检索数据：

CustomClass Data = Box.Get(getIntent(), "Name");

3-要在使用后删除数据，请将此方法添加到活动中：

@Override
protected void onDestroy() {
    Box.Remove(getIntent());
    super.onDestroy();
}

4-并将此代码添加到项目中：

package ir.namirasoft.Utility;

import android.content.Intent;

import java.util.HashMap;
import java.util.Vector;

public class Box {
    // Number
    private static int Number = 1;

    public static int NextNumber() {
        return Number++;
    }

    //
    private static String _Intent_Identifier = "_Intent_Identifier";
    private static HashMap<Integer, Vector<Integer>> DeleteList = new HashMap<Integer, Vector<Integer>>();
    private static HashMap<Integer, HashMap<String, Object>> ObjectList = new HashMap<Integer, HashMap<String, Object>>();

    public static int GetIntent_Identifier(Intent I) {
        int Intent_Identifier = I.getIntExtra(_Intent_Identifier, 0);
        if (Intent_Identifier == 0)
            I.putExtra(_Intent_Identifier, Intent_Identifier = NextNumber());
        return Intent_Identifier;
    }

    public static void Add(Intent I, String Name, Object O) {
        int Intent_Identifier = GetIntent_Identifier(I);
        synchronized (ObjectList) {
            if (!ObjectList.containsKey(Intent_Identifier))
                ObjectList.put(Intent_Identifier, new HashMap<String, Object>());
            ObjectList.get(Intent_Identifier).put(Name, O);
        }
    }

    public static <T> T Get(Intent I, String Name) {
        int Intent_Identifier = GetIntent_Identifier(I);
        synchronized (DeleteList) {
            DeleteList.remove(Intent_Identifier);
        }
        return (T) ObjectList.get(Intent_Identifier).get(Name);
    }

    public static void Remove(final Intent I) {
        final int Intent_Identifier = GetIntent_Identifier(I);
        final int ThreadID = NextNumber();
        synchronized (DeleteList) {
            if (!DeleteList.containsKey(Intent_Identifier))
                DeleteList.put(Intent_Identifier, new Vector<Integer>());
            DeleteList.get(Intent_Identifier).add(ThreadID);
        }
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(60 * 1000);
                } catch (InterruptedException e) {
                }
                synchronized (DeleteList) {
                    if (DeleteList.containsKey(Intent_Identifier))
                        if (DeleteList.get(Intent_Identifier).contains(ThreadID))
                            synchronized (ObjectList) {
                                ObjectList.remove(Intent_Identifier);
                            }
                }
            }
        }).start();
    }
}

**Box类是线程安全的。

创建类似bean类的类并实现Serializable接口。然后我们可以通过intent方法传递它，例如：

intent.putExtra("class", BeanClass);

然后从其他活动中获取，例如：

BeanClass cb = intent.getSerializableExtra("class");

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无论如何都是全局的。

最好的方法是在应用程序中有一个类（称为Control），该类将保存类型为“Customer”的静态变量（在您的情况下）。初始化活动A中的变量。

例如：

Control.Customer = CustomerClass;

然后转到Activity B并从Control类获取它。使用变量后不要忘记赋值null，否则会浪费内存。

在自定义类中创建两个方法，如下所示

public class Qabir {

    private int age;
    private String name;

    Qabir(){
    }

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

    // method for sending object
    public String toJSON(){
        return "{age:" + age + ",name:\"" +name +"\"}";
    }

    // method for get back original object
    public void initilizeWithJSONString(String jsonString){

        JSONObject json;        
        try {
            json =new JSONObject(jsonString );
            age=json.getInt("age");
            name=json.getString("name");
        } catch (JSONException e) {
            e.printStackTrace();
        } 
    }
}

现在在您的发件人活动中这样做

Qabir q= new Qabir(22,"KQ");    
Intent in=new Intent(this,SubActivity.class);
in.putExtra("obj", q.toJSON());
startActivity( in);

在您的接收器中活动

Qabir q =new Qabir();
q.initilizeWithJSONString(getIntent().getStringExtra("obj"));