a）当你想把的内存中的对象写入到硬盘的时候；
b）当你想用套接字在网络上传送对象的时候；
c）当你想通过RMI传输对象的时候；

再稍微解释一下:

a)比如说你的内存不够用了，那计算机就要将内存里面的一部分对象暂时的保存到硬盘中，等到要用的时候再读入到

内存中，硬盘的那部分存储空间就是所谓的虚拟内存。在比如过你要将某个特定的对象保存到文件中，我隔几天在把

它拿出来用，那么这时候就要实现Serializable接口；
b)在进行java的Socket编程的时候，你有时候可能要传输某一类的对象，那么也就要实现Serializable接口；

最常见的你传输一个字符串，它是JDK里面的类，也实现了Serializable接口，所以可以在网络上传输。
c)如果要通过远程的方法调用（RMI）去调用一个远程对象的方法，如在计算机A中调用另一台计算机B的对象的方法，

那么你需要通过JNDI服务获取计算机B目标对象的引用，将对象从B传送到A，就需要实现序列化接口。

1、什么是Parcelable接口呢？

1）Parcelable,定义了将数据写入Parcel，和从Parcel中读出的接口。一个实体（用类来表示），如果需要封装到消息中去，就必须实现这一接口，实现了这一接口，该实体就成为“可打包的”了。

2）Parcelable接口的定义:

二 至于选取哪种可参考下面的原则：

1.在使用内存的时候，Parcelable 类比Serializable性能高，所以推荐使用Parcelable类。
2.Serializable在序列化的时候会产生大量的临时变量，从而引起频繁的GC。
3.Parcelable不能使用在要将数据存储在磁盘上的情况，因为Parcelable不能很好的保证数据的持续性在外界有变化的情况下。尽管Serializable效率低点， 也不提倡用，但在这种情况下，还是建议你用Serializable 。

1. package com.yang.domain;
2. import android.os.Parcel;
3. import android.os.Parcelable;
4. public class Person implements Parcelable {
5. //这里定义了两个变量来说明读和写的顺序要一致
6. private Integer id;
7. private String name;
8. public Person() {
9. }
10. public Person(Integer id, String name) {
11. this.id = id;
12. this.name = name;
13. }
14. public Integer getId() {
15. return id;
16. }
17. public void setId(Integer id) {
18. this.id = id;
19. }
20. public String getName() {
21. return name;
22. }
23. public void setName(String name) {
24. this.name = name;
25. }
26. @Override
27. public int describeContents() {
28. return 0;
29. }
30. @Override
31. public void writeToParcel(Parcel dest, int flags) {
32. // 把javanbean中的数据写到Parcel。先写id然后写name
33. dest.writeInt(this.id);
34. dest.writeString(this.name);
35. }
36. // 添加一个静态成员,名为CREATOR,该对象实现了Parcelable.Creator接口
37. public static final Parcelable.Creator<Person> CREATOR = new Parcelable.Creator<Person>() {
38. @Override
39. public Person createFromParcel(Parcel source) {
40. // 从Parcel中读取数据，返回person对象
41. return new Person(source.readInt(), source.readString());
42. }
43. @Override
44. public Person[] newArray(int size) {
45. return new Person[size];
46. }
47. };
48. }

1. public class MyParcelable implements Parcelable {
2. private List<MyListClass> arrList = new ArrayList<MyListClass>();
3. private int myInt = 0;
4. private String str = null;
5. public String getStr() {
6. return str;
7. }
8. public void setStr(String str) {
9. this.str = str;
10. }
11. public List<MyListClass> getArrList() {
12. return arrList;
13. }
14. public void setArrList(List<MyListClass> arrList) {
15. this.arrList = arrList;
16. }
17. public int getMyInt() {
18. return myInt;
19. }
20. public void setMyInt(int myInt) {
21. this.myInt = myInt;
22. }
23. MyParcelable() {
24. // initialization
25. arrList = new ArrayList<MyListClass>();
26. }
27. public MyParcelable(Parcel in) {
28. myInt = in.readInt();
29. str = in.readString();
30. in.readTypedList(arrList, MyListClass.CREATOR);
31. }
32. @Override
33. public int describeContents() {
34. return 0;
35. }
36. @Override
37. public void writeToParcel(Parcel outParcel, int flags) {
38. outParcel.writeInt(myInt);
39. outParcel.writeString(str);
40. outParcel.writeTypedList(arrList);
41. }
42. public static final Parcelable.Creator<MyParcelable> CREATOR = new Parcelable.Creator<MyParcelable>() {
43. @Override
44. public MyParcelable createFromParcel(Parcel in) {
45. return new MyParcelable(in);
46. }
47. @Override
48. public MyParcelable[] newArray(int size) {
49. return new MyParcelable[size];
50. }
51. };
52. }

1. public abstract class A implements Parcelable {
2. private int a;
3. protected A(int a) {
4. this.a = a;
5. }
6. public void writeToParcel(Parcel out, int flags) {
7. out.writeInt(a);
8. }
9. protected A(Parcel in) {
10. a = in.readInt();
11. }
12. }
13. public class B extends A {
14. private int b;
15. public B(int a, int b) {
16. super(a);
17. this.b = b;
18. }
19. public static final Parcelable.Creator<B> CREATOR = new Parcelable.Creator<B>() {
20. public B createFromParcel(Parcel in) {
21. return new B(in);
22. }
23. public B[] newArray(int size) {
24. return new B[size];
25. }
26. };
27. public int describeContents() {
28. return 0;
29. }
30. public void writeToParcel(Parcel out, int flags) {
31. super.writeToParcel(out, flags);
32. out.writeInt(b);
33. }
34. private B(Parcel in) {
35. super(in);
36. b = in.readInt();
37. }
38. }

1. package com.jyxp.my.parcelable;
2. import java.io.Serializable;
3. public class MySerializable implements Serializable {
4. private static final long serialVersionUID = 1L;
5. private Double mDouble;
6. private Float mFloat;
7. public MySerializable() {
8. // TODO Auto-generated constructor stub
9. }
10. public Double getmDouble() {
11. return mDouble;
12. }
13. public void setmDouble(Double mDouble) {
14. this.mDouble = mDouble;
15. }
16. public Float getmFloat() {
17. return mFloat;
18. }
19. public void setmFloat(Float mFloat) {
20. this.mFloat = mFloat;
21. }
22. }