Один из вариантов может заключаться в том, чтобы позволить вашему пользовательскому классу реализовать интерфейс Serializable, а затем вы можете передавать экземпляры объекта в намерении extra, используя вариант putExtra(Serializable..) метода Intent#putExtra().

Псевдокод:

//To pass:
intent.putExtra("MyClass", obj);

// To retrieve object in second Activity
getIntent().getSerializableExtra("MyClass");

Примечание. Убедитесь, что в каждом вложенном классе вашего основного настраиваемого класса реализован интерфейс Serializable, чтобы избежать каких-либо исключений сериализации. Например:

class MainClass implements Serializable {

    public MainClass() {}

    public static class ChildClass implements Serializable {

        public ChildClass() {}
    }
}

Реализуйте свой класс с помощью Serializable. Предположим, что это ваш класс сущности:

import java.io.Serializable;

@SuppressWarnings("serial") //With this annotation we are going to hide compiler warnings
public class Deneme implements Serializable {

    public Deneme(double id, String name) {
        this.id = id;
        this.name = name;
    }

    public double getId() {
        return id;
    }

    public void setId(double id) {
        this.id = id;
    }

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    private double id;
    private String name;
}

Мы отправляем объект с именем dene из активности X в активность Y. Где-то в активности X;

Deneme dene = new Deneme(4,"Mustafa");
Intent i = new Intent(this, Y.class);
i.putExtra("sampleObject", dene);
startActivity(i);

В Y-действии мы получаем объект.

Intent i = getIntent();
Deneme dene = (Deneme)i.getSerializableExtra("sampleObject");

Вот и все.

Используйте gson, чтобы преобразовать ваш объект в JSON и передать его через намерение. В новом действии преобразуйте JSON в объект.

В вашем build.gradle добавьте это в свои зависимости

implementation 'com.google.code.gson:gson:2.8.4'

В своей деятельности преобразуйте объект в json-строку:

Gson gson = new Gson();
String myJson = gson.toJson(vp);
intent.putExtra("myjson", myjson);

В получающем действии преобразуйте json-строку обратно в исходный объект:

Gson gson = new Gson();
YourObject ob = gson.fromJson(getIntent().getStringExtra("myjson"), YourObject.class);

Для Kotlin то же самое

Передайте данные

val gson = Gson()
val intent = Intent(this, YourActivity::class.java)
intent.putExtra("identifier", gson.toJson(your_object))
startActivity(intent)

Получите данные

val gson = Gson()
val yourObject = gson.fromJson<YourObject>(intent.getStringExtra("identifier"), YourObject::class.java)

• Использование глобальных статических переменных - не лучшая практика разработки программного обеспечения.
• Преобразование полей объекта в примитивные типы данных может оказаться сложной задачей.
• Использование сериализации - это нормально, но это не снижает производительность на платформе Android.
• Parcelable специально разработан для Android, и вам следует его использовать. Вот простой пример: Передача настраиваемых объектов между Действия для Android

Вы можете сгенерировать код Parcelable для своего класса с помощью этого сайта.

При вызове деятельности

Intent intent = new Intent(fromClass.this,toClass.class).putExtra("myCustomerObj",customerObj);

В toClass.java получите активность от

Customer customerObjInToClass = getIntent().getExtras().getParcelable("myCustomerObj");

Убедитесь, что класс клиента реализует parcelable

public class Customer implements Parcelable {

    private String firstName, lastName, address;
    int age;

    /* all your getter and setter methods */

    public Customer(Parcel in ) {
        readFromParcel( in );
    }

    public static final Parcelable.Creator CREATOR = new Parcelable.Creator() {
        public LeadData createFromParcel(Parcel in ) {
            return new Customer( in );
        }

        public Customer[] newArray(int size) {
            return new Customer[size];
        }
    };


    @Override
    public void writeToParcel(Parcel dest, int flags) {

        dest.writeString(firstName);
        dest.writeString(lastName);
        dest.writeString(address);
        dest.writeInt(age);
    }

    private void readFromParcel(Parcel in ) {

        firstName = in .readString();
        lastName  = in .readString();
        address   = in .readString();
        age       = in .readInt();
    }

По моему опыту, есть три основных решения, каждое со своими недостатками и преимуществами:

1. Реализация Parcelable

2. Реализация Serializable

3. Использование какой-либо облегченной библиотеки шины событий (например, EventBus Greenrobot или Otto Square)

Parcelable - быстрый и стандартный для Android, но имеет много шаблонного кода и требует жестко запрограммированных строк для справки при извлечении значений из намерения (не строго типизированный).

Serializable - почти нулевой шаблон, но это самый медленный подход, а также требует жестко запрограммированных строк при извлечении значений из намерения (не строго типизированный).

Event Bus - нулевой шаблон, самый быстрый подход и не требует жестко запрограммированных строк, но требует дополнительной зависимости (хотя обычно она легковесна, ~ 40 КБ)

Я опубликовал очень подробное сравнение этих трех подходов, включая тесты эффективности.

Я нашел простой и элегантный метод:

• НЕТ посылки
• НЕТ Сериализуемого
• НЕТ статического поля
• Без шины событий

Способ 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 создаст глобальную ссылку JNI для объекта java и выпустит эту глобальную ссылку JNI, когда для этого объекта java нет ссылки. binder сохранит эту глобальную ссылку JNI в объекте Binder.

* ВНИМАНИЕ: этот метод работает ТОЛЬКО, если два действия не выполняются в одном процессе, в противном случае выбросить ClassCastException в (ObjectWrapperForBinder) getIntent (). getExtras (). getBinder ("object_value") *

определение класса ObjectWrapperForBinder

public class ObjectWrapperForBinder extends Binder {

    private final Object mData;

    public ObjectWrapperForBinder(Object data) {
        mData = data;
    }

    public Object getData() {
        return mData;
    }
}

Способ 2

• for the sender,
  1. use custom native method to add your java object to JNI global reference table(via JNIEnv::NewGlobalRef)
  2. поместите возвращаемое целое число (фактически, JNIEnv :: NewGlobalRef return jobject, который является указателем, мы можем безопасно преобразовать его в int) в ваше намерение (через Intent :: putExtra)
• for the receiver
  1. get integer from Intent(via Intent::getInt)
  2. используйте собственный собственный метод для восстановления вашего java-объекта из глобальной справочной таблицы JNI (через JNIEnv :: NewLocalRef)
  3. удалить элемент из глобальной справочной таблицы JNI (через JNIEnv :: DeleteGlobalRef),

Но у метода 2 есть небольшая, но серьезная проблема: если получателю не удается восстановить объект java (например, какое-то исключение происходит перед восстановлением объекта java, или действие получателя вообще не существует), то объект java станет сирота или утечка памяти, метод 1 не имеет этой проблемы, потому что связыватель Android будет обрабатывать это исключение

Способ 3

Чтобы вызвать java-объект удаленно, мы создадим контракт / интерфейс данных для описания java-объекта, мы будем использовать вспомогательный файл

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

Код для второго действия:

измените атрибут android: process в AndroidManifest.xml на непустое имя процесса, чтобы второе действие выполнялось в другом процессе

    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 кажется недостаточно простым, потому что мы должны реализовать вспомогательный интерфейс. Если вы просто хотите выполнить простую задачу, а возвращаемое значение метода не нужно, мы можем использовать 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 также является вспомогательным интерфейсом, если у вас есть исходный код Android, вы можете найти файл с именем IMessenger.aidl

package android.os;

import android.os.Message;

/** @hide */
oneway interface IMessenger {
    void send(in Message msg);
}

Вы также можете записать данные объекта во временные строки и целые числа и передать их действию. Конечно, таким образом вы переносите данные, но не сам объект.

Но если вы просто хотите отобразить их, а не использовать объект в другом методе или что-то в этом роде, этого должно быть достаточно. Я сделал это так же, чтобы просто отобразить данные из одного объекта в другом действии.

String fName_temp   = yourObject.getFname();
String lName_temp   = yourObject.getLname();
String age_temp     = yourObject.getAge();
String address_temp = yourObject.getAddress();

Intent i = new Intent(this, ToClass.class);
i.putExtra("fname", fName_temp);
i.putExtra("lname", lName_temp);
i.putExtra("age", age_temp);
i.putExtra("address", address_temp);

startActivity(i);

Вы также можете передать их напрямую, а не temp ivars, но, на мой взгляд, так будет понятнее. Кроме того, вы можете установить временные ivars на null, чтобы они быстрее очищались GarbageCollector.

Удачи!

Замечание: переопределите toString () вместо написания собственного метода печати.

Как упоминается в комментариях ниже, вот как вы возвращаете свои данные в другом действии:

String fName = getIntent().getExtras().getInt("fname");

Я создал одноэлементный вспомогательный класс, содержащий временные объекты.

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

Внутри вашего нового Activity вы можете получить объект:

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

Имейте в виду, что после загрузки объект удаляется, чтобы избежать ненужных ссылок.

Есть несколько способов получить доступ к переменным или объектам в других классах или Activity.

A. База данных

Б. Общие предпочтения.

C. Сериализация объекта.

D. Класс, который может содержать общие данные, может называться Common Utilities. Это зависит от тебя.

E. Передача данных через намерения и интерфейс Parcelable.

Это зависит от потребностей вашего проекта.

A. База данных

SQLite - это база данных с открытым исходным кодом, встроенная в Android. SQLite поддерживает стандартные функции реляционной базы данных, такие как синтаксис SQL, транзакции и подготовленные операторы.

Руководства

Б. Общие настройки

Предположим, вы хотите сохранить имя пользователя. Итак, теперь будет две вещи: ключ имя пользователя и значение.

Как хранить

 // 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 (), putInt (), putFloat () и putLong (), вы можете сохранить желаемый тип данных.

Как получить

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

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

C. Сериализация объекта

Сериализация объекта используется, если мы хотим сохранить состояние объекта, чтобы отправить его по сети, или вы также можете использовать его для своих целей.

Используйте Java beans и сохраните его как одно из его полей, а для этого используйте геттеры и сеттеры.

JavaBeans - это классы Java, у которых есть свойства. Думайте о свойствах как о частных переменных экземпляра. Поскольку они являются частными, единственный способ получить к ним доступ извне своего класса - это использовать методы в классе. Методы, которые изменяют значение свойства, называются методами установки, а методы, которые получают значение свойства, называются методами получения.

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. CommonUtilities

Вы можете сами создать класс, который может содержать общие данные, которые вам часто нужны в вашем проекте.

Образец

public class CommonUtilities {

    public static String className = "CommonUtilities";

}

E. Передача данных через намерения

См. Руководство Android - данные Parcel для передачи между действиями с использованием классов Parcelable для этой опции передачи данных.

Создайте свой собственный класс Customer следующим образом:

import import java.io.Serializable;
public class Customer implements Serializable
{
    private String name;
    private String city;

    public Customer()
    {

    }
    public Customer(String name, String city)
    {
        this.name= name;
        this.city=city;
    }
    public String getName() 
    {
        return name;
    }
    public void setName(String name) 
    {
        this.name = name;
    }
    public String getCity() 
    {
        return city;
    }
    public void setCity(String city) 
    {
        this.city= city;
    }

}

В вашем onCreate() методе

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

    Customer cust=new Customer();
    cust.setName("abc");
    cust.setCity("xyz");

    Intent intent=new Intent(abc.this,xyz.class);
    intent.putExtra("bundle",cust);
    startActivity(intent); 
}

В классе xyz activity вам нужно использовать следующий код:

Intent intent=getIntent();
Customer cust=(Customer)intent.getSerializableExtra("bundle");
textViewName.setText(cust.getName());
textViewCity.setText(cust.getCity());

public class MyClass implements Serializable{
    Here is your instance variable
}

Теперь вы хотите передать объект этого класса в startActivity. Просто используйте это:

Bundle b = new Bundle();
b.putSerializable("name", myClassObject);
intent.putExtras(b);

Здесь это работает, потому что MyClass реализует Serializable.

Лучше всего иметь в вашем приложении класс (назовите его Control), который будет содержать статическую переменную типа «Клиент» (в вашем случае). Инициализируйте переменную в своем действии A.

Например:

Control.Customer = CustomerClass;

Затем перейдите к Activity B и получите его из класса Control. Не забудьте присвоить значение null после использования переменной, иначе память будет потрачена впустую.

Если вы выберете использование способа, описанного Саму, помните, что можно отправлять только примитивные значения. То есть значения, которые можно парсить. Итак, если ваш объект содержит сложные объекты, они не последуют. Например, такие переменные, как Bitmap, HashMap и т. Д. ... Их сложно передать с помощью намерения.

В общем, я бы посоветовал вам отправлять только примитивные типы данных в качестве дополнительных, например String, int, boolean и т. Д. В вашем случае это будут: String fname, String lname, int age и String address.

Мое мнение: для более сложных объектов лучше использовать ContentProvider, SDCard и т. Д. Также можно использовать статическую переменную, но это может быстро привести к ошибочному коду ...

Но опять же, это всего лишь мое субъективное мнение.

Я использую 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});
    }
}

В activityA используйте это так:

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

Вы можете попробовать использовать этот класс. Ограничение в том, что его нельзя использовать вне одного процесса.

Одно мероприятие:

 final Object obj1 = new Object();
 final Intent in = new Intent();
 in.putExtra(EXTRA_TEST, new Sharable(obj1));

Другая деятельность:

final Sharable s = in.getExtras().getParcelable(EXTRA_TEST);
final Object obj2 = s.obj();

public final class Sharable implements Parcelable {

    private Object mObject;

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


        @Override
        public Sharable[] newArray(int size) {
            return new Sharable[size];
        }
    };

    public Sharable(final Object obj) {
        mObject = obj;
    }

    public Sharable(Parcel in ) {
        readFromParcel( in );
    }

    Object obj() {
        return mObject;
    }


    @Override
    public int describeContents() {
        return 0;
    }


    @Override
    public void writeToParcel(final Parcel out, int flags) {
        final long val = SystemClock.elapsedRealtime();
        out.writeLong(val);
        put(val, mObject);
    }

    private void readFromParcel(final Parcel in ) {
        final long val = in .readLong();
        mObject = get(val);
    }

    /////

    private static final HashMap < Long, Object > sSharableMap = new HashMap < Long, Object > (3);

    synchronized private static void put(long key, final Object obj) {
        sSharableMap.put(key, obj);
    }

    synchronized private static Object get(long key) {
        return sSharableMap.remove(key);
    }
}

Запустите другое действие из этого действия и передайте параметры через объект Bundle

Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("USER_NAME", "[email protected]");
startActivity(intent);

Получение данных о другом действии (YourActivity)

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

Это нормально для простого типа данных. Но если вы хотите передавать сложные данные между действиями. Вам нужно сначала сериализовать его.

Здесь у нас есть модель сотрудника

class Employee{
    private String empId;
    private int age;
    print Double salary;

    getters...
    setters...
}

Вы можете использовать Gson lib, предоставленную Google, для сериализации таких сложных данных, как это

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

Этот вопрос также обсуждается в другом вопросе о переполнении стека. Ознакомьтесь с решением для передачи данных через намеренное использование Сериализуемый. Главное - использовать объект 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, используя:

1. онлайн-инструмент - parcelabler
2. плагин для Android Studio - Генератор кода Android Parcelable

Создайте класс, подобный классу bean, и реализуйте интерфейс Serializable. Затем мы можем передать его через метод intent, например:

intent.putExtra("class", BeanClass);

Затем получите его из другого действия, например:

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

Создайте два метода в своем пользовательском классе, как это

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

Объекты Android Activity можно уничтожать и восстанавливать. Итак, вам нужно будет использовать другой подход для просмотра их - или любого объекта, который они создают !!! - вверх. То есть вы можете передать ссылку на статический класс, но тогда дескриптор объекта (Java вызывает эти ссылки, как и SmallTalk; но они не являются ссылками в смысле C или сборки), возможно, позже станет недействительным, поскольку функция Android OE является любая Деятельность может быть аннигилирована и воссоздана позже.

В исходном вопросе был задан вопрос: «Как передать объект из одного действия в другое в Android», но никто не ответил на этот вопрос. Конечно, вы можете сериализовать (Serializable, Parcelable, в / из JSON) и передать копию данных объекта, и можно будет создать новый объект с такими же данными; но у него НЕ будет одинаковых ссылок / дескрипторов. Кроме того, многие другие упоминали, что вы можете хранить ссылку в статическом хранилище. И это будет работать, если Android не решит уничтожить вашу Activity.

Итак, чтобы действительно решить исходный вопрос, вам понадобится статический поиск, плюс каждый объект будет обновлять свою ссылку, когда / если он будет воссоздан. Например. каждое действие Android будет обновляться, если будет вызвано его onCreate. Вы также можете увидеть, как некоторые люди используют список задач для поиска Activity по имени. (система временно уничтожает этот экземпляр действия, чтобы сэкономить место. getRunningTasks, список задач фактически является специализированным списком самых последних экземпляров объекта каждого действия).

Для справки:

Остановлено: действие полностью скрыто другим действием (действие теперь находится в фоновом режиме). Остановленное действие также остается активным (объект Activity сохраняется в памяти, он поддерживает всю информацию о состоянии и членах, но не прикреплен к диспетчеру окон). Однако он больше не виден пользователю и может быть уничтожен системой, когда память потребуется где-то еще.

Система onDestroy временно уничтожает этот экземпляр активности для экономии места.

Итак, шина сообщений - это работоспособное решение. Это в основном панк. Вместо того, чтобы пытаться иметь ссылки на объекты; затем вы переделываете свой дизайн, чтобы использовать MessagePassing вместо SequentialCode. Экспоненциально сложнее отлаживать; но это позволяет вам игнорировать такого рода понимание операционной среды. Фактически, каждый доступ к методу объекта инвертируется, поэтому вызывающий объект отправляет сообщение, а сам объект определяет обработчик для этого сообщения. Намного больше кода, но можно сделать его более надежным с учетом ограничений Android OE.

Если все, что вам нужно, - это верхняя активность (типичная вещь в приложениях Android из-за того, что контекст требуется везде), тогда вы можете просто указать каждое действие как верхнее в статическом глобальном пространстве при каждом вызове его onResume. Затем ваш AlertDialog или что-то еще, что требует контекста, может просто взять его оттуда. Кроме того, немного неприятно использовать глобальный, но он может упростить передачу контекста вверх и вниз повсюду, и, конечно же, когда вы используете MessageBus, тогда он в любом случае глобален.

Да, использование статического объекта - это, безусловно, самый простой способ сделать это с помощью нестандартных несериализуемых объектов.

1. Я знаю, что статика - это плохо, но, похоже, мы вынуждены здесь ее использовать. Проблема с parceables / seriazables заключается в том, что у двух действий есть повторяющиеся экземпляры одного и того же объекта = трата памяти и ЦП.

   public class IntentMailBox {
       static Queue<Object> content = new LinkedList<Object>();
   }
   

Вызов активности

IntentMailBox.content.add(level);
Intent intent = new Intent(LevelsActivity.this, LevelActivity.class);
startActivity(intent);

Вызываемое действие (обратите внимание, что onCreate () и onResume () могут вызываться несколько раз, когда система уничтожает и воссоздает действия)

if (IntentMailBox.content.size()>0)
    level = (Level) IntentMailBox.content.poll();
else
    // Here you reload what you have saved in onPause()

2. Другой способ - объявить статическое поле класса, который вы хотите передать в этот самый класс. Он будет служить только для этой цели. Не забывайте, что он может иметь значение null в onCreate, потому что ваш пакет приложения был выгружен из памяти системой и перезагружен позже.

3. Помня, что вам все еще нужно обрабатывать жизненный цикл активности, вы можете захотеть записать все данные прямо в общие настройки, что затруднительно для сложных структур данных как таковых.

Вышеупомянутые ответы почти все верны, но для тех, кто не понимает этих ответов, Android имеет мощный класс Intent, с его помощью вы обмениваетесь данными не только между действиями, но и другими компонентами Android (приемник вещания, услуги для контента при условии, что мы используем класс ContetnResolver без намерения). В своей деятельности вы строите намерение

Intent intent = new Intent(context,SomeActivity.class);
intent.putExtra("key",value);
startActivity(intent);

В вашей принимающей деятельности у вас есть

public class SomeActivity extends AppCompactActivity {

    public void onCreate(...){
    ...
          SomeObject someObject = getIntent().getExtras().getParceable("key");
    }

}

Вы должны реализовать интерфейс Parceable или Serializable для своего объекта, чтобы делиться между действиями. Сложно реализовать интерфейс Parcealbe вместо Serializable на объекте, поэтому в Android есть специальный плагин для этого. Загрузите его и используйте

Я всегда задавался вопросом, почему это не может быть так же просто, как вызов метода другого действия. Недавно я написал служебную библиотеку, которая делает ее почти такой же простой. Вы можете проверить это здесь (https://github.com/noxiouswinter/gnlib_android/wiki/gnlauncher < / а>).

public interface IPayload {
    public void sayHello(String name, int age);
}

public class Activity_1 extends Activity implements IPayload {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //Notify GNLauncher when the Activity is ready. 
        GNLauncher.get().ping(this);
    }

    @Override
    public void sayHello(String name, int age) {
        Log.d("gnlib_test", "Hello " + name + "! \nYour age is: " + age);
    }
}

public class Activity_2 extends Activity {
    public void onClick(View v) {
        ((IPayload)GNLauncher.get().getProxy(this, IPayload.class, Activity_1.class)).sayHello(name, age);
    }
}

См. https://github.com/noxiouswinter/gnlib_android/wiki#prerequisites для информация о том, как добавить зависимости.

Перенести объект из одного действия в другое.

(1) исходная активность

Intent ii = new Intent(examreport_select.this,
                    BarChartActivity.class);

            ii.putExtra("IntentExamResultDetail",
                    (Serializable) your List<ArraList<String>> object here);
            startActivity(ii);

(2) активность назначения

List<ArrayList<String>> aa = (List<ArrayList<String>>) getIntent()
            .getSerializableExtra("IntentExamResultDetail");

Раньше я устанавливал объект с помощью Pacelable или Serializable для передачи, но всякий раз, когда я добавляю другие переменные к объекту (модели), я должен все это зарегистрировать. Это так неудобно.

Перемещать объект между активностями или фрагментами очень просто.

Android DataCache

Мы можем передать объект из одного действия в другое:

SupplierDetails poSuppliersDetails = new SupplierDetails();

Внутри poSuppliersDetails у нас есть несколько значений. Теперь я отправляю этот объект в целевую активность:

Intent iPODetails = new Intent(ActivityOne.this, ActivityTwo.class);
iPODetails.putExtra("poSuppliersDetails", poSuppliersDetails);

Как получить это в ACtivityTwo:

private SupplierDetails supplierDetails;
    supplierDetails =(SupplierDetails) getIntent().getSerializableExtra("poSuppliersDetails");

Передайте одно действие другому:

startActivity(new Intent(getBaseContext(),GetActivity.class).putExtra("passingkey","passingvalue"));

Получите значения:

String myvalue= getIntent().getExtras("passingkey");

Невозможно сериализовать объекты любого типа. Например, вы не можете сериализовать методы делегата или интерфейсы, которые несут код вместо данных. Итак, я написал класс Box, который можно использовать для передачи любого типа данных без сериализации.

1- для целевого использования данных:

Intent I = new Intent(this, YourActivity.class);
CustomClass Date = new CustomClass();
Box.Add(I, "Name", Data);

2- для получения данных из намерения:

CustomClass Data = Box.Get(getIntent(), "Name");

3- для удаления данных после использования добавьте этот метод к своим действиям:

@Override
protected void onDestroy() {
    Box.Remove(getIntent());
    super.onDestroy();
}

4- и добавьте этот код в свой проект:

package ir.namirasoft.Utility;

import android.content.Intent;

import java.util.HashMap;
import java.util.Vector;

public class Box {
    // Number
    private static int Number = 1;

    public static int NextNumber() {
        return Number++;
    }

    //
    private static String _Intent_Identifier = "_Intent_Identifier";
    private static HashMap<Integer, Vector<Integer>> DeleteList = new HashMap<Integer, Vector<Integer>>();
    private static HashMap<Integer, HashMap<String, Object>> ObjectList = new HashMap<Integer, HashMap<String, Object>>();

    public static int GetIntent_Identifier(Intent I) {
        int Intent_Identifier = I.getIntExtra(_Intent_Identifier, 0);
        if (Intent_Identifier == 0)
            I.putExtra(_Intent_Identifier, Intent_Identifier = NextNumber());
        return Intent_Identifier;
    }

    public static void Add(Intent I, String Name, Object O) {
        int Intent_Identifier = GetIntent_Identifier(I);
        synchronized (ObjectList) {
            if (!ObjectList.containsKey(Intent_Identifier))
                ObjectList.put(Intent_Identifier, new HashMap<String, Object>());
            ObjectList.get(Intent_Identifier).put(Name, O);
        }
    }

    public static <T> T Get(Intent I, String Name) {
        int Intent_Identifier = GetIntent_Identifier(I);
        synchronized (DeleteList) {
            DeleteList.remove(Intent_Identifier);
        }
        return (T) ObjectList.get(Intent_Identifier).get(Name);
    }

    public static void Remove(final Intent I) {
        final int Intent_Identifier = GetIntent_Identifier(I);
        final int ThreadID = NextNumber();
        synchronized (DeleteList) {
            if (!DeleteList.containsKey(Intent_Identifier))
                DeleteList.put(Intent_Identifier, new Vector<Integer>());
            DeleteList.get(Intent_Identifier).add(ThreadID);
        }
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(60 * 1000);
                } catch (InterruptedException e) {
                }
                synchronized (DeleteList) {
                    if (DeleteList.containsKey(Intent_Identifier))
                        if (DeleteList.get(Intent_Identifier).contains(ThreadID))
                            synchronized (ObjectList) {
                                ObjectList.remove(Intent_Identifier);
                            }
                }
            }
        }).start();
    }
}

** Класс Box является потокобезопасным.

Я написал библиотеку под названием intentparser.

Его действительно легко использовать. Добавьте это в свой проект.

allprojects {
        repositories {
            ...
            maven { url 'https://jitpack.io' }
        }
    }

Добавьте это в свое приложение gradle

dependencies {
            implementation 'com.github.lau1944:intentparser:v$currentVersion'
    }

Передать объект с помощью метода расширения putObject

val testModel = TestModel(
            text = "hello world",
            isSuccess = false,
            testNum = 1,
            textModelSec = TextModelSec("second model")
)
startActivity(
     Intent(this, ActivityTest::class.java).apply {
          this.putObject(testModel)
     }
) 

Получить объект из предыдущего действия

val testModel = intent.getObject(TestModel::class.java)

Привет всем, я вижу много хороших вариантов, но мне было интересно, почему не использовалась привязка?

Передача ссылки на объект кажется мне более эффективной, чем сериализация и деэтерилизация объектов, но я не делал глубокого погружения, чтобы увидеть, происходит ли это за кулисами.

Создать подшивку достаточно просто ...

public class MyBinder extends Binder {

    private Object myObject;

    public MyBinder(Object object) {
        myObject = object;
    }

    public Object getObject() {
        return myObject;
    }

}

И создание пакета для использования - это не такой уж и плохой эфир.

public class MyParcelable implements Parcelable {

    private Object myObject;

    public MyParcelable() {
    }

    public MyParcelable(Parcel parcel) {
        myObject = ((MyBinder)parcel.readStrongBinder()).getObject();
    }

    public void setObject(Object object) {
        myObject = object;
    }

    public Object getObject() {
        return myObject;
    }

    public void writeToParcel(Parcel parcel, int flags) {
        parcel.writeStrongBinder(new MyBinder(myObject));
    }

    public int describeContents() {
        return myObject == null ? 0 : 1;
    }

    public static final Parcelable.Creator<MyParcelable> CREATOR = new Parcelable.Creator<MyParcelable>() {

        public MyParcelable createFromParcel(Parcel parcel) {
            return new MyParcelable(parcel);
        }

        public MyParcelable[] newArray(int length) {
            return new MyParcelable[length];
        }

    };
}

Эта логика действительно хороша, потому что вы фактически передаете ссылку из активности в действие.

Я бы посоветовал проверить наличие нулей, и если instanceof Binder является MyBinder!

и чтобы реализовать это, вы просто ...

Отправь это

Object myObject = "some object";
MyParcelable myParcelable = new MyParcelable();
myParcelable.setObject(myObject);

intent.putExtra("MyParcelable", myParcelable);

Верни это

myParcelable = (MyParcelable) getIntent().getExtras().getParcelable("MyParcelable");
myObject = myParcelable.getObject();

Черт возьми, кто-то может сойти с ума и сделать эту присоску настоящим универсалом.

Как упоминалось в комментариях, этот ответ нарушает инкапсуляцию и тесно связывает компоненты, что является скорее всего, не то, что вы хотите. Лучшее решение, вероятно, сделать ваш объект Parcelable или Serializable, как объясняют другие ответы. Сказав это, решение решает проблему. Итак, если вы знаете, что делаете:

Используйте класс со статическими полями:

public class Globals {
    public static Customer customer = new Customer();
}

Внутри занятий вы можете использовать:

Активность с:

Globals.customer = myCustomerFromActivity;

Цель деятельности:

myCustomerTo = Globals.customer;

Это простой способ передать информацию о занятиях.