public class PoolMgr{

    private int init ;

    private int max;

    private int factor;

    private Colection c; //

    public void init(){
          //init
    }
    //根据策略来动态的生成对象。。
    //如果对象不足可以增加对象池的对象，或者blocking直到有对象释放。
    public Object aquire(){

        return c.remove();
    }

    public void release(Object o){
        if(o == null) return;

        reset(o);
        c.add(o);
    }

}

Object o = null;
try{
   o = PoolMgr.getInstance();  
}finaly{
   PoolMgr.release(o);  
}

public interface PooledObject<T> extends Comparable<PooledObject<T>> {
    // 获取封装的对象
    T getObject();

    // 对象创建的时间
    long getCreateTime();

    // 对象上次处于活动状态的时间
    long getActiveTimeMillis();

    // 对象上次处于空闲状态的时间
    long getIdleTimeMillis();

    // 对象上次被借出的时间
    long getLastBorrowTime();

    // 对象上次返还的时间
    long getLastReturnTime();

    // 对象上次使用的时间
    long getLastUsedTime();

    // 将状态置为 PooledObjectState.INVALID
    void invalidate();

    // 更新 lastUseTime
    void use();

    // 获取对象状态
    PooledObjectState getState();

    // 将状态置为 PooledObjectState.ABANDONED
    void markAbandoned();

    // 将状态置为 PooledObjectState.RETURNING
    void markReturning();
}

public interface PooledObjectFactory<T> {
    // 创建一个池对象
    PooledObject<T> makeObject() throws Exception;

    // 销毁对象
    void destroyObject(PooledObject<T> p) throws Exception;

    // 验证对象是否可用
    boolean validateObject(PooledObject<T> p);

    // 激活对象，从池中取对象时会调用此方法
    void activateObject(PooledObject<T> p) throws Exception;

    // 钝化对象，向池中返还对象时会调用此方法
    void passivateObject(PooledObject<T> p) throws Exception;
}

public class StringBufferFactory extends BasePooledObjectFactory<StringBuffer> {
    // 创建一个新的对象
    @Override
    public StringBuffer create() {
        return new StringBuffer();
    }

    // 封装为池化对象
    @Override
    public PooledObject<StringBuffer> wrap(StringBuffer buffer) {
        return new DefaultPooledObject<>(buffer);
    }

    // 使用完返还对象时将 StringBuffer 清空
    @Override
    public void passivateObject(PooledObject<StringBuffer> pooledObject) {
        pooledObject.getObject().setLength(0);
    }
}

 // 创建对象池配置
GenericObjectPoolConfig config = new GenericObjectPoolConfig();
// 创建对象工厂
PooledObjectFactory factory = new StringBufferFactory();
// 创建对象池
ObjectPool<StringBuffer> pool = new GenericObjectPool<>(factory, config);
StringReader in = new StringReader("abcdefg");
StringBuffer buf = null;
try {
    // 从池中获取对象
    buf = pool.borrowObject();

    // 使用对象
    for (int c = in.read(); c != -1; c = in.read()) {
        buf.append((char) c);
    }
    return buf.toString();
} catch (Exception e) {
    try {
        // 出现错误将对象置为失效
        pool.invalidateObject(buf);
        // 避免 invalidate 之后再 return 抛异常
        buf = null;
    } catch (Exception ex) {
        // ignored
    }
    throw e;
} finally {
    try {
        in.close();
    } catch (Exception e) {
        // ignored
    }

    try {
        if (null != buf) {
            // 使用完后必须 returnObject
            pool.returnObject(buf);
        }
    } catch (Exception e) {
        // ignored
    }
}

public class PrototypeClass implements Cloneable{
    @Override
    public PrototypeClass clone(){
        PrototypeClass p = null;
        try{
            p = (PrototypeClass)super.clone();
        }catch(CloneNotSupportedException e){
            //TODO
        }
        return p;
    }
}

public class PrototypeClass implements Cloneable{
    public ArrayList<String> arrayList = new ArrayList<>();

    @Override
    public PrototypeClass clone(){
        PrototypeClass p = null;
        try{
           p = (PrototypeClass) super.clone();
        }catch(CloneNotSupportedException e) ) {
            //
        }
        return p;
    }
}

public class PrototypeClass implements Cloneable{
    public ArrayList<String> arrayList = new ArrayList<>();

    @Override
    public PrototypeClass clone(){
        PrototypeClass p = null;
        try{
           p = (PrototypeClass) super.clone();
           p.arrayList = (ArrayList<String>) this.arrayList.clone();
        }catch(CloneNotSupportedException e) ) {
            //
        }
        return p;
    }
}

public static <T extends Serializable> T clone(T t) throws Exception {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    ObjectOutputStream oos = new ObjectOutputStream(baos);
    oos.writeObject(t);

    ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
    ObjectInputStream ois = new ObjectInputStream(bais);
    return (T)ois.readObject();
}

public class Product{
    public void doSomething(){

    }
}

public abstract class Builder{
    abstract void setPart(); //设置个性部分
    abstract Product buildProduct();//建造产品
}

public class ConcreteBuilder extends Builder{
  public void setPart(){
    //...
  }
  pbulic Product buildProduct(){
    return new Product();
  }
}

public class Director{

   public Product buildProductA(){
    Builder b = new ConcreteBuilder();
    b.setPart();
    return b.buildProduct();
   }

}

public abstract Product{
    //all product base filds & methods.
    abstract int on();
    abstract int off();
}

public abstract AbstractTvProduct extends Product{
    abstract int switchChannel();
}

public abstract AbstractFridgeProduct extends Product{
    abstract int increaseTemp();
    abstract int decreaseTemp();
}

public HaierTVProduct extends AbstractTvProduct{

}

public HaierFridgeProduct extends AbstractFridgeProduct{

}

public TCLTVProduct extends AbstractTvProduct{

}

public TCLFridgeProduct extends AbstractFridgeProduct{
    
}

public interface IFactory{
    Product createTV();
    Product createFridge();
}


public class HaierFactory implements IFactory{
    Product createTV(){
       return new HaierTVProduct();
    }
    Product createFridge(){
        return new HaierFridgeProduct();
    }
}

public class TCLFactory implements IFactory{
    Product createTV(){
       return new TCLTVProduct();
    }
    Product createFridge(){
        return new TCLFridgeProduct();
    }
}

public abstract class Product{
    public abstract void method1();
    public void method2(){}
}

public class Product1 extends Product{
    public void method1(){}
}

public class Product2 extends Product{
    public void method1(){}
}

public abstract class Factory{
    public abstract <T extends Product> T create(Class<T> c);
}

public class ConcreteFactory extends Factory{

    public <T extends Product> T create(Class<T> c){
        Product p = null;
        try{
            p = (Product)Class.forName(c.getName()).newInstance();
        }catch(Exception e){

        }
        return (T)p;
    }
}

public void Factory{

    public static <T extends Product> T create(Class<T> c){
        Product p = null;
        try{
            p = (Product)Class.forName(c.getName()).newInstance();
        }catch(Exception e){

        }
        return (T)p;
    }
}

Product p = Factory.create(Product1.class);

public class Factory1 extends Factory{
  public static Product create(){
    return new Product1();
  }

}

public class Factory2 extends Factory{
  public static Product create(){
    return new Product2();
  }
}

public class ProductFactory{

    private static final Map<String,Product> pMap = new HashMap();

    public static synchronized Product createProduct(String type) throws Exception{
        Product p = null;
        if(pMap.containsKey(type)){
            p = pMap.get(type);
        }else{
            if(type.equals("Product1")){
                p = new Product1();
            }else{
                p = new Product2();
            }
        }
        return product;
    }
}

public class Singleton{

    private static Singleton instance = new Singleton();

    private Singleton(){}

    public static Singleton getInstance(){
        return instance;
    }
}

public class Singleton{

   private volatile static Singleton instance = null;

   private Singleton(){}

   public static Singleton getInstance(){
      if(instance == null){
         synchronized(Singleton.class){
            if(instance == null){
                instance = new Singleton();
            }
         }
      }
      return instance;
   }

}

public enum Singleton{
    instance;
}