如何在Android应用程序中传递活动之间的数据？

若要在所有活动中使用会话 ID，可以按照以下步骤进行操作：

1- 在应用程序文件的静态变量 session 中定义一个静态变量（将保存会话 ID 的值）。

2- 现在，在获取会话 ID 值的类引用中调用会话变量并将其分配给静态变量。

3- 现在，您只需通过调用静态变量即可在任何位置使用此会话 ID 值。

目标活动定义如下：

public class DestinationActivity extends AppCompatActivity{

    public static Model model;
    public static void open(final Context ctx, Model model){
          DestinationActivity.model = model;
          ctx.startActivity(new Intent(ctx, DestinationActivity.class))
    }

    public void onCreate(/*Parameters*/){
           //Use model here
           model.getSomething();
    }
}

在第一个活动中，按以下方式启动第二个活动：

DestinationActivity.open(this,model);

New and real time interaction between activities using callbacks:

- 步骤01：实现共享接口

public interface SharedCallback {
    public String getSharedText(/*you can define arguments here*/);
}

- 步骤 02：实现一个共享的类

final class SharedMethode {
    private static WeakReference<Context> mContext;

    private static SharedMethode sharedMethode = new SharedMethode();

    private SharedMethode() {
        super();
    }

    public static SharedMethode getInstance() {
        return sharedMethode;
    }

    public void setContext(Context context) {
        if (mContext != null)
            return;

        mContext = new WeakReference<Context>(context);
    }

    public boolean contextAssigned() {
        return mContext != null && mContext.get() != null;
    }

    public Context getContext() {
        return mContext.get();
    }

    public void freeContext() {
        if (mContext != null) mContext.clear();
        mContext = null;
    }
}

- 步骤 03 :: 在第一个活动中玩转代码

public class FirstActivity extends Activity implements SharedCallback {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.your_layout);

        // call playMe from here or there
        playMe();
    }

    private void playMe() {
        SharedMethode.getInstance().setContext(this);
        Intent intent = new Intent(this, SecondActivity.class);
        startActivity(intent);
    }

    @Override
    public String getSharedText(/*passed arguments*/) {
        return "your result";
    }

}

- 步骤 04 :: 在 SecondActivity 中完成游戏的最终化。

public class SecondActivity extends Activity {

    private SharedCallback sharedCallback;

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

        if (SharedMethode.getInstance().contextAssigned()) {
            if (SharedMethode.getInstance().getContext() instanceof SharedCallback)
                sharedCallback = (SharedCallback) SharedMethode.getInstance().getContext();

            // to prevent memory leak
            SharedMethode.freeContext();
        }

        // You can now call your implemented methodes from anywhere at any time
        if (sharedCallback != null)
            Log.d("TAG", "Callback result = " + sharedCallback.getSharedText());

    }

    @Override
    protected void onDestroy() {
        sharedCallback = null;
        super.onDestroy();
    }

}

• 步骤 05 :: 您还可以实现一个回调函数（从第二个活动返回到第一个活动），以从 SecondAvtivity 获取一些结果或调用某些方法

在Android应用程序中，传递数据的方式不止一种。其中一种是使用意图和可包裹对象，正如许多答案中已经提到的那样。

另一种优雅的方法是使用Eventbus库。

从发出活动：

EventBus.getDefault().postSticky("--your Object--");

在接收活动中：

EventBus.getDefault().removeStickyEvent("--Object class--")

其他需要考虑的要点：

1. 提供更多自由度，您可以在不修改任何形式的情况下传递复杂对象。
2. 不仅限于在活动之间传递数据，一旦设置了库，您可以将其用于在应用程序管道中从一个地方传递数据到另一个地方。例如，使用此功能进行底部菜单与活动之间的通信。
3. 稳定的库。
4. 简化组件之间的通信
5. 解耦事件发送者和接收者
6. 在UI工件（例如活动、片段）和后台线程中表现良好
7. 避免复杂和容易出错的依赖关系和生命周期问题
8. 速度快；专门针对高性能进行优化
9. 体积小（~60k jar）
10. 已被1,000,000,000+安装的应用程序证明在实践中有效
11. 具有交付线程、订阅者优先级等高级功能。

要在Java中实现这个功能：

startActivity(new Intent(this, MainActivity.class).putExtra("userId", "2"));

//你的问题是你想在登录后存储会话ID，并在每个需要注销的活动中使用该会话ID。

//解决方案是在成功登录后将会话ID存储在公共变量中。每当您需要会话ID进行注销时，您可以访问该变量并将变量值替换为零。

//Serializable class

public class YourClass  implements Serializable {
     public long session_id = 0;
}

使用 Bundle @link https://medium.com/@nikhildhyani365/pass-data-from-one-activity-to-another-using-bundle-18df2a701142
//从 medium 复制

           Intent I =  new Intent(MainActivity.this,Show_Details.class);

            Bundle b = new Bundle();


            int x = Integer.parseInt(age.getText().toString());
            int y = Integer.parseInt(className.getText().toString());

            b.putString("Name",name.getText().toString());

            b.putInt("Age",x);
            b.putInt("ClassName",y);

            I.putExtra("student",b);

            startActivity(I);

使用Intent @link https://android.jlelse.eu/passing-data-between-activities-using-intent-in-android-85cb097f3016

我们可以通过两种方式将值传递到另一个Activity（已发布相同类型的答案，但在此处我尝试通过意图来降低代码）

1.通过意图(Intent)

  Activity1:
      startActivity(new Intent(getApplicationContext(),Activity2.class).putExtra("title","values"));

InActivity 2:

String recString= getIntent().getStringExtra("title");

2. 通过 SharedPreference

  Activity1:

SharedPreferences pref = getApplicationContext().getSharedPreferences("MyPref", 0); 
 // 0 - for private mode
Editor editor = pref.edit();
editor.putString("key_name", "string value"); // Storing string
editor.commit(); // commit changes

Activty2:
   SharedPreferences pref = getApplicationContext().getSharedPreferences("MyPref", 0); 

pref.getString("key_name", null); // getting String

考虑使用单例模式来保存会话信息，以便所有活动都可以访问。
与 extras 和静态变量相比，这种方法具有几个优点：

1. 允许您扩展Info类，添加您需要的新用户信息设置。您可以创建一个继承它的新类或仅编辑Info类，而无需更改所有地方的额外处理。

2. 易于使用-不需要在每个活动中获取额外信息。

   public class Info {
   
       private static Info instance;
       private int id;
       private String name;
   
       //私有构造函数是为了禁止在create()或getInstance()方法之外创建实例
       private Info() {
   
       }
   
       //您用来从任何Activity获取相同信息的方法。
       //如果尚未创建，则返回现有的Info实例，否则返回null。
       public static Info getInstance() {
           return instance;
       }
   
       //创建一个新的Info实例或返回现有的实例（如果存在）。
       public static synchronized Info create(int id, String name) {
   
           if (null == instance) {
               instance = new Info();
               instance.id = id;
               instance.name = name;
           }
           return instance;
       }
   }
   

我使用公共静态字段来存储活动之间的共享数据，但为了最小化其副作用，您可以：

• 只创建一个或尽可能少的字段，并重复使用它们，将它们设置为对象类型，并在接收活动中将其转换为所需类型。
• 每当它们中的任何一个不再有用时，都将其明确设置为null以便被垃圾回收器收集，然后进行下一次分配。