android - इरादों का उपयोग करके एक एंड्रॉइड गतिविधि से दूसरे ऑब्जेक्ट को ऑब्जेक्ट कैसे भेजें?




android-intent android-activity (20)

क्लास Intent की putExtra() विधि का उपयोग करके मैं एक Activity से दूसरे Activity में एक कस्टम प्रकार की ऑब्जेक्ट कैसे पास कर सकता हूं?


Google की जीएसन लाइब्रेरी का उपयोग करके आप ऑब्जेक्ट को दूसरी गतिविधियों में पास कर सकते हैं। असल में हम ऑब्जेक्ट को जेसन स्ट्रिंग के रूप में परिवर्तित कर देंगे और दूसरी गतिविधि में जाने के बाद हम फिर से इस तरह की ऑब्जेक्ट में फिर से कनवर्ट करेंगे

इस तरह एक बीन वर्ग पर विचार करें

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

हमें उदाहरण वर्ग की वस्तु को पारित करने की आवश्यकता है

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

For reading we need to do the reverse operation in 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);

Add this dependancy in gradle

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

अपनी कक्षा में serializable लागू करें

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

फिर आप इस वस्तु को मंशा में पारित कर सकते हैं

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

दूसरी गतिविधि int आप इस तरह डेटा प्राप्त कर सकते हैं

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

लेकिन जब डेटा बड़ा हो जाता है, तो यह विधि धीमी हो जाएगी।


आप इरादे के माध्यम से serializable वस्तु भेज सकते हैं

// 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 {
} 

आप ऐसा करने के लिए एंड्रॉइड बंडल का उपयोग कर सकते हैं।

अपनी कक्षा से बंडल बनाएं जैसे:

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

    return b;
}

फिर इस बंडल को इंटेंट के साथ पास करें। अब आप बंडल पास करके अपनी कक्षा वस्तु को फिर से बना सकते हैं

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

इसे अपनी कस्टम कक्षा में घोषित करें और उपयोग करें।


आपकी पहली गतिविधि में:

intent.putExtra("myTag", yourObject);

और आपके दूसरे में:

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

अपनी कस्टम ऑब्जेक्ट Serializable बनाने के लिए मत भूलना:

public class myCustomObject implements Serializable {
...
}

आपको किसी ऑब्जेक्ट को स्ट्रिंग प्रस्तुति में क्रमबद्ध करने की आवश्यकता होगी। एक संभावित स्ट्रिंग प्रस्तुति JSON है, और एंड्रॉइड में जेएसओएन से क्रमबद्ध करने के सबसे आसान तरीकों में से एक, यदि आप मुझसे पूछें, तो Google GSON के माध्यम से है।

उस स्थिति में आप स्ट्रिंग रिटर्न वैल्यू (new Gson()).toJson(myObject); और स्ट्रिंग मान को पुनर्प्राप्त करें और fromJson से इसे अपने ऑब्जेक्ट में वापस चालू करने के लिए उपयोग करें।

यदि आपका ऑब्जेक्ट बहुत जटिल नहीं है, हालांकि, यह ओवरहेड के लायक नहीं हो सकता है, और आप इसके बजाय ऑब्जेक्ट के अलग-अलग मानों को पार करने पर विचार कर सकते हैं।


एंड्रॉइड एप्लिकेशन बनाएं

फ़ाइल >> नया >> एंड्रॉइड एप्लिकेशन

प्रोजेक्ट का नाम दर्ज करें: एंड्रॉइड-पास-ऑब्जेक्ट-टू-एक्टिविटी

Pakcage: com.hmkcode.android

अन्य अपमानजनक चयन रखें, जब तक आप समाप्त नहीं हो जाते, तब तक आगे बढ़ें

ऐप बनाने शुरू करने से पहले हमें पीओजेओ कक्षा "व्यक्ति" बनाने की जरूरत है जिसे हम एक गतिविधि से दूसरी गतिविधि में ऑब्जेक्ट भेजने के लिए उपयोग करेंगे। ध्यान दें कि कक्षा Serializable इंटरफेस को कार्यान्वित कर रहा है।

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 + "]";
    }   
}

दो गतिविधियों के लिए दो लेआउट

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>

दो गतिविधि कक्षाएं

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

}
}

ऐसा करने का एक और तरीका Application ऑब्जेक्ट (android.app.Aplication) का उपयोग करना है। आप इसे AndroidManifest.xml फ़ाइल में परिभाषित करते हैं:

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

फिर आप इसे किसी भी गतिविधि से कॉल कर सकते हैं और ऑब्जेक्ट को Application क्लास में सहेज सकते हैं।

प्रथम गतिविधि में:

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

द्वितीय सक्रियता में, करें:

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

यह आसान है यदि आपके पास ऐसी ऑब्जेक्ट्स हैं जिनके पास एप्लिकेशन स्तरीय स्कोप है यानी उन्हें पूरे एप्लिकेशन में उपयोग करना होगा। यदि आप ऑब्जेक्ट स्कोप पर स्पष्ट नियंत्रण चाहते हैं या यदि दायरा सीमित है तो Parcelable विधि अभी भी बेहतर है।

यह Intents के उपयोग से पूरी तरह से बचने के लिए, हालांकि। मुझे नहीं पता कि वे आपको उपयुक्त हैं या नहीं। मैंने इसका एक और तरीका यह है कि ऑब्जेक्ट्स के int पहचानकर्ता इरादे के माध्यम से भेजते हैं और ऑब्जेक्ट में ऑब्जेक्ट में ऑब्जेक्ट्स को पुनर्प्राप्त करते हैं।


ऐसे कुछ तरीके हैं जिनसे आप अन्य वर्गों या गतिविधि में चर या वस्तु तक पहुंच सकते हैं।

ए डाटाबेस

बी साझा वरीयताओं।

सी ऑब्जेक्ट serialization।

डी। एक वर्ग जो सामान्य डेटा धारण कर सकता है उसे सामान्य उपयोगिता के रूप में नामित किया जा सकता है, यह आपके ऊपर निर्भर करता है।

ई। इरादों और पार्सलबल इंटरफ़ेस के माध्यम से डेटा पास करना।

यह आपकी परियोजना की जरूरतों पर निर्भर करता है।

डाटाबेस

SQLite एक ओपन सोर्स डेटाबेस है जो एंड्रॉइड में एम्बेडेड है। SQLite मानक रिलेशनल डेटाबेस सुविधाओं जैसे SQL वाक्यविन्यास, लेनदेन और तैयार कथन का समर्थन करता है।

ट्यूटोरियल - http://www.vogella.com/articles/AndroidSQLite/article.html

बी साझा प्राथमिकताएं

मान लीजिए कि आप उपयोगकर्ता नाम स्टोर करना चाहते हैं। तो अब दो उपयोगकर्ता कुंजी उपयोगकर्ता नाम, मूल्य मान होगा।

स्टोर कैसे करें

 // 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

सी ऑब्जेक्ट सीरियलाइजेशन

ऑब्जेक्ट serlization का उपयोग किया जाता है अगर हम किसी ऑब्जेक्ट स्थिति को नेटवर्क पर भेजने के लिए सहेजना चाहते हैं या आप इसे अपने उद्देश्य के लिए भी उपयोग कर सकते हैं।

जावा बीन्स का प्रयोग करें और इसमें अपने खेतों में से एक के रूप में स्टोर करें और इसके लिए गेटर्स और सेटर का उपयोग करें

जावाबीन जावा कक्षाएं हैं जिनमें गुण हैं। निजी आवृत्ति चर के रूप में गुणों के बारे में सोचें। चूंकि वे निजी हैं, इसलिए उनकी कक्षा के बाहर से ही उन्हें एक्सेस किया जा सकता है, कक्षा में विधियों के माध्यम से। प्रॉपर्टी के वैल्यू को बदलने वाले तरीकों को सेटर विधियों कहा जाता है, और प्रॉपर्टी के मूल्य को पुनर्प्राप्त करने वाले तरीकों को गेटर विधि कहा जाता है।

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

फिर इस ऑब्जेक्ट को क्रमबद्ध करने के लिए ऑब्जेक्ट सीरियलज़ेशन का उपयोग करें और अपनी दूसरी कक्षा में इस ऑब्जेक्ट को deserialize करें।

क्रमिकरण में एक ऑब्जेक्ट को बाइट्स के अनुक्रम के रूप में दर्शाया जा सकता है जिसमें ऑब्जेक्ट के डेटा के साथ-साथ ऑब्जेक्ट के प्रकार और ऑब्जेक्ट में संग्रहीत डेटा के प्रकार के बारे में जानकारी शामिल होती है।

एक धारावाहिक वस्तु को फ़ाइल में लिखा गया है, इसे फ़ाइल से पढ़ा जा सकता है और deserialized है, कि वस्तु और उसके डेटा का प्रतिनिधित्व करने वाली प्रकार की जानकारी और बाइट्स वस्तु को स्मृति में पुन: बनाने के लिए उपयोग किया जा सकता है।

यदि आप इस लिंक को संदर्भित करने के लिए ट्यूटोरियल चाहते हैं

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

अन्य कक्षाओं में चर प्राप्त करें

डी। सामान्य उपयोगिताएं

आप अपने आप से एक कक्षा बना सकते हैं जिसमें आम डेटा हो सकता है जिसे आपको अक्सर अपनी परियोजना में आवश्यकता होती है।

नमूना

public class CommonUtilities {

    public static String className = "CommonUtilities";

}

ई। इरादों के माध्यम से डेटा पास करना

डेटा पास करने के इस विकल्प के लिए कृपया इस ट्यूटोरियल को देखें।

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


तेजी से आवश्यकता के लिए संक्षिप्त उत्तर

1. Serializable लागू करने के लिए अपनी कक्षा को लागू करें।

यदि आपके पास कोई आंतरिक वर्ग है तो उन्हें Serializable में भी लागू करना न भूलें !!

public class SportsData implements  Serializable
public class Sport implements  Serializable

List<Sport> clickedObj;

2. अपनी वस्तु को मंशा में रखें

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

3. और अन्य ऑब्जेक्ट क्लास में अपना ऑब्जेक्ट प्राप्त करें

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

मुझे पता है कि यह देर हो चुकी है लेकिन यह बहुत आसान है। आप सभी ने अपनी कक्षा को Serializable को लागू करने दिया है

public class MyClass implements Serializable{

}

तो आप इस तरह के इरादे से गुजर सकते हैं

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

इसे आसान कॉल करने के लिए

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

मैं एक ही समस्या से जूझ रहा था। मैंने इसे एक स्थिर वर्ग का उपयोग करके हल किया, जिसे मैं हैश मैप में इच्छित डेटा संग्रहीत करता हूं। शीर्ष पर मैं मानक गतिविधि वर्ग का विस्तार करता हूं जहां मैंने विधियों को ओवरराइड किया है, डेटा ट्रांसपोर्ट और डेटा समाशोधन छिपाने के लिए ऑनस्ट्रोय बनाएं। कुछ हास्यास्पद सेटिंग्स को बदला जाना चाहिए जैसे अभिविन्यास-हैंडलिंग।

एनोटेशन: किसी अन्य गतिविधि में पारित होने वाली सामान्य वस्तुओं को गधे में दर्द नहीं है। यह घुटने में खुद को शूटिंग और 100 मीटर जीतने की उम्मीद है। "पारगम्य" पर्याप्त विकल्प नहीं है। यह मुझे हंसता है ... मैं इस इंटरफ़ेस को अपनी तकनीक-मुक्त एपीआई में लागू नहीं करना चाहता, जितना कम मैं एक नया परत पेश करना चाहता हूं ... यह कैसे हो सकता है कि हम मोबाइल प्रोग्रामिंग में बहुत दूर हैं आधुनिक प्रतिमान ...


यदि आप बस ऑब्जेक्ट्स को पास कर रहे हैं तो Parcelable को इसके लिए डिज़ाइन किया गया था। जावा के मूल क्रमिकरण का उपयोग करने के लिए इसे उपयोग करने के लिए थोड़ा और प्रयास करने की आवश्यकता है, लेकिन यह तेज़ तरीका है (और मेरा मतलब है, रास्ता तेज़ी से)।

दस्तावेज़ों से, कार्यान्वित करने के लिए एक सरल उदाहरण यह है:

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

ध्यान दें कि यदि किसी दिए गए पार्सल से पुनर्प्राप्त करने के लिए आपके पास एक से अधिक फ़ील्ड हैं, तो आपको इसे उसी क्रम में करना होगा जिसमें आप उन्हें डालते हैं (यानी, एक फीफो दृष्टिकोण में)।

एक बार जब आप अपनी ऑब्जेक्ट्स Parcelable लागू कर Parcelable यह केवल putExtra() साथ अपने putExtra() में डालने का मामला है:

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

फिर आप getParcelableExtra() साथ उन्हें वापस खींच सकते हैं:

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

यदि आपकी ऑब्जेक्ट क्लास पार्ससेलबल और सीरियलज़ेबल लागू करती है तो सुनिश्चित करें कि आप निम्न में से किसी एक पर डाले गए हैं:

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

यदि आपकी ऑब्जेक्ट क्लास Serializable लागू करती है, तो आपको कुछ और करने की आवश्यकता नहीं है, आप एक serializable ऑब्जेक्ट पास कर सकते हैं।
मैं यही उपयोग करता हूं।


By far the easiest way IMHO to parcel objects. You just add an annotation tag above the object you wish to make parcelable.

An example from the library is below 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; }
}

First implement Parcelable in your class. Then pass object like this.

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

The package string isn't necessary, just the string needs to be the same in both Activities

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


If you have a singleton class (fx Service) acting as gateway to your model layer anyway, it can be solved by having a variable in that class with getters and setters for it.

In Activity 1:

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

In Activity 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.
}

In Service:

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

This solution does not require any serialization or other "packaging" of the object in question. But it will only be beneficial if you are using this kind of architecture anyway.


POJO class "Post " (Note that it is implemented Serializable)

package com.example.booklib;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import android.graphics.Bitmap;

public class Post implements Serializable{
    public String message;
    public String bitmap;
    List<Comment> commentList = new ArrayList<Comment>();
    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }
    public String getBitmap() {
        return bitmap;
    }
    public void setBitmap(String bitmap) {
        this.bitmap = bitmap;
    }
    public List<Comment> getCommentList() {
        return commentList;
    }
    public void setCommentList(List<Comment> commentList) {
        this.commentList = commentList;
    }

}

पीओजेओ कक्षा "टिप्पणी" (पोस्ट क्लास के सदस्य होने के बाद से, सीरियलज़ेबल को लागू करने के लिए भी आवश्यक है)

    package com.example.booklib;

    import java.io.Serializable;

    public class Comment implements Serializable{
        public String message;
        public String fromName;
        public String getMessage() {
            return message;
        }
        public void setMessage(String message) {
            this.message = message;
        }
        public String getFromName() {
            return fromName;
        }
        public void setFromName(String fromName) {
            this.fromName = fromName;
        }

    }

फिर अपनी गतिविधि कक्षा में, आप किसी अन्य गतिविधि को ऑब्जेक्ट पास करने के लिए निम्न कार्य कर सकते हैं।

ListView listview = (ListView) findViewById(R.id.post_list);
listview.setOnItemClickListener(new OnItemClickListener(){
        @Override
        public void onItemClick(AdapterView<?> parent, View view,
                int position, long id) {
            Post item = (Post)parent.getItemAtPosition(position);
            Intent intent = new Intent(MainActivity.this,CommentsActivity.class);
            intent.putExtra("post",item);
            startActivity(intent);

        }
    });

आपके प्राप्तकर्ता वर्ग "टिप्पणियां सक्रियता" में आप डेटा को निम्नलिखित के रूप में प्राप्त कर सकते हैं

Post post =(Post)getIntent().getSerializableExtra("post");

The simplest would be to just use the following where the item is a string:

intent.putextra("selected_item",item)

For receiving:

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

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






android-activity