但是如果我们想要传输自定义的对象就有一点复杂了。你可以简单地将类序列化(Serializable),然后让Java来善后。但是使用序列化对于Android来说会产生严重的性能问题。解决办法即时使用Parcelable。
package uk.co.kraya.android.demos.Parcelable;
import android.os.Parcel;
import android.os.Parcelable;
/**
* @author Shriram Shri Shrikumar
*
*/
public class ObjectA implements Parcelable {
private String strValue;
private Integer intValue;
/**
* 一个没有parcel参数的默认构造方法
*
*/
public ObjectA() { ; };
/**
*
* 当我们利用parcel重建对象时需要这个构造方法
*
*
* @param in 读取这个对象的Parcel
*/
public ObjectA(Parcel in) {
readFromParcel(in);
}
/**
* getter
*
* @return strValue
*/
public String getStrValue() {
return strValue;
}
/**
* setter
*
* @param strValue
*/
public void setStrValue(String strValue) {
this.strValue = strValue;
}
/**
* getter
*
* @return
*/
public Integer getIntValue() {
return intValue;
}
/**
* setter
*
* @param intValue
*/
public void setIntValue(Integer intValue) {
this.intValue = intValue;
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
// 我们只需把每个字段写入parcel
// 然后按写入的顺序读取出来
dest.writeString(strValue);
dest.writeInt(intValue);
}
/**
*
* 构造方法会调用该方法，利用parcel为字段赋值
*
*
* @param in 重构对象的parcel
*/
private void readFromParcel(Parcel in) {
//我们以parcel写入的相同顺序读取对象
strValue = in.readString();
intValue = in.readInt();
}
/**
*
* 需要利用这个字段创建新的对象
* 要么以单个对象的形式，要么以数组的形式
*
*
*
* 这意味着你能使用默认构造方法创建对象或者使用其它构造方法
*/
public static final Parcelable.Creator CREATOR =
new Parcelable.Creator() {
public ObjectA createFromParcel(Parcel in) {
return new ObjectA(in);
}
public ObjectA[] newArray(int size) {
return new ObjectA[size];
}
};
}
上面的例子中有一个自定义类ObjectA，它实现了Parcelable,类里有两个字段，分别是int,String类型。考虑一种特殊情况，如果你的自定义类里引用了另外一个类。很明显，它们都必须实现Parcelable，但是要怎样集成它们呢？ObjectB向我们展示了一个实现了Parcelable的类里嵌套另一个实现了Parcelable的自定义类。
[java] view plaincopy
package uk.co.kraya.android.demos.Parcelable;
import android.os.Parcel;
import android.os.Parcelable;
public class ObjectB implements Parcelable {
private ObjectA obj;
private Long longVal;
public ObjectB() { ; }
public ObjectA getObj() {
return obj;
}
public ObjectB(Parcel in) {
readFromParcel(in);
}
public void setObj(ObjectA obj) {
this.obj = obj;
}
public Long getLongVal() {
return longVal;
}
public void setLongVal(Long longVal) {
this.longVal = longVal;
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
// writeParcelable方法需要一个flags,但是很简单
dest.writeParcelable(obj, flags);
// 和ObjectA一样
dest.writeLong(longVal);
}
private void readFromParcel(Parcel in) {
// readParcelable needs the ClassLoader readParcelable方法需要类加载器
// 类加载器能够从指定类得到
obj = in.readParcelable(ObjectA.class.getClassLoader());
// 和ObjectA一样
longVal = in.readLong();
}
public static final Parcelable.Creator CREATOR =
new Parcelable.Creator() {
public ObjectB createFromParcel(Parcel in) {
return new ObjectB(in);
}
public ObjectB[] newArray(int size) {
return new ObjectB[size];
}
};
}
当我们在写Parcel时，我们需要向它传flags参数（非常简单）。当我们读取Parcel时，我们需要一个类加载器(classloader),这个类加载器能够从实现Parcelable的母的类获取（还是很简单吧)
最后，我们是这样传输parcelable对象的。
ObjectA obj = new ObjectA();
// Set values etc.
Intent i = new Intent(this, MyActivity.class);
i.putExtra("com.package.ObjectA", obj);
startActivity(i);
是不是很简单，对吧？
接下来是读取parcelable对象。
[java] view plaincopy
public class MyActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Bundle b = getIntent().getExtras();
ObjectA obj =
b.getParcelable("com.package.ObjectA");
}
}
当然，如果它真的真的太容易了，那。。我们就失业了。。
原文链接：
