设计模式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);

    }

}

测试输出结果;

cn.hncu.pattern.mulitition.A@11dba45
cn.hncu.pattern.mulitition.A@b03be0
cn.hncu.pattern.mulitition.A@11dba45
cn.hncu.pattern.mulitition.A@b03be0
cn.hncu.pattern.mulitition.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());
    }


}

输出结果：

cn.hncu.pattern.mulitition.multi.A@18a49e0
cn.hncu.pattern.mulitition.multi.A@1f82982
cn.hncu.pattern.mulitition.multi.A@16d2633
cn.hncu.pattern.mulitition.multi.A@18a49e0
cn.hncu.pattern.mulitition.multi.A@1f82982
cn.hncu.pattern.mulitition.multi.A@16d2633

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