工厂模式

定义

定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使类的实例化延迟到子类

例：通用可扩展

//产品抽象
public abstract class Product{
    //公共方法
    public void cmmmonMethod（）{}
    //子类实现方法
    public abstract void privateMethod(){}
}
//子类
public Prodect1 extends Product{
    public abstract void privateMethod(){
        //实现
    }
}
public Prodect2 extends Product{
    public abstract void privateMethod(){
        //实现
    }
}

//工厂类接口
public abstract class Creator{
    public abstarct <T extends Product> T createProduct(Class<T> c);
}
//工厂类实现
public class CreatorImpl extends Creator{
    public <T extends Product> T createProduct(Class<T> c){
        Product product = null;
        try{
            product = (Product)Class.forName(c.getName).newInstance();
        }catch (Exception e){
            //异常处理
        }
    }
}

优点：

a:良好的封装性；
b:很好的扩展性；
c:屏蔽了产品类，调用者不用关心产品变化，只需要关注产品接口

扩展

简单工厂模式

//工厂类实现
public class CreatorImpl{
    public static <T extends Product> T createProduct(Class<T> c){
        Product product = null;
        try{
            product = (Product)Class.forName(c.getName).newInstance();
        }catch (Exception e){
            //异常处理
        }
    }
}

修改为不是继承，并静态化了方法

多个工厂类

通过继承工厂接口，每个工厂只生产一种类型的产品 所以接口不需要传递类型，直接返回所需要的产品类型。

//工厂类接口
public abstract class Creator{
    public abstract Product createProduct();
}

//实现类
public class ProductFactory1 extends Creater{
    public Prodect1 createProdect(){
        return new Prodect1();
    }
}

public class ProductFactory2 extends Creater{
    public Prodect1 createProdect(){
        return new Prodect1();
    }
}

替代单例模式（不建议，单例应该禁止暴力反射，避免出现多个实例，而且感觉这种模式很脑残）

通过工厂生产控制只生产一个产品，是内存只有一个对象，用来替换单例模式

//首先有个单例类
public class Single{
    private Single(){}
    public void doSomething(){}
}
public class SingleFactory{
    private static Single single;
    //通过反射获取对象
    static{
        try{
            Class c = Class.forName(Single.class.getName());
            //获取无参构造,并设置为可访问
            Constructor con = c.getDeclaredConstructor();
            con.setAccessible(true);
            single = (Single)con.newInstance();
        }catch (Exception e){
            System.out.println("生产失败了...");
        }
    }
    public static Single getSingle(){
        return this.single;
    }
}

带缓存的工厂(很鸡肋，扩展加缓存数量、使用频率、或者时间控制感觉能好些)

public class ProdectFactory{
    private static final Map<Prodect> pMap = new HashMap();
    public static synchronized Prodect creatProdect(String type) throws Expection{
        Product p = null;
        if(pMap.containKey(type)){
            p = pMap.get(type);
        }else{
            if(type.equals("Product1")){
                p = new Product1();
            }else if(type.equals("Product2")){
                p = new Product2();
            }
                ...
            pMap.put(type,p);    
        }
        return p;
    }
}