我找到了一个简单优雅的方法：

不可分割无可串行化无静态场无事件总线

方法1

第一项活动的代码：

    final Object objSent = new Object();
    final Bundle bundle = new Bundle();
    bundle.putBinder("object_value", new ObjectWrapperForBinder(objSent));
    startActivity(new Intent(this, SecondActivity.class).putExtras(bundle));        
    Log.d(TAG, "original object=" + objSent);

第二项活动的代码：

    final Object objReceived = ((ObjectWrapperForBinder)getIntent().getExtras().getBinder("object_value")).getData();
    Log.d(TAG, "received object=" + objReceived);

您会发现objSent和objReceived具有相同的hashCode，因此它们是相同的。

但是为什么我们可以用这种方式传递java对象呢？

实际上，android binder将为java对象创建全局JNI引用，并在没有该java对象的引用时释放该全局JNI参考。binder将在binder对象中保存此全局JNI引用。

*注意：除非两个活动在同一进程中运行，否则此方法将在（ObjectWrapperForBinder）getIntent（）.getExtras（）.get-Binder（“object_value”）处引发ClassCastException*

类ObjectWrapperForBinder定义

public class ObjectWrapperForBinder extends Binder {

    private final Object mData;

    public ObjectWrapperForBinder(Object data) {
        mData = data;
    }

    public Object getData() {
        return mData;
    }
}

方法2

对于发送者，使用自定义本地方法将java对象添加到JNI全局引用表（通过JNIEnv:：NewGlobalRef）将返回整数（实际上，JNIEnv:：NewGlobalRef返回jobject，这是一个指针，我们可以将其安全地转换为int）放入Intent（通过Intent:：putExtra）用于接收器从Intent获取整数（通过Intent:：getInt）使用自定义本机方法从JNI全局引用表还原java对象（通过JNIEnv:：NewLocalRef）从JNI全局引用表中删除项（通过JNIEnv:：DeleteGlobalRef），

但是方法2有一个很小但很严重的问题，如果接收器无法还原java对象（例如，在还原java对象之前发生了一些异常，或者接收器Activity根本不存在），那么java对象将成为孤立对象或内存泄漏，方法1没有此问题，因为android binder将处理此异常

方法3

要远程调用java对象，我们将创建一个数据契约/接口来描述java对象，将使用aidl文件

IDataContract.aidl公司

package com.example.objectwrapper;
interface IDataContract {
    int func1(String arg1);
    int func2(String arg1);
}

第一项活动的代码

    final IDataContract objSent = new IDataContract.Stub() {

        @Override
        public int func2(String arg1) throws RemoteException {
            // TODO Auto-generated method stub
            Log.d(TAG, "func2:: arg1=" + arg1);
            return 102;
        }

        @Override
        public int func1(String arg1) throws RemoteException {
            // TODO Auto-generated method stub
            Log.d(TAG, "func1:: arg1=" + arg1);
            return 101;
        }
    };
    final Bundle bundle = new Bundle();
    bundle.putBinder("object_value", objSent.asBinder());
    startActivity(new Intent(this, SecondActivity.class).putExtras(bundle));
    Log.d(TAG, "original object=" + objSent);

第二项活动的代码：

将AndroidManifest.xml中的android:process属性更改为非空进程名称，以确保第二个活动在另一个进程中运行

    final IDataContract objReceived = IDataContract.Stub.asInterface(getIntent().getExtras().getBinder("object_value"));
    try {
        Log.d(TAG, "received object=" + objReceived + ", func1()=" + objReceived.func1("test1") + ", func2()=" + objReceived.func2("test2"));
    } catch (RemoteException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

这样，即使两个活动在不同的进程中运行，我们也可以在它们之间传递接口，并远程调用接口方法

方法4

方法3似乎不够简单，因为我们必须实现aidl接口。如果您只想执行简单的任务，而方法返回值是不必要的，我们可以使用android.os.Messenger

第一个活动（发件人）的代码：

public class MainActivity extends Activity {
    private static final String TAG = "MainActivity";

    public static final int MSG_OP1 = 1;
    public static final int MSG_OP2 = 2;

    public static final String EXTRA_MESSENGER = "messenger";

    private final Handler mHandler = new Handler() {

        @Override
        public void handleMessage(Message msg) {
            // TODO Auto-generated method stub
            Log.e(TAG, "handleMessage:: msg=" + msg);
            switch (msg.what) {
            case MSG_OP1:

                break;
            case MSG_OP2:
                break;

            default:

                break;
            }
            super.handleMessage(msg);
        }

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

        startActivity(new Intent(this, SecondActivity.class).putExtra(EXTRA_MESSENGER, new Messenger(mHandler)));
    }
}

第二个活动（接收器）的代码：

public class SecondActivity extends Activity {

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

        final Messenger messenger = getIntent().getParcelableExtra(MainActivity.EXTRA_MESSENGER);
        try {
            messenger.send(Message.obtain(null, MainActivity.MSG_OP1, 101, 1001, "10001"));
            messenger.send(Message.obtain(null, MainActivity.MSG_OP2, 102, 1002, "10002"));
        } catch (RemoteException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

所有的Messenger.send都将以异步和顺序的方式在处理程序中执行。

实际上，android.os.Messenger也是一个aidl接口，如果你有android源代码，你可以找到一个名为IMessenger.aidl的文件

package android.os;

import android.os.Message;

/** @hide */
oneway interface IMessenger {
    void send(in Message msg);
}

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

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

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

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

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

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

创建自己的类Customer，如下所示：

import import java.io.Serializable;
public class Customer implements Serializable
{
    private String name;
    private String city;

    public Customer()
    {
        
    }
    public Customer(String name, String city)
    {
        this.name= name;
        this.city=city;
    }
    public String getName() 
    {
        return name;
    }
    public void setName(String name) 
    {
        this.name = name;
    }
    public String getCity() 
    {
        return city;
    }
    public void setCity(String city) 
    {
        this.city= city;
    }
    
}

在onCreate（）方法中

@Override
protected void onCreate(Bundle savedInstanceState) 
{
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.activity_top);
    
    Customer cust=new Customer();
    cust.setName("abc");
    cust.setCity("xyz");
    
    Intent intent=new Intent(abc.this,xyz.class);
    intent.putExtra("bundle",cust);
    startActivity(intent); 
}

在xyz活动类中，您需要使用以下代码：

Intent intent=getIntent();
Customer cust=(Customer)intent.getSerializableExtra("bundle");
textViewName.setText(cust.getName());
textViewCity.setText(cust.getCity());

在Android中，有许多方法可以将对象从一个活动传递到另一个活动。但它们中没有一个可以直接选择通过Intents或Bundles传递对象。您需要做的就是解码对象，作为字符串传递，在NextActivity中编码。示例如下：

Intent i = new Intent(this, nextActivity.class);
i.putExtra("fname", customer.getFirstName());
i.putExtra("lname", customer.getLastName());
i.putExtra("address", customer.getAddress());
startActivity(i);

第二种方法非常简单，使用可以从所有活动轻松访问的静态对象。

第三，最后但并非最不重要的是，您可以将Object存储到某个常量Java文件中，然后从任何活动中读取该Object值。

正如在评论中提到的，这个答案打破了封装并紧密耦合了组件，这很可能不是您想要的。最好的解决方案可能是使对象可Parcelable或Serializable，正如其他响应所解释的那样。话虽如此，解决方案解决了问题。所以，如果你知道你在做什么：

使用带有静态字段的类：

public class Globals {
    public static Customer customer = new Customer();
}

在活动内部，您可以使用：

活动来源：

Globals.customer = myCustomerFromActivity;

活动目标：

myCustomerTo = Globals.customer;

这是传递活动信息的简单方法。

以上答案几乎都是正确的，但对于那些不理解这些答案的人来说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有插件的原因，尤其是针对这一点。下载并使用它。