Complete Guide to Passing Custom Objects Between Activities in Android

Introduction

In Android application development, data transfer between Activities is a common requirement. When dealing with complex data structures, directly passing custom objects from one Activity to another becomes particularly important. Based on high-scoring answers from Stack Overflow and relevant technical documentation, this article systematically introduces how to implement custom object passing through Intents.

Fundamental Principles of Serializable Interface

Serializable is a marker interface provided by Java that contains no methods. Classes implementing this interface indicate that their instances can be serialized, meaning they can be converted into byte streams for storage or transmission. In Android, Intent's putExtra method supports passing Serializable objects, providing convenience for object transfer between Activities.

Steps to Implement Serializable Interface

First, custom classes need to implement the Serializable interface. Taking a customer class as an example:

import java.io.Serializable;

public class Customer implements Serializable {
    private String firstName;
    private String lastName;
    private int age;
    private String address;
    
    public Customer(String firstName, String lastName, int age, String address) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
        this.address = address;
    }
    
    public String getDisplayInfo() {
        return "Name: " + firstName + " " + lastName + 
               ", Age: " + age + ", Address: " + address;
    }
}

In this example, the Customer class implements the Serializable interface, giving it serialization capability. Note that parameter assignment in the constructor should use the this keyword to avoid field shadowing issues.

Passing Objects in Activities

In the source Activity, create an Intent and add the Serializable object:

// Create Customer object instance
Customer customer = new Customer("John", "Doe", 25, "123 Main Street");

// Create Intent and pass object
Intent intent = new Intent(MainActivity.this, DetailActivity.class);
intent.putExtra("customer_data", customer);
startActivity(intent);

Here, "customer_data" is used as a key to identify the passed object. It's recommended to use meaningful constants to define these key values.

Receiving Objects in Target Activity

In the target Activity, retrieve the passed object through Intent:

// Check if Intent contains specified extra
if (getIntent().hasExtra("customer_data")) {
    // Retrieve and cast object
    Customer receivedCustomer = (Customer) getIntent().getSerializableExtra("customer_data");
    
    // Use received object
    if (receivedCustomer != null) {
        String displayText = receivedCustomer.getDisplayInfo();
        textView.setText(displayText);
    }
}

Null checks should be performed during type casting to avoid ClassCastException.

Serialization Handling for Nested Objects

When custom objects contain other custom objects as member variables, all nested classes must implement the Serializable interface:

public class Order implements Serializable {
    private Customer customer;
    private List<OrderItem> items;
    private Date orderDate;
    
    // Constructors, getters and setters
}

public class OrderItem implements Serializable {
    private String productName;
    private int quantity;
    private double price;
    
    // Constructors, getters and setters
}

This design ensures serialization consistency throughout the object graph, preventing SerializationException.

Performance Comparison: Serializable vs Parcelable

Although Serializable is simple to use, it has performance disadvantages. Serializable uses reflection mechanism for serialization, generating temporary objects and triggering garbage collection, which can become a bottleneck in performance-sensitive scenarios.

In contrast, Parcelable is Android-specific and achieves object serialization through explicit read-write operations with better performance:

public class Customer implements Parcelable {
    private String firstName;
    private String lastName;
    private int age;
    private String address;
    
    // Constructor
    
    protected Customer(Parcel in) {
        firstName = in.readString();
        lastName = in.readString();
        age = in.readInt();
        address = in.readString();
    }
    
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(firstName);
        dest.writeString(lastName);
        dest.writeInt(age);
        dest.writeString(address);
    }
    
    @Override
    public int describeContents() {
        return 0;
    }
    
    public static final Creator<Customer> CREATOR = new Creator<Customer>() {
        @Override
        public Customer createFromParcel(Parcel in) {
            return new Customer(in);
        }
        
        @Override
        public Customer[] newArray(int size) {
            return new Customer[size];
        }
    };
}

Best Practices in Practical Applications

When choosing serialization methods, consider the following factors: Serializable is suitable for simple data transfer and development efficiency; Parcelable is more appropriate for performance-critical scenarios, especially when frequently transferring large amounts of data.

It's recommended to uniformly use constants to define Intent key values in projects:

public class IntentConstants {
    public static final String KEY_CUSTOMER = "customer_data";
    public static final String KEY_ORDER = "order_data";
    // Other constant definitions
}

Additionally, for objects containing sensitive information, consider encryption before serialization to ensure data security.

Common Issues and Solutions

In actual development, common issues may include: exceptions caused by inconsistent serialization versions, nested objects not implementing Serializable interface, performance issues with large objects, etc.

Solutions include: using serialVersionUID field to control version compatibility, ensuring all related classes implement serialization interface, considering database or file storage for large data, etc.

Conclusion

Passing custom objects through Intents is a fundamental skill in Android development. The Serializable interface provides a simple and easy-to-use implementation suitable for most scenarios. Understanding its principles and limitations, combined with selecting appropriate serialization strategies based on specific requirements, can effectively improve application performance and stability. As Android development technology continues to evolve, new data transfer methods like ViewModel and LiveData are becoming increasingly popular, but object passing based on Intents remains a core technology that must be mastered.