Android_Serializable_Parcelable_多进程

1. Serializable

Serializable:序列化 接口，是Java提供的，谁想序列化就实现这个接口。序列化的是对象，不是类，静态成员变量是属于类的不属于对象的，不参加序列化。
 serialVersionUID:是在反序列化的时候用的，序列化的时候把系统当前类的serialVersionUID写入到文件中,在反序列化的时候，系统去检测文件中的serialVersionUID 是否和当前类的 serialVersionUID 一样，一样的话就反序列化成功，不一样就抛出 java.io.InvalidClassException异常

 //序列化过程  写数据的过程
        User user = new User("zhangqi", 14);
        File file = new File(Environment.getExternalStorageDirectory(), "cache.txt");
        if (!file.exists()) {
            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


        try {
            objectOutputStream = new ObjectOutputStream(new FileOutputStream(file));
            objectOutputStream.writeObject(user);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (objectOutputStream != null) {
                try {
                    objectOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        //反序列化过程  读数据的过程
        try {
            objectInputStream = new ObjectInputStream(new FileInputStream(file));
            User mUser = (User) objectInputStream.readObject();
            if (mUser != null) {
                Log.d("name = ", mUser.getName());
                Log.d("age = ", String.valueOf(mUser.getAge()));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (objectInputStream != null) {
                try {
                    objectInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

2. Parcelable

public class ParcelUser implements Parcelable {

    private String name;
    private int age;
    private String address;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    /**
     * 从序列化后的对象中，转化成原对象
     * @param in
     */
    protected ParcelUser(Parcel in) {
       name = in.readString();
       age = in.readInt();
       address = in.readString();

    }

    public static final Creator<ParcelUser> CREATOR = new Creator<ParcelUser>() {
        /**
         * 从序列化后的对象中，创建原始对象
         * @param in
         * @return
         */
        @Override
        public ParcelUser createFromParcel(Parcel in) {
            return new ParcelUser(in);
        }

        @Override
        public ParcelUser[] newArray(int size) {
            return new ParcelUser[size];
        }
    };

    /**
     * 返回当前对象的描述性文件，一般都是返回0，如果当前对象有描述性文件，就返回当前的文件
     * @return
     */
    @Override
    public int describeContents() {
        return 0;
    }

    /**
     * 将现有的对象，写入到序列化机构中
     * @param dest
     * @param flags
     */
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);
        dest.writeInt(age);
        dest.writeString(address);
    }
}

3. Serializable 和 Parcelable 优缺点

Serializable:使用简便，但是效率低，有很多I/O 操作
Parcelable:使用复杂，但是效率高，是Android平台提供的，优先考虑使用这个。

4. 多进程的创建

1）在配置文件中，给活动设置属性 process="进程名"

 默认不设置的，进程名为当前应用的包名

进程名=“:test” 此种方式的表明 是 包名的基础上加上 .test,此种进程属于当前应用的私有进程，其他应用或者组件不能和这个进程跑到一起。

使用多进程出现的问题

* 多进程：
* 1）静态成员变量与单例模式都会失效
* 2）线程的同步机制失效
* 3）SharedPreferences的可靠性下降：底层是 读写xml文件的，
* 4）会多次启动Application