Parcelable 인터페이스 사용

전재 하 다http://www.cnblogs.com/hpboy/archive/2012/07/12/2587797.html
Parcelable 이 뭐 예요?
     Parcelable 은 데 이 터 를 Parcel 에 기록 하고 Parcel 에서 읽 은 인 터 페 이 스 를 정의 합 니 다.하나의 실체 (클래스 로 표시) 가 메시지 에 봉인 되 어야 한다 면 반드시 이 인 터 페 이 스 를 실현 하고 이 인 터 페 이 스 를 실현 해 야 한다. 이 실 체 는 '포장 가능 한' 것 이 된다.
 
Parcelable 전달 대상
    Android 직렬 화 대상 은 주로 두 가지 방법 이 있 습 니 다.
    1. Serializable 인 터 페 이 스 를 실현 하고 Serializable 인 터 페 이 스 를 실현 하 는 것 은 JavaSE 자체 가 지원 하 는 것 이다.
    2. Parcelable 인 터 페 이 스 를 실현 합 니 다. Parcelable 은 Android 특유 의 기능 으로 Serializable 인 터 페 이 스 를 실현 하 는 것 보다 효율 이 높 습 니 다. 예 를 들 어 Intent 데이터 전달 에 도 지원 되 고 프로 세 스 간 통신 (IPC) 에 도 사용 할 수 있 습 니 다.
      기본 유형 을 제외 하고 Parcelable 인 터 페 이 스 를 실현 한 클래스 만 Parcel 에 넣 을 수 있 습 니 다.
Parcelable 인터페이스 정의

public interface Parcelable {
    //      ，     
    public int describeContents();
    //      ，  
    public void writeToParcel(Parcel dest, int flags);
     //    ，     Parcel        Parcelable       。              ，           ，            。
    //             ，    Creator    ,                      。
    public interface Creator<T> {
           public T createFromParcel(Parcel source);
           public T[] newArray(int size);
       }

어떻게 Parcelable 인 터 페 이 스 를 실현 합 니까?
   parcelable 인터페이스 정의 에서 볼 수 있 듯 이 parcelable 인 터 페 이 스 를 실현 하려 면 다음 과 같은 몇 가지 방법 이 필요 합 니 다.
   1. description Contents 방법.내용 인터페이스 설명, 기본 값 으로 0 을 되 돌려 주면 됩 니 다.
   2. writeToParcel 방법.이 방법 은 클래스 의 데 이 터 를 외부 에서 제공 하 는 Parcel 에 기록 합 니 다. 즉, 전달 할 데 이 터 를 Parcel 용기 에 포장 하여 저장 합 니 다. 이 방법 은 다음 과 같 습 니 다.
     writeToParcel (Parcel dest, int flags) 의 구체 적 인 매개 변수 의 미 는 javadoc 참조
   3. 정적 인 Parcelable. Creator 인터페이스, 이 인 터 페 이 스 는 두 가지 방법 이 있 습 니 다.
     createFromParcel(Parcel in)  Parcel 용기 에서 전달 데이터 값 을 읽 고 Parcelable 대상 으로 봉 하여 논리 층 으로 되 돌려 줍 니 다.
     new Array (int size) 는 T, 길이 가 size 인 배열 을 만 들 고 한 마디 (return new T [size]) 만 사용 하면 됩 니 다. 방법 은 외부 클래스 의 반 직렬 화 를 위 한 것 입 니 다.
코드 구현
    1. 데 이 터 를 봉인 하고 parcelable 인 터 페 이 스 를 실현 하 는 Person 대상 을 Two Activity 에 전달 합 니 다.

public class DemoActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        //     
        Person p = new Person();
        p.setId(1);
        p.setName("xiaoming");
        //  Intent  Person  
        Intent i = new Intent(this, TwoActivity.class);
        i.putExtra("Person", p);
        startActivity(i);
    }
}

   2. Two Activity 는 데 이 터 를 가 져 와 DemoActivity 가 전달 하 는 Person 대상 에서 분석 하고 인쇄 합 니 다.

public class TwoActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
        
        Person p = (Person)getIntent().getParcelableExtra("Person");
        
        System.out.println("p_id"+p.getId());
        System.out.println("p_name"+p.getName());
    }
}

3. parcelable 인터페이스의 실현

public class Person implements Parcelable{
     
     //     
     private int id;
     private String name;
     
     // 1.    Parcelable.Creator  ,     Person     ，   ，  ：
     // android.os.BadParcelableException:
     // Parcelable protocol requires a Parcelable.Creator object called  CREATOR on class com.um.demo.Person
     // 2.        Percel    Person  ，   Person        
     // 3.  Parcelable.Creator        CREATOR，              ；
     // 4.   Parcel       ，                ，           
     // 5.      
     public static final Parcelable.Creator<Person> CREATOR = new Creator(){
 
         @Override
         public Person createFromParcel(Parcel source) {
             // TODO Auto-generated method stub
             //                 ，           
             Person p = new Person();
             p.setId(source.readInt());
             p.setName(source.readString());
             return p;
         }
 
         @Override
         public Person[] newArray(int size) {
             // TODO Auto-generated method stub
             return new Person[size];
         }
     };
     
     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;
     }
 
     @Override
     public int describeContents() {
         // TODO Auto-generated method stub
         return 0;
     }
 
     @Override
     public void writeToParcel(Parcel dest, int flags) {
         // TODO Auto-generated method stub
         // 1.                ，           
         // 2.     
         dest.writeInt(id);
         dest.writeString(name);
     }
 }

자, parcelable 인터페이스의 실현, 여기저기 끝!!