Como enviar um objeto de uma Atividade Android para outro usando Intents?

Como posso passar um objeto de um tipo personalizado de uma atividade para outra usando o putExtra()método da classe Intent ?

Se você está apenas passando objetos, o Parcelable foi projetado para isso. Requer um pouco mais de esforço do que usar a serialização nativa de Java, mas é muito mais rápido (e quero dizer, MUITO MAIS rápido).

Nos documentos, um exemplo simples de como implementar é:

// simple class that just has one member property as an example
public class MyParcelable implements Parcelable {
    private int mData;

    /* everything below here is for implementing Parcelable */

    // 99.9% of the time you can just ignore this
    @Override
    public int describeContents() {
        return 0;
    }

    // write your object's data to the passed-in Parcel
    @Override
    public void writeToParcel(Parcel out, int flags) {
        out.writeInt(mData);
    }

    // this is used to regenerate your object. All Parcelables must have a CREATOR that implements these two methods
    public static final Parcelable.Creator<MyParcelable> CREATOR = new Parcelable.Creator<MyParcelable>() {
        public MyParcelable createFromParcel(Parcel in) {
            return new MyParcelable(in);
        }

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

    // example constructor that takes a Parcel and gives you an object populated with it's values
    private MyParcelable(Parcel in) {
        mData = in.readInt();
    }
}

Observe que, no caso de você ter mais de um campo para recuperar de um determinado pacote, você deve fazer isso na mesma ordem em que os colocou (ou seja, em uma abordagem FIFO).

Depois de ter seus objetos implementar Parcelableé apenas uma questão de colocá-los em suas Intenções com putExtra () :

Intent i = new Intent();
i.putExtra("name_of_extra", myParcelableObject);

Em seguida, você pode recuperá- los com getParcelableExtra () :

Intent i = getIntent();
MyParcelable myParcelableObject = (MyParcelable) i.getParcelableExtra("name_of_extra");

Se sua classe de objeto implementa Parcelable e Serializable, certifique-se de converter para um dos seguintes:

i.putExtra("parcelable_extra", (Parcelable) myParcelableObject);
i.putExtra("serializable_extra", (Serializable) myParcelableObject);

Você precisará serializar seu objeto em algum tipo de representação de string. Uma possível representação de cadeia de caracteres é JSON, e uma das maneiras mais fáceis de serializar de / para JSON no Android, se você me perguntar, é pelo Google GSON .

Nesse caso, basta colocar o valor de retorno da string (new Gson()).toJson(myObject);e recuperar o valor da string e usá fromJson-lo para transformá-lo novamente em seu objeto.

Se seu objeto não for muito complexo, no entanto, pode não valer a pena a sobrecarga, e você pode considerar a possibilidade de passar os valores separados do objeto.

Você pode enviar um objeto serializável através da intenção

// send where details is object
ClassName details = new ClassName();
Intent i = new Intent(context, EditActivity.class);
i.putExtra("Editing", details);
startActivity(i);


//receive
ClassName model = (ClassName) getIntent().getSerializableExtra("Editing");

And 

Class ClassName implements Serializable {
} 

Para situações em que você sabe que passará dados dentro de um aplicativo, use "globais" (como Classes estáticas)

Aqui está o que Dianne Hackborn (hackbod - uma engenheira de software do Google Android) disse sobre o assunto:

Para situações em que você sabe que as atividades estão em execução no mesmo processo, basta compartilhar dados por meio de globais. Por exemplo, você pode ter um global HashMap<String, WeakReference<MyInterpreterState>> e, ao criar um novo MyInterpreterState, criar um nome exclusivo para ele e colocá-lo no mapa de hash; para enviar esse estado para outra atividade, basta colocar o nome exclusivo no mapa de hash e, quando a segunda atividade for iniciada, ele poderá recuperar MyInterpreterState do mapa de hash com o nome que recebe.

Sua classe deve implementar Serializable ou Parcelable.

public class MY_CLASS implements Serializable

Uma vez feito, você pode enviar um objeto em putExtra

intent.putExtra("KEY", MY_CLASS_instance);

startActivity(intent);

Para obter extras, você só precisa fazer

Intent intent = getIntent();
MY_CLASS class = (MY_CLASS) intent.getExtras().getSerializable("KEY");

Se sua turma implementa o Parcelable use next

MY_CLASS class = (MY_CLASS) intent.getExtras().getParcelable("KEY");

Espero que ajude: D

Resposta curta para necessidade rápida

1. Implemente sua classe para serializável.

Se você tem alguma classe interna, não se esqueça de implementá-la também em serializável !!

public class SportsData implements  Serializable
public class Sport implements  Serializable

List<Sport> clickedObj;

2. Coloque seu objeto em intenção

 Intent intent = new Intent(SportsAct.this, SportSubAct.class);
            intent.putExtra("sport", clickedObj);
            startActivity(intent);

3. E receba seu objeto na outra classe de atividade

Intent intent = getIntent();
    Sport cust = (Sport) intent.getSerializableExtra("sport");

se sua classe de objeto é implementada Serializable, você não precisa fazer mais nada, pode transmitir um objeto serializável.
é isso que eu uso.

implementar serializável em sua classe

public class Place implements Serializable{
        private int id;
        private String name;

        public void setId(int id) {
           this.id = id;
        }
        public int getId() {
           return id;
        }
        public String getName() {
           return name;
        }

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

Então você pode passar este objeto na intenção

     Intent intent = new Intent(this, SecondAct.class);
     intent.putExtra("PLACE", Place);
     startActivity(intent);

int a segunda atividade, você pode obter dados como este

     Place place= (Place) getIntent().getSerializableExtra("PLACE");

Mas quando os dados se tornarem grandes, esse método será lento.

Você pode usar o pacote Android para fazer isso.

Crie um pacote da sua classe como:

public Bundle toBundle() {
    Bundle b = new Bundle();
    b.putString("SomeKey", "SomeValue");

    return b;
}

Em seguida, passe este pacote com INTENT. Agora você pode recriar seu objeto de classe passando o pacote como

public CustomClass(Context _context, Bundle b) {
    context = _context;
    classMember = b.getString("SomeKey");
}

Declare isso em sua classe Personalizada e use.

Existem algumas maneiras pelas quais você pode acessar variáveis ​​ou objetos em outras classes ou atividades.

A. Banco de Dados

B. preferências compartilhadas.

C. Serialização de objetos.

D. Uma classe que pode conter dados comuns pode ser denominada Utilitários comuns, depende de você.

E. Passagem de dados através de Intents e Parcelable Interface.

Depende das necessidades do seu projeto.

A. Banco de Dados

SQLite é um banco de dados de código-fonte aberto que é incorporado ao Android. O SQLite suporta recursos padrão de banco de dados relacional, como sintaxe SQL, transações e instruções preparadas.

Tutoriais - http://www.vogella.com/articles/AndroidSQLite/article.html

B. Preferências compartilhadas

Suponha que você queira armazenar o nome de usuário. Portanto, agora haverá duas coisas: um Nome de Usuário Chave , Valor Valor.

Como guardar

 // Create an 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();

Usando putString (), putBoolean (), putInt (), putFloat (), putLong (), você pode salvar o tipo de dt desejado.

Como buscar

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

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

C. Serialização de objetos

A serialização de objetos é usada se queremos salvar um estado de objeto para enviá-lo pela rede ou você pode usá-lo também para sua finalidade.

Use java beans e armazene-o como um de seus campos e use getters e setter para isso

JavaBeans são classes Java que possuem propriedades. Pense nas propriedades como variáveis ​​de instância privada. Como eles são particulares, a única maneira de acessá-los de fora da classe é através dos métodos da classe. Os métodos que alteram o valor de uma propriedade são chamados métodos setter, e os métodos que recuperam o valor de uma propriedade são chamados métodos getter.

public class VariableStorage implements Serializable  {

    private String inString ;

    public String getInString() {
        return inString;
    }

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


}

Defina a variável no seu método de email usando

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

Em seguida, use Serialzation do objeto para serializar esse objeto e em sua outra classe desserialize esse objeto.

Na serialização, um objeto pode ser representado como uma sequência de bytes que inclui os dados do objeto, além de informações sobre o tipo do objeto e os tipos de dados armazenados no objeto.

Depois que um objeto serializado é gravado em um arquivo, ele pode ser lido e desserializado, ou seja, as informações de tipo e bytes que representam o objeto e seus dados podem ser usados ​​para recriar o objeto na memória.

Se você deseja um tutorial para isso, consulte este link

http://javawithswaranga.blogspot.in/2011/08/serialization-in-java.html

Obter variável em outras classes

D. Utilidades comuns

Você pode fazer uma aula por si mesmo, que pode conter dados comuns que você precisa com freqüência em seu projeto.

Amostra

public class CommonUtilities {

    public static String className = "CommonUtilities";

}

E. Passando dados por meio de intenções

Por favor, consulte este tutorial para esta opção de transmissão de dados.

http://shri.blog.kraya.co.uk/2010/04/26/android-parcel-data-to-pass-between-activities-using-parcelable-classes/

Obrigado pela ajuda parcelável, mas encontrei mais uma solução opcional

 public class getsetclass implements Serializable {
        private int dt = 10;
    //pass any object, drwabale 
        public int getDt() {
            return dt;
        }

        public void setDt(int dt) {
            this.dt = dt;
        }
    }

Na Atividade Um

getsetclass d = new getsetclass ();
                d.setDt(50);
                LinkedHashMap<String, Object> obj = new LinkedHashMap<String, Object>();
                obj.put("hashmapkey", d);
            Intent inew = new Intent(SgParceLableSampelActivity.this,
                    ActivityNext.class);
            Bundle b = new Bundle();
            b.putSerializable("bundleobj", obj);
            inew.putExtras(b);
            startActivity(inew);

Obter dados na atividade 2

 try {  setContentView(R.layout.main);
            Bundle bn = new Bundle();
            bn = getIntent().getExtras();
            HashMap<String, Object> getobj = new HashMap<String, Object>();
            getobj = (HashMap<String, Object>) bn.getSerializable("bundleobj");
            getsetclass  d = (getsetclass) getobj.get("hashmapkey");
        } catch (Exception e) {
            Log.e("Err", e.getMessage());
        }

Eu uso o Gson com sua API tão poderosa e simples para enviar objetos entre atividades,

Exemplo

// This is the object to be sent, can be any object
public class AndroidPacket {

    public String CustomerName;

   //constructor
   public AndroidPacket(String cName){
       CustomerName = cName;
   }   
   // other fields ....


    // You can add those functions as LiveTemplate !
    public String toJson() {
        Gson gson = new Gson();
        return gson.toJson(this);
    }

    public static AndroidPacket fromJson(String json) {
        Gson gson = new Gson();
        return gson.fromJson(json, AndroidPacket.class);
    }
}

2 funções que você as adiciona aos objetos que deseja enviar

Uso

Enviar objeto de A para B

    // Convert the object to string using Gson
    AndroidPacket androidPacket = new AndroidPacket("Ahmad");
    String objAsJson = androidPacket.toJson();

    Intent intent = new Intent(A.this, B.class);
    intent.putExtra("my_obj", objAsJson);
    startActivity(intent);

Receber em B

@Override
protected void onCreate(Bundle savedInstanceState) {        
    Bundle bundle = getIntent().getExtras();
    String objAsJson = bundle.getString("my_obj");
    AndroidPacket androidPacket = AndroidPacket.fromJson(objAsJson);

    // Here you can use your Object
    Log.d("Gson", androidPacket.CustomerName);
}

Eu o uso quase em todos os projetos que faço e não tenho problemas de desempenho.

Eu lutei com o mesmo problema. Eu o resolvi usando uma classe estática, armazenando quaisquer dados que eu desejasse em um HashMap. No topo, uso uma extensão da classe Activity padrão, onde substituí os métodos onCreate an onDestroy para fazer o transporte e a limpeza de dados ocultos. Algumas configurações ridículas precisam ser alteradas, por exemplo, manipulação de orientação.

Anotação: Não fornecer objetos gerais a serem passados ​​para outra atividade é um problema. É como dar um tiro no joelho e esperar ganhar 100 metros. "Parcable" não é um substituto suficiente. Isso me faz rir ... Não quero implementar essa interface na minha API livre de tecnologia, pois menos quero introduzir uma nova Camada ... Como poderia ser, estarmos em programação móvel tão longe de nós? paradigma moderno ...

Na sua primeira atividade:

intent.putExtra("myTag", yourObject);

E no seu segundo:

myCustomObject myObject = (myCustomObject) getIntent().getSerializableExtra("myTag");

Não se esqueça de tornar seu objeto personalizado serializável:

public class myCustomObject implements Serializable {
...
}

Outra maneira de fazer isso é usar o Applicationobjeto (android.app.Application). Você define isso em seu AndroidManifest.xmlarquivo como:

<application
    android:name=".MyApplication"
    ...

Você pode chamar isso de qualquer atividade e salvar o objeto na Applicationclasse.

Na FirstActivity:

MyObject myObject = new MyObject();
MyApplication app = (MyApplication) getApplication();
app.setMyObject(myObject);

No SecondActivity, faça:

MyApplication app = (MyApplication) getApplication();
MyObject retrievedObject = app.getMyObject(myObject);

Isso é útil se você tiver objetos com escopo no nível do aplicativo, ou seja, eles devem ser usados ​​em todo o aplicativo. O Parcelablemétodo ainda é melhor se você deseja controle explícito sobre o escopo do objeto ou se o escopo é limitado.

Isso evita o uso de todos Intents, no entanto. Não sei se eles combinam com você. Outra maneira que usei isso é fazer com que os intidentificadores de objetos sejam enviados através de intenções e recuperem objetos que eu tenho no Maps no Applicationobjeto.

no seu modelo de classe (Object), implemente Serializable, por exemplo:

public class MensajesProveedor implements Serializable {

    private int idProveedor;


    public MensajesProveedor() {
    }

    public int getIdProveedor() {
        return idProveedor;
    }

    public void setIdProveedor(int idProveedor) {
        this.idProveedor = idProveedor;
    }


}

e sua primeira atividade

MensajeProveedor mp = new MensajeProveedor();
Intent i = new Intent(getApplicationContext(), NewActivity.class);
                i.putExtra("mensajes",mp);
                startActivity(i);

e sua segunda atividade (NewActivity)

        MensajesProveedor  mensajes = (MensajesProveedor)getIntent().getExtras().getSerializable("mensajes");

boa sorte!!

public class SharedBooking implements Parcelable{

    public int account_id;
    public Double betrag;
    public Double betrag_effected;
    public int taxType;
    public int tax;
    public String postingText;

    public SharedBooking() {
        account_id = 0;
        betrag = 0.0;
        betrag_effected = 0.0;
        taxType = 0;
        tax = 0;
        postingText = "";
    }

    public SharedBooking(Parcel in) {
        account_id = in.readInt();
        betrag = in.readDouble();
        betrag_effected = in.readDouble();
        taxType = in.readInt();
        tax = in.readInt();
        postingText = in.readString();
    }

    public int getAccount_id() {
        return account_id;
    }
    public void setAccount_id(int account_id) {
        this.account_id = account_id;
    }
    public Double getBetrag() {
        return betrag;
    }
    public void setBetrag(Double betrag) {
        this.betrag = betrag;
    }
    public Double getBetrag_effected() {
        return betrag_effected;
    }
    public void setBetrag_effected(Double betrag_effected) {
        this.betrag_effected = betrag_effected;
    }
    public int getTaxType() {
        return taxType;
    }
    public void setTaxType(int taxType) {
        this.taxType = taxType;
    }
    public int getTax() {
        return tax;
    }
    public void setTax(int tax) {
        this.tax = tax;
    }
    public String getPostingText() {
        return postingText;
    }
    public void setPostingText(String postingText) {
        this.postingText = postingText;
    }
    public int describeContents() {
        // TODO Auto-generated method stub
        return 0;
    }
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(account_id);
        dest.writeDouble(betrag);
        dest.writeDouble(betrag_effected);
        dest.writeInt(taxType);
        dest.writeInt(tax);
        dest.writeString(postingText);

    }

    public static final Parcelable.Creator<SharedBooking> CREATOR = new Parcelable.Creator<SharedBooking>()
    {
        public SharedBooking createFromParcel(Parcel in)
        {
            return new SharedBooking(in);
        }
        public SharedBooking[] newArray(int size)
        {
            return new SharedBooking[size];
        }
    };

}

Passando os dados:

Intent intent = new Intent(getApplicationContext(),YourActivity.class);
Bundle bundle = new Bundle();
i.putParcelableArrayListExtra("data", (ArrayList<? extends Parcelable>) dataList);
intent.putExtras(bundle);
startActivity(intent);

Recuperando os dados:

Bundle bundle = getIntent().getExtras();
dataList2 = getIntent().getExtras().getParcelableArrayList("data");

a solução mais fácil que encontrei é .. criar uma classe com membros de dados estáticos com setters de getters.

definir a partir de uma atividade e obter de outra atividade esse objeto.

atividade A

mytestclass.staticfunctionSet("","",""..etc.);

atividade b

mytestclass obj= mytestclass.staticfunctionGet();

você pode usar os métodos putExtra (Serializable ..) e getSerializableExtra () para passar e recuperar objetos do seu tipo de classe; você terá que marcar sua classe como serializável e verifique se todas as suas variáveis ​​de membro também são serializáveis ​​...

Criar aplicativo Android

Arquivo >> Novo >> Aplicativo para Android

Digite o nome do projeto: android-pass-object-to-activity

Pakcage: com.hmkcode.android

Mantenha outras seleções padrão, vá em Avançar até chegar em Concluir

Antes de começar a criar o aplicativo, precisamos criar a classe POJO "Person", que usaremos para enviar objetos de uma atividade para outra. Observe que a classe está implementando a interface serializável.

Person.java

package com.hmkcode.android;
import java.io.Serializable;

public class Person implements Serializable{

    private static final long serialVersionUID = 1L;

    private String name;
    private int age;

        // getters & setters....

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }   
}

Dois layouts para duas atividades

activity_main.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".MainActivity" >

<LinearLayout
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal">
    <TextView
        android:id="@+id/tvName"
        android:layout_width="100dp"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:gravity="center_horizontal"
        android:text="Name" />

    <EditText
        android:id="@+id/etName"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"

        android:ems="10" >
        <requestFocus />
    </EditText>
</LinearLayout>

<LinearLayout
     android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal">
<TextView
    android:id="@+id/tvAge"
    android:layout_width="100dp"
    android:layout_height="wrap_content"
    android:layout_gravity="center"
    android:gravity="center_horizontal"
    android:text="Age" />
<EditText
    android:id="@+id/etAge"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:ems="10" />
</LinearLayout>

<Button
    android:id="@+id/btnPassObject"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_gravity="center_horizontal"
    android:text="Pass Object to Another Activity" />

</LinearLayout>

activity_another.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
 >

<TextView
    android:id="@+id/tvPerson"
    android:layout_height="wrap_content"
    android:layout_width="fill_parent"
    android:layout_gravity="center"
    android:gravity="center_horizontal"
 />

</LinearLayout>

Duas Classes de Atividade

1) ActivityMain.java

package com.hmkcode.android;

import android.os.Bundle;
import android.app.Activity;
import android.content.Intent;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;

public class MainActivity extends Activity implements OnClickListener {

Button btnPassObject;
EditText etName, etAge;
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    btnPassObject = (Button) findViewById(R.id.btnPassObject);
    etName = (EditText) findViewById(R.id.etName);
    etAge = (EditText) findViewById(R.id.etAge);

    btnPassObject.setOnClickListener(this);
}

@Override
public void onClick(View view) {

    // 1. create an intent pass class name or intnet action name 
    Intent intent = new Intent("com.hmkcode.android.ANOTHER_ACTIVITY");

    // 2. create person object
    Person person = new Person();
    person.setName(etName.getText().toString());
    person.setAge(Integer.parseInt(etAge.getText().toString()));

    // 3. put person in intent data
    intent.putExtra("person", person);

    // 4. start the activity
    startActivity(intent);
}

}

2) AnotherActivity.java

package com.hmkcode.android;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.widget.TextView;

public class AnotherActivity extends Activity {

TextView tvPerson;

@Override
protected void onCreate(Bundle savedInstanceState) {
    // TODO Auto-generated method stub
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_another);

    // 1. get passed intent 
    Intent intent = getIntent();

    // 2. get person object from intent
    Person person = (Person) intent.getSerializableExtra("person");

    // 3. get reference to person textView 
    tvPerson = (TextView) findViewById(R.id.tvPerson);

    // 4. display name & age on textView 
    tvPerson.setText(person.toString());

}
}

Usando a biblioteca Gson do google, você pode passar o objeto para outras atividades.

Considere uma classe de bean como esta

 public class Example {
    private int id;
    private String name;

    public Example(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

Precisamos passar o objeto da classe Example

Example exampleObject=new Example(1,"hello");
String jsonString = new Gson().toJson(exampleObject);
Intent nextIntent=new Intent(this,NextActivity.class);
nextIntent.putExtra("example",jsonString );
startActivity(nextIntent);

Para ler, precisamos fazer a operação reversa no NextActivity

 Example defObject=new Example(-1,null);
    //default value to return when example is not available
    String defValue= new Gson().toJson(defObject);
    String jsonString=getIntent().getExtras().getString("example",defValue);
    //passed example object
    Example exampleObject=new Gson().fromJson(jsonString,Example .class);

Adicione esta dependência em gradle

compile 'com.google.code.gson:gson:2.6.2'

Intent i = new Intent();
i.putExtra("name_of_extra", myParcelableObject);
startACtivity(i);

Eu sei que isso é tarde, mas é muito simples. Tudo o que você precisa fazer é deixar sua classe implementar Serializable como

public class MyClass implements Serializable{

}

então você pode passar para uma intenção como

Intent intent=......
MyClass obje=new MyClass();
intent.putExtra("someStringHere",obje);

Para obtê-lo, você simplesmente chama

MyClass objec=(MyClass)intent.getExtra("theString");

Se você tiver uma classe singleton (fx Service) atuando como gateway para a camada do modelo, ela poderá ser resolvida com uma variável nessa classe com getters e setters para ela.

Na atividade 1:

Intent intent = new Intent(getApplicationContext(), Activity2.class);
service.setSavedOrder(order);
startActivity(intent);

Na atividade 2:

private Service service;
private Order order;

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

    service = Service.getInstance();
    order = service.getSavedOrder();
    service.setSavedOrder(null) //If you don't want to save it for the entire session of the app.
}

Em serviço:

private static Service instance;

private Service()
{
    //Constructor content
}

public static Service getInstance()
{
    if(instance == null)
    {
        instance = new Service();
    }
    return instance;
}
private Order savedOrder;

public Order getSavedOrder()
{
    return savedOrder;
}

public void setSavedOrder(Order order)
{
    this.savedOrder = order;
}

Esta solução não requer nenhuma serialização ou outro "empacotamento" do objeto em questão. Mas isso só será benéfico se você estiver usando esse tipo de arquitetura.

De longe, a maneira mais fácil do IMHO de empacotar objetos. Você acabou de adicionar uma tag de anotação acima do objeto que deseja tornar parcelável.

Um exemplo da biblioteca está abaixo https://github.com/johncarl81/parceler

@Parcel
public class Example {
    String name;
    int age;

    public Example(){ /*Required empty bean constructor*/ }

    public Example(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public String getName() { return name; }

    public int getAge() { return age; }
}

Primeiro implemente o Parcelable em sua classe. Então passe um objeto como este.

SendActivity.java

ObjectA obj = new ObjectA();

// Set values etc.

Intent i = new Intent(this, MyActivity.class);
i.putExtra("com.package.ObjectA", obj);

startActivity(i);

ReceiveActivity.java

Bundle b = getIntent().getExtras();
ObjectA obj = b.getParcelable("com.package.ObjectA");

A sequência do pacote não é necessária, apenas a sequência precisa ser a mesma nas duas Atividades

REFERÊNCIA

Iniciar outra atividade a partir desta atividade passar parâmetros via Bundle Object

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

Recuperar em outra atividade (YourActivity)

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

Isso é bom para tipos de dados simples. Mas se você quiser passar dados complexos entre as atividades, precisará serializá-los primeiro.

Aqui temos o modelo de funcionário

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

    getters...
    setters...
}

Você pode usar o Gson lib fornecido pelo google para serializar dados complexos como este

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

Na cidade Koltin

Adicione a extensão kotlin no seu build.gradle.

apply plugin: 'kotlin-android-extensions'

android {
    androidExtensions {
        experimental = true
   }
}

Em seguida, crie sua classe de dados assim.

@Parcelize
data class Sample(val id: Int, val name: String) : Parcelable

Passar Objeto com Intenção

val sample = Sample(1,"naveen")

val intent = Intent(context, YourActivity::class.java)
    intent.putExtra("id", sample)
    startActivity(intent)

Obter objeto com intenção

val sample = intent.getParcelableExtra("id")

A maneira mais fácil e java de fazer é: implemente serializável em sua classe pojo / model

Recomendado para Android para visualização do desempenho: torne o modelo parcelável

O mais simples seria usar apenas o seguinte em que o item é uma sequência:

intent.putextra("selected_item",item)

Para receber:

String name = data.getStringExtra("selected_item");