Java---设计模块(单例的变形)(多例)

设计模式1——单例变形(多例)
★ 缓存在单例中的使用
缓存在编程中使用很频繁，有着非常重要的作用，它能够帮助程序实现以空间换取时间，通常被设计成整个应用程序所共享的一个空间，现要求实现一个用缓存存放单例对象的类。
说明：该缓存中可以存放多个该类对象，每个对象以一个key值标识，key值相同时所访问的是同一个单例对象。

给一个key值标识：

package cn.hncu.pattern.mulitition;import java.util.HashMap;import java.util.Map;public class A {    private static final Map<String, A> map = new HashMap<String, A>();    public A() {    }//private也是可以的，这不是关键，关键是map是私有的，这个是集合的单例    public static A getInstance(String key){        A a = map.get(key);        if(a==null){            a = new A();            map.put(key, a);        }        return a;    }}

测试：

package cn.hncu.pattern.mulitition;public class Test {    public static void main(String[] args) {        Atest();    }    private static void Atest() {        A a1 = A.getInstance("hncu1");        System.out.println(a1);        A a2 = A.getInstance("hncu2");        System.out.println(a2);        A a3 = A.getInstance("hncu1");        System.out.println(a3);        A a4 = A.getInstance("hncu2");        System.out.println(a4);        A a5 = A.getInstance("hncu1");        System.out.println(a5);    }}

测试输出结果;

[e-mail][e-mail][e-mail][e-mail].A@11dba45

可以发现：a1,a3,a5的地址的值是相等的，a2,a4是相等的。

通过Buffer类调用Book类的单例：
Book类：

package cn.hncu.pattern.mulitition;public class Book {    private String name;    private int id;    private double price;    private String details;    private static int cont=0;    public Book() {        id=cont++;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getId() {        return id;    }    public void setId(int id) {        this.id = id;    }    public double getPrice() {        return price;    }    public void setPrice(double price) {        this.price = price;    }    public String getDetails() {        return details;    }    public void setDetails(String details) {        this.details = details;    }    @Override    public int hashCode() {        final int prime = 31;        int result = 1;        result = prime * result + id;        return result;    }    @Override    public boolean equals(Object obj) {        if (this == obj)            return true;        if (obj == null)            return false;        if (getClass() != obj.getClass())            return false;        Book other = (Book) obj;        if (id != other.id)            return false;        return true;    }    @Override    public String toString() {        return "Book [id=" + id + "]";    }}

Buffer类：

package cn.hncu.pattern.mulitition;import java.util.HashMap;import java.util.Map;public class Buffer {    private static final Map<String, Book> map = new HashMap<String, Book>();    public Buffer() {    }//private也是可以的，这不是关键，关键是map是私有的，这个是集合的单例    public static Book getInstance(String key){        Book a = map.get(key);        if(a==null){            a = new Book();            map.put(key, a);        }        return a;    }}   

测试类;

package cn.hncu.pattern.mulitition;public class Test {    public static void main(String[] args) {        Buffertest();    }    private static void Buffertest() {        Book bk1 = Buffer.getInstance("hncu1");        System.out.println(bk1);        Book bk2 = Buffer.getInstance("hncu2");        System.out.println(bk2);        Book bk3 = Buffer.getInstance("hncu3");        System.out.println(bk3);        Book bk4 = Buffer.getInstance("hncu2");        System.out.println(bk4);        Book bk5= Buffer.getInstance("hncu1");        System.out.println(bk5);    }}

输出结果：

Book [id=0]Book [id=1]Book [id=2]Book [id=1]Book [id=0]

★ 单例变形——多例模式
把上面缓存的单例实现，做成一个能够控制对象个数的共享空间，供整个应用程序使用。在缓存中维护指定个数的对象，每个对象的key值由该类内部指定，有外部请求时直接返回其中一个对象出去。
说明：相当于维护一个指定数量的对象池，当请求个数超过控制的总数时，开始循环重复使用 。

package cn.hncu.pattern.mulitition.multi;import java.util.HashMap;import java.util.Map;public class A {    private static final Map<Integer, A> map= new HashMap<Integer, A>();    private static final int MAX=3;//控制容器中所能使用对象的总个数    private static int cont = 1;//代表池中目前将要被使用的对象的序号    public static A getInstance(){        A a = map.get(cont);        if(a==null){            a=new A();            map.put(cont, a);        }        cont++;        if(cont>MAX){            cont=1;        }        return a;    }}

测试的类：

package cn.hncu.pattern.mulitition;public class Test {    public static void main(String[] args) {        Atest2();    }    private static void Atest2() {        System.out.println(cn.hncu.pattern.mulitition.multi.A.getInstance());        System.out.println(cn.hncu.pattern.mulitition.multi.A.getInstance());        System.out.println(cn.hncu.pattern.mulitition.multi.A.getInstance());        System.out.println(cn.hncu.pattern.mulitition.multi.A.getInstance());        System.out.println(cn.hncu.pattern.mulitition.multi.A.getInstance());        System.out.println(cn.hncu.pattern.mulitition.multi.A.getInstance());    }}

输出结果：

[e-mail][e-mail][e-mail][e-mail][e-mail].A@16d2633

可以看到： 123行的输出个不相同，
第4行的地址和第一行的相同，
第5行的地址和第二行的相同，
第6行的地址和第三行的相同。
依次类推，循环节点为3.