android设计模式—原型设计模式

版权声明：本文为博主原创文章，转载请注明地址。 https://blog.csdn.net/huangxiaoguo1/article/details/88036979

• 定义

   用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象
  

• 目的

   保护最原始的那一份存档，隐藏复制过程
  

• 使用场景

   1. 通过new产生一个对象需要非常繁琐的数据准备或访问权限，这时可以使用原型模式
  
   2. 一个对象需要供给其他对象访问，而且各个对象都需要修改其值时，可以拷贝多个对象供调用者访问，即保护性拷贝
  

• 浅拷贝和深拷贝

• 浅拷贝：使用一个已知实例对新创建实例的成员变量逐个赋值，这个方式被称为浅拷贝。
  其实指的是使用了同一个内存地址

例如：

ArrayList<String> a = new ArrayList();
ArrayList<String> b = a;
//当修改a时，b的值同样会被修改

2. 深拷贝：当一个类的拷贝构造方法，不仅要复制对象的所有非引用成员变量值，还要为引用类型的成员变量创建新的实例，并且初始化为形式参数实例值。
   其实指的是使用了不同内存地址

例如：

ArrayList<String> a = new ArrayList();
ArrayList<String> b = a.clone();
//或者
ArrayList<String> c = new ArrayList(a);

使用官方的Cloneable

• 创建原型模式

public class PersonOrder1 implements java.lang.Cloneable {
    private int oderNumber;
    private String name;

    public int getOderNumber() {
        return oderNumber;
    }

    public void setOderNumber(int oderNumber) {
        this.oderNumber = oderNumber;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public PersonOrder1 clone() {

        try {
            PersonOrder1 personOrder = new PersonOrder1();
            personOrder.setOderNumber(oderNumber);
            personOrder.setName(name);
            return personOrder;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

}
---------------------------------------------------------------------------------

public class CompanyOrder1 implements java.lang.Cloneable {
    private int oderNumber;
    private String name;

    public int getOderNumber() {
        return oderNumber;
    }

    public void setOderNumber(int oderNumber) {
        this.oderNumber = oderNumber;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public CompanyOrder1 clone() {
        try {
            CompanyOrder1 order = new CompanyOrder1();
            order.setName(this.name);
            order.setOderNumber(this.oderNumber);
            return order;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

继承至系统的接口java.lang.Cloneable，然后重写clone方法

• 使用clone后的对象

   
    private void methods2() {
        CompanyOrder1 companyOrder1 = new CompanyOrder1();
        companyOrder1.setOderNumber(3500);
        companyOrder1.setName("公司订单");
        Log.e("huangxiaoguo", "订单----     number  " + companyOrder1.getOderNumber() + "名称-----------" + companyOrder1.getName());
        int number = companyOrder1.getOderNumber();
        while (number > 0) {
            // 获得克隆后的
            CompanyOrder1 companyClone = companyOrder1.clone();
            companyClone.setOderNumber(number > 1000 ? 1000 : number);
            number -= 1000;
            Log.d("huangxiaoguo", "订单----     number  " + companyClone.getOderNumber() + "名称-----------" + companyClone.getName());
        }

        Log.e("huangxiaoguo", "订单----     number  " + companyOrder1.getOderNumber() + "名称-----------" + companyOrder1.getName());


        PersonOrder1 personOrder1 = new PersonOrder1();
        personOrder1.setOderNumber(4500);
        personOrder1.setName("我的订单");
        Log.e("huangxiaoguo", "订单----     number  " + personOrder1.getOderNumber() + "名称-----------" + personOrder1.getName());
        int number1 = personOrder1.getOderNumber();
        while (number1 > 0) {
            // 获得克隆后的
            PersonOrder1 personClone = personOrder1.clone();
            personClone.setOderNumber(number1 > 1000 ? 1000 : number1);
            number1 -= 1000;
            Log.d("huangxiaoguo", "订单----     number  " + personClone.getOderNumber() + "名称-----------" + personClone.getName() );
        }
        Log.e("huangxiaoguo", "订单----     number  " + personOrder1.getOderNumber() + "名称-----------" + personOrder1.getName());
    }

在这里可以看到原对象和clone的对象进行了分离。

构建自己的Cloneable

• 构建Cloneable接口

/**
 * 统一克隆接口
 */
public interface Cloneable {
    Cloneable clone();
}

• 定义统一方法定义（方便统一处理数据）

/**
 * 定义统一方法，实现克隆数据
 */

public interface IOrder extends Cloneable {
    int getOderNumber();

    void setOderNumber(int number);

    String getName();

    void setName(String name);

    ArrayList<String> getImages();

    void setImages(ArrayList<String> images);

    void addImage(String img);
}

• 创建原型模式

public class PersonOrder implements IOrder {
    private int oderNumber;
    private String name;
    //图片集合
    private ArrayList<String> images = new ArrayList<String>();

    @Override
    public int getOderNumber() {
        return oderNumber;
    }

    @Override
    public void setOderNumber(int oderNumber) {
        this.oderNumber = oderNumber;
    }

    @Override
    public String getName() {
        return name;
    }

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

    @Override
    public ArrayList<String> getImages() {
        return images;
    }

    @Override
    public void setImages(ArrayList<String> images) {
        this.images = images;
    }

    public void addImage(String img) {
        images.add(img);
    }

    @Override
    public Cloneable clone() {
        PersonOrder personOrder = new PersonOrder();
        personOrder.setOderNumber(oderNumber);
        personOrder.setName(name);
        //深拷贝(注意：深拷贝需要对所有的引用类型对象都需要copy)
        personOrder.images = (ArrayList<String>) this.images.clone();
        return personOrder;
    }
}
-------------------------------------------------------------------------------------------------

public class CompanyOrder implements IOrder {

    private int oderNumber;
    private String name;
    //图片集合
    private ArrayList<String> images = new ArrayList<String>();

    @Override
    public int getOderNumber() {
        return oderNumber;
    }

    @Override
    public void setOderNumber(int oderNumber) {
        this.oderNumber = oderNumber;
    }

    @Override
    public String getName() {
        return name;
    }

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

    @Override
    public ArrayList<String> getImages() {
        return images;
    }

    @Override
    public void setImages(ArrayList<String> images) {
        this.images = images;
    }

    public void addImage(String img) {
        images.add(img);
    }

    @Override
    public Cloneable clone() {
        CompanyOrder order = new CompanyOrder();
        order.setName(this.name);
        order.setOderNumber(this.oderNumber);
        //深拷贝(注意：深拷贝需要对所有的引用类型对象都需要copy)
        order.images = (ArrayList<String>) this.images.clone();
        return order;
    }
}

这里使用了深拷贝（注意：深拷贝需要对所有的引用类型对象都需要copy）。

• 处理clone模型

/**
 * 处理逻辑的工具类
 */

public class OrderCloneFactory {
    public void dealOrder(IOrder order) {
        int number = order.getOderNumber();
        while (number > 0) {
            // 获得克隆后的
            IOrder iOrder = (IOrder) order.clone();
            iOrder.addImage("修改图片");
            iOrder.setOderNumber(number > 1000 ? 1000 : number);
            number -= 1000;
            for (String name : iOrder.getImages()) {
                Log.d("huangxiaoguo","image name : " + name);
            }
            Log.d("huangxiaoguo", "订单----     number  " + iOrder.getOderNumber() + ",名称-----------" + iOrder.getName());
        }
    }
}

• 使用clone对象

    private void methods1() {
        OrderCloneFactory orderCloneFactory = new OrderCloneFactory();
        PersonOrder order = new PersonOrder();
        order.setOderNumber(4500);
        order.setName("我的订单");
        order.addImage("图片1");
        order.addImage("图片2");
        showDocument(order.getOderNumber(),order.getImages());
        orderCloneFactory.dealOrder(order);
        showDocument(order.getOderNumber(),order.getImages());


        Log.d("huangxiaoguo","-----------------------------------------------------------------");

        CompanyOrder companyOrder = new CompanyOrder();
        companyOrder.setOderNumber(3500);
        companyOrder.setName("公司订单");
        companyOrder.addImage("图片1");
        companyOrder.addImage("图片2");
        showDocument(companyOrder.getOderNumber(),companyOrder.getImages());
        orderCloneFactory.dealOrder(companyOrder);

        showDocument(companyOrder.getOderNumber(),companyOrder.getImages());
    }

    /**
     * 打印文档内容
     */
    public void showDocument(int oderNumber, List<String> images) {
        Log.e("huangxiaoguo","oderNumber : " + oderNumber);
        for (String name : images) {
            Log.e("huangxiaoguo","image name : " + name);
        }
    }

构建自己的Cloneable，更好的来处理业务逻辑。

此外还要注意的是，拷贝的时候不会调用构造函数！

• Intent中的原型模式

@Override
public Object clone() {
    return new Intent(this);
}

private Intent(Intent o, boolean all) {
    this.mAction = o.mAction;
    this.mData = o.mData;
    this.mType = o.mType;
    this.mPackage = o.mPackage;
    this.mComponent = o.mComponent;
    if (o.mCategories != null) {
        this.mCategories = new ArraySet<String>(o.mCategories);
    }
}

总结：原型模式的本质就是clone，解决构建复杂对象的资源消耗问题，提升构建对象的效率；保护性拷贝，可以通过返回一个拷贝对象的形式，实现只读的限制。