Android(Java)：已启动Activity如何访问启动方的Intent数据与方法？

一、获取启动当前Activity的Intent数据成员 #

1. 在启动方（BaseActivity）中携带数据 #

通过Intent的putExtra()方法传递数据，支持基本类型、字符串以及实现Serializable/Parcelable的自定义对象：

// BaseActivity中启动ChildActivity的代码
Intent intent = new Intent(BaseActivity.this, ChildActivity.class);
intent.putExtra("flag", "sample_flag"); // 字符串类型示例
intent.putExtra("count", 10); // 整数类型示例
startActivity(intent);

2. 在目标Activity（ChildActivity）中提取数据 #

在onCreate()或其他生命周期方法中，通过getIntent()获取启动时的Intent，再根据数据类型调用对应getXXXExtra()方法提取：

// ChildActivity中获取数据的代码
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_child);

    Intent launchIntent = getIntent();
    if (launchIntent != null) {
        // 获取字符串类型数据，第二个参数为默认值
        String flag = launchIntent.getStringExtra("flag");
        // 获取整数类型数据
        int count = launchIntent.getIntExtra("count", 0);
    }
}

二、ChildActivity调用BaseActivity的add(int a, int b)方法 #

直接持有BaseActivity实例会导致内存泄漏（Activity由系统管理，实例可能被回收），且Serializable/Parcelable无法传递Activity实例（持有系统资源），推荐以下几种可行方案：

方案1：接口回调（弱引用避免泄漏） #

通过定义回调接口，让BaseActivity实现接口，再通过弱引用传递给ChildActivity：

1. 定义回调接口：

public interface AddOperationCallback {
    int add(int a, int b);
}

2. BaseActivity实现接口并传递引用：

public class BaseActivity extends AppCompatActivity implements AddOperationCallback {
    @Override
    public int add(int a, int b) {
        return a + b;
    }

    private void launchChildActivity() {
        Intent intent = new Intent(this, ChildActivity.class);
        // 用WeakReference包装，避免内存泄漏
        ChildActivity.setAddCallback(new WeakReference<>(this));
        startActivity(intent);
    }
}

3. ChildActivity中调用回调：

public class ChildActivity extends AppCompatActivity {
    private static WeakReference<AddOperationCallback> callbackRef;

    public static void setAddCallback(WeakReference<AddOperationCallback> ref) {
        callbackRef = ref;
    }

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

        // 调用add方法
        if (callbackRef != null && callbackRef.get() != null) {
            int result = callbackRef.get().add(3, 5);
            // 处理计算结果
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 清空引用，防止内存泄漏
        callbackRef = null;
    }
}

方案2：Jetpack ViewModel（推荐，符合架构规范） #

使用ViewModel实现跨Activity的数据/方法共享，ViewModel生命周期独立于Activity，避免泄漏：

1. 创建共享ViewModel：

import androidx.lifecycle.MutableLiveData;
import androidx.lifecycle.ViewModel;
import kotlin.jvm.functions.Function2;

public class SharedCalcViewModel extends ViewModel {
    private final MutableLiveData<Function2<Integer, Integer, Integer>> addFunction = new MutableLiveData<>();

    public void setAddFunction(Function2<Integer, Integer, Integer> function) {
        addFunction.setValue(function);
    }

    public MutableLiveData<Function2<Integer, Integer, Integer>> getAddFunction() {
        return addFunction;
    }
}

2. BaseActivity中绑定add方法：

import androidx.lifecycle.ViewModelProvider;

public class BaseActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_base);

        SharedCalcViewModel viewModel = new ViewModelProvider(getApplication()).get(SharedCalcViewModel.class);
        // 将add方法以Lambda形式传入ViewModel
        viewModel.setAddFunction((a, b) -> add(a, b));
    }

    public int add(int a, int b) {
        return a + b;
    }

    private void launchChildActivity() {
        Intent intent = new Intent(this, ChildActivity.class);
        startActivity(intent);
    }
}

3. ChildActivity中获取并调用方法：

import androidx.lifecycle.ViewModelProvider;

public class ChildActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_child);

        SharedCalcViewModel viewModel = new ViewModelProvider(getApplication()).get(SharedCalcViewModel.class);
        viewModel.getAddFunction().observe(this, addFunc -> {
            if (addFunc != null) {
                int result = addFunc.invoke(3, 5);
                // 处理计算结果
            }
        });
    }
}

方案3：广播机制（适合简单场景，不推荐频繁使用） #

通过本地广播传递计算请求，BaseActivity接收后执行add方法，再将结果回传给ChildActivity：

1. BaseActivity中注册广播接收器：

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import androidx.localbroadcastmanager.content.LocalBroadcastManager;

public class BaseActivity extends AppCompatActivity {
    private BroadcastReceiver calcReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            int a = intent.getIntExtra("a", 0);
            int b = intent.getIntExtra("b", 0);
            int sum = add(a, b);

            // 发送结果广播
            Intent resultIntent = new Intent("com.example.CALC_RESULT");
            resultIntent.putExtra("sum", sum);
            LocalBroadcastManager.getInstance(context).sendBroadcast(resultIntent);
        }
    };

    public int add(int a, int b) {
        return a + b;
    }

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

        // 注册广播接收器
        IntentFilter filter = new IntentFilter("com.example.CALC_REQUEST");
        LocalBroadcastManager.getInstance(this).registerReceiver(calcReceiver, filter);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 注销接收器，避免泄漏
        LocalBroadcastManager.getInstance(this).unregisterReceiver(calcReceiver);
    }
}

2. ChildActivity中发送请求并接收结果：

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import androidx.localbroadcastmanager.content.LocalBroadcastManager;

public class ChildActivity extends AppCompatActivity {
    private BroadcastReceiver resultReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            int sum = intent.getIntExtra("sum", 0);
            // 处理计算结果
        }
    };

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

        // 注册结果接收器
        IntentFilter filter = new IntentFilter("com.example.CALC_RESULT");
        LocalBroadcastManager.getInstance(this).registerReceiver(resultReceiver, filter);

        // 发送计算请求
        Intent requestIntent = new Intent("com.example.CALC_REQUEST");
        requestIntent.putExtra("a", 3);
        requestIntent.putExtra("b", 5);
        LocalBroadcastManager.getInstance(this).sendBroadcast(requestIntent);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        LocalBroadcastManager.getInstance(this).unregisterReceiver(resultReceiver);
    }
}

内容的提问来源于stack exchange，提问作者Akash Fulari