原型模式

我理解的原型模式就是将对象都创建好并且缓存下来，当你需要其中的对象的时候直接clone下来，不需要new这个过程。

想要不经历new这个过程就创建对象其中之一的方法就是在堆内存中直接复制对象也就是clone方法，也就是原型模式

但是其中很多细节

(1)首先定义基类的时候要继承Cloneable接口，重写其中的clone方法，但是clone方法返回的并不是你想要的Item类，所以强制转换也是其中的一个细节

public abstract class Item implements Cloneable {//1
    private String  ketId;
    protected String itemName;

    public String getKetId() {
        return ketId;
    }

    public void setKetId(String ketId) {
        this.ketId = ketId;
    }

    public String getItemName() {
        return itemName;
    }
    public Item clone(){//2
        try {
            return (Item) super.clone();//3
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }

}

(2)然后定义两个继承了Item的派生类

Adidas

public class Adidas extends Item {
    public Adidas(){
        this.itemName = "Adidas";
    }
}

Nike

public class Nike extends Item {
    public Nike(){
        this.itemName = "Nike";
    }
}

(3)然后定义缓存类

缓存类里面用一个HashTable来作为存储方式

public class ItemCache {
    private static Hashtable<String, Item> itemMap =
            new Hashtable<String,Item>();

    public static Item getItem(String keyId){
        Item item = itemMap.get(keyId);
        return (Item) item.clone();
    }
　　//缓存方法
    public static void addItem(){
        Adidas adidas = new Adidas();
        adidas.setKetId("1");
        itemMap.put( adidas.getKetId(), adidas);

        Nike nike = new Nike();
        nike.setKetId("2");
        itemMap.put(nike.getKetId(), nike);
    }

}

(4)测试类

首先要先进行缓存，也就是调用缓存类中的缓存方法，还有HashTable查询出来的兑现也要强制转换

1 public class PrototypeDemo {
2     public static void main(String[] args) {
3         ItemCache.addItem();//1
4 
5         Adidas adidas = (Adidas) ItemCache.getItem("1");//2
6         System.out.println("Adidas:" + adidas.getItemName());
7     }
8 }

 原型模式的弱引用问题

如果一个对象是你要clone对象的成员变量，当你clone这个对象之后该成员变量的实例化问题就是弱引用

下面是实验代码

成员变量类，name来标识这个类

public class SecondDemo {
    public String name;


    public String getName() {
        return name;
    }

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

}

引用类

public class FirstDemo implements Cloneable {
    SecondDemo secondDemo = new SecondDemo();

    public void setName (String name){
        this.secondDemo.setName(name);
    }
    @Override
    public  FirstDemo clone(){
        FirstDemo firstDemo = null;
        try {
            firstDemo =(FirstDemo)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return firstDemo;
    }
}

测试类

public class CiteDemo {
    public static void main(String[] args) {
        FirstDemo firstDemo = new FirstDemo();
        firstDemo.setName("second");
        FirstDemo firstDemo1 = firstDemo.clone();
        System.out.println(firstDemo.secondDemo.getName());//second
        System.out.println(firstDemo1.secondDemo.getName());//second
    }
}

实验证明clone出来的类还是原来的Second类，所以不会对其进行重新实例化，同时数组字段同样是弱引用，只有基本数据类型可以重新创建。