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

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

方法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);
}

一种选择是让自定义类实现Serializable接口，然后可以使用intent#putExtra（）方法的putExtra变量（Serializable..）在intent extra中传递对象实例。

实际代码：

在自定义模型/对象类中：

public class YourClass implements Serializable {

在使用自定义模型/类的其他类中：

//To pass:
intent.putExtra("KEY_NAME", myObject);

myObject的类型为“YourClass”。然后，要从另一个活动中检索，请使用getSerializableExtra使用相同的Key名称获取对象。需要对YourClass进行类型转换：

// To retrieve object in second Activity
myObject = (YourClass) getIntent().getSerializableExtra("KEY_NAME");

注意：确保主自定义类的每个嵌套类都实现了Serializable接口，以避免任何序列化异常。例如：

class MainClass implements Serializable {
    
    public MainClass() {}

    public static class ChildClass implements Serializable {
         
        public ChildClass() {}
    }
}

这个问题也在另一个堆栈溢出问题中讨论。请查看使用Serializable通过意向传递数据的解决方案。重点是使用Bundle对象，它在Intent中存储必要的数据。

 Bundle bundle = new Bundle();

 bundle.putSerializable(key1, value1);
 bundle.putSerializable(key2, value2);
 bundle.putSerializable(key3, value3);

 intent.putExtras(bundle);

要提取值，请执行以下操作：

 Bundle bundle = new Bundle();

 for (String key : bundle.keySet()) {
 value = bundle.getSerializable(key));
 }

Serializable的优点是简单。然而，如果需要传输许多数据，您应该考虑使用Parcelable方法，因为Parcelable是专门为Android设计的，它比Serializable更高效。可以使用以下命令创建Parcelable类：

在线工具parcelablerAndroid Studio插件-Android Parcelable代码生成器

如果您选择使用Samuh描述的方式，请记住，只能发送原始值。即，可分割的值。因此，如果您的对象包含复杂对象，这些对象将不会跟随。例如，Bitmap、HashMap等变量。这些变量很难按意图传递。

一般来说，我建议您只将原始数据类型作为额外类型发送，如String、int、boolean等。在您的情况下，它将是：String fname、String lname、int age和String address。

我的观点：通过实现ContentProvider、SDCard等，可以更好地共享更复杂的对象。也可以使用静态变量，但这可能会很快导致容易出错的代码。。。

不过，这只是我的主观看法。

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

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"));

我创建了一个保存临时对象的单例助手类。

public class IntentHelper {

    private static IntentHelper _instance;
    private Hashtable<String, Object> _hash;

    private IntentHelper() {
        _hash = new Hashtable<String, Object>();
    }

    private static IntentHelper getInstance() {
        if(_instance==null) {
            _instance = new IntentHelper();
        }
        return _instance;
    }

    public static void addObjectForKey(Object object, String key) {
        getInstance()._hash.put(key, object);
    }

    public static Object getObjectForKey(String key) {
        IntentHelper helper = getInstance();
        Object data = helper._hash.get(key);
        helper._hash.remove(key);
        helper = null;
        return data;
    }
}

不要将对象放在Intent中，而是使用IntentHelper：

IntentHelper.addObjectForKey(obj, "key");

在新的“活动”中，您可以获取对象：

Object obj = (Object) IntentHelper.getObjectForKey("key");

请记住，一旦加载，对象将被删除，以避免不必要的引用。