从此活动启动另一个活动，并通过捆绑对象传递参数

Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("USER_NAME", "xyz@gmail.com");
startActivity(intent);

检索其他活动的数据（YourActivity）

String s = getIntent().getStringExtra("USER_NAME");

这对于一种简单的数据类型是可以的。但是如果你想在活动之间传递复杂的数据。你需要先序列化它。

这里有员工模型

class Employee{
    private String empId;
    private int age;
    print Double salary;
    
    getters...
    setters...
}

您可以使用google提供的Gson-lib来序列化复杂的数据这样地

String strEmp = new Gson().toJson(emp);
Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("EMP", strEmp);
startActivity(intent);

Bundle bundle = getIntent().getExtras();
String empStr = bundle.getString("EMP");
            Gson gson = new Gson();
            Type type = new TypeToken<Employee>() {
            }.getType();
            Employee selectedEmp = gson.fromJson(empStr, type);

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

intent.putExtra("class", BeanClass);

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

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

我使用parcelable将数据从一个活动发送到另一个活动。这是我的代码，在我的项目中运行良好。

public class Channel implements Serializable, Parcelable {

    /**  */
    private static final long serialVersionUID = 4861597073026532544L;

    private String cid;
    private String uniqueID;
    private String name;
    private String logo;
    private String thumb;


    /**
     * @return The cid
     */
    public String getCid() {
        return cid;
    }

    /**
     * @param cid
     *     The cid to set
     */
    public void setCid(String cid) {
        this.cid = cid;
    }

    /**
     * @return The uniqueID
     */
    public String getUniqueID() {
        return uniqueID;
    }

    /**
     * @param uniqueID
     *     The uniqueID to set
     */
    public void setUniqueID(String uniqueID) {
        this.uniqueID = uniqueID;
    }

    /**
     * @return The name
     */
    public String getName() {
        return name;
    }

    /**
     * @param name
     *            The name to set
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * @return the logo
     */
    public String getLogo() {
        return logo;
    }

    /**
     * @param logo
     *     The logo to set
     */
    public void setLogo(String logo) {
        this.logo = logo;
    }

    /**
     * @return the thumb
     */
    public String getThumb() {
        return thumb;
    }

    /**
     * @param thumb
     *     The thumb to set
     */
    public void setThumb(String thumb) {
        this.thumb = thumb;
    }


    public Channel(Parcel in) {
        super();
        readFromParcel(in);
    }

    public static final Parcelable.Creator<Channel> CREATOR = new Parcelable.Creator<Channel>() {
        public Channel createFromParcel(Parcel in) {
            return new Channel(in);
        }

        public Channel[] newArray(int size) {

            return new Channel[size];
        }
    };

    public void readFromParcel(Parcel in) {
        String[] result = new String[5];
        in.readStringArray(result);

        this.cid = result[0];
        this.uniqueID = result[1];
        this.name = result[2];
        this.logo = result[3];
        this.thumb = result[4];
    }

    public int describeContents() {
        return 0;
    }

    public void writeToParcel(Parcel dest, int flags) {

        dest.writeStringArray(new String[] { this.cid, this.uniqueID,
                this.name, this.logo, this.thumb});
    }
}

在活动A中，如下所示：

Bundle bundle = new Bundle();
bundle.putParcelableArrayList("channel",(ArrayList<Channel>) channels);
Intent intent = new Intent(ActivityA.this,ActivityB.class);
intent.putExtras(bundle);
startActivity(intent);

在ActivityB中，使用如下方法获取数据：

Bundle getBundle = this.getIntent().getExtras();
List<Channel> channelsList = getBundle.getParcelableArrayList("channel");

这个问题也在另一个堆栈溢出问题中讨论。请查看使用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代码生成器

有几种方法可以访问其他类或Activity中的变量或对象。

A.数据库

B.共享偏好。

C.对象序列化。

可以保存公共数据的类可以命名为公共实用程序。这取决于你。

E.通过Intents和Parcelable接口传递数据。

这取决于您的项目需求。

A.数据库

SQLite是一个嵌入到Android中的开源数据库。SQLite支持标准的关系数据库功能，如SQL语法、事务和准备好的语句。

教程

B.共享偏好

假设您想存储用户名。所以现在有两件事，一个关键用户名，一个值。

如何存储

 // Create object of SharedPreferences.
 SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(this);

 //Now get Editor
 SharedPreferences.Editor editor = sharedPref.edit();

 //Put your value
 editor.putString("userName", "stackoverlow");

 //Commits your edits
 editor.commit();

使用putString（）、putBoolean（）、put Int（）、putFloat（）和putLong（），可以保存所需的数据类型。

如何获取

SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(this);
String userName = sharedPref.getString("userName", "Not Available");

http://developer.android.com/reference/android/content/SharedPreferences.html

C.对象序列化

如果我们希望保存对象状态以通过网络发送，或者您也可以将其用于您的目的，则使用对象序列化。

使用Javabean并将其存储为他的一个字段，并使用getter和setter。

JavaBean是具有财产的Java类。想想作为私有实例变量的财产。因为他们是私人的可以通过类中的方法从类外部访问它们。更改属性值的方法称为setter方法，检索属性值的方式称为getter方法。

public class VariableStorage implements Serializable  {

    private String inString;

    public String getInString() {
        return inString;
    }

    public void setInString(String inString) {
        this.inString = inString;
    }
}

使用

VariableStorage variableStorage = new VariableStorage();
variableStorage.setInString(inString);

然后使用对象序列化来序列化此对象，并在其他类中反序列化此对象。

在串行化中，对象可以表示为一个字节序列，其中包括对象的数据以及关于对象类型和存储在对象中的数据类型的信息。

序列化对象写入文件后，可以从文件中读取并反序列化。也就是说，表示对象及其数据的类型信息和字节可用于在内存中重新创建对象。

如果您需要此教程，请参阅：

Java序列化（博客文章）获取其他类中的变量（堆栈溢出）

D.公用设施

您可以自己创建一个类，其中可以包含项目中经常需要的公共数据。

样品

public class CommonUtilities {

    public static String className = "CommonUtilities";

}

E.通过意图传递数据

有关传递数据的选项，请参考教程Android–使用Parcelable类在活动之间传递包裹数据。

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