简单工厂事实上不是一个设计模式，比較像一种编程习惯！

首先看一下代码，从代码中理解这个编程习惯。

举个做披萨的样例：

Pizza类代码：

public interface Pizza {    void prepare();    void box();    void bake();    void cut();}

详细的披萨CheesePizza:

public class CheesePizza implements Pizza {    private String tag="CheesePizza：";    @Override    public void prepare() {        System.out.println(tag+"pripare()");    }    @Override    public void box() {        System.out.println(tag+"box()");    }    @Override    public void bake() {        System.out.println(tag+"bake()");    }    @Override    public void cut() {        System.out.println(tag+"cut()");    }}

详细的披萨ClamPizza:

public class ClamPizza implements Pizza {    private String tag="ClamPizza：";    @Override    public void prepare() {        System.out.println(tag+"pripare()");    }    @Override    public void box() {        System.out.println(tag+"box()");    }    @Override    public void bake() {        System.out.println(tag+"bake()");    }    @Override    public void cut() {        System.out.println(tag+"cut()");    }}

简单工厂累：

public class SimplePizzaFactory {    public Pizza createPizza(String tpye){        Pizza pizza = null;        if (tpye.equals("cheese")){        pizza=new CheesePizza();        }else if (tpye.equals("clam")){         pizza=new ClamPizza();        }        return pizza;    }}

披萨订单类PizzaStore:

public  class PizzaStore {    SimplePizzaFactory simplePizzaFactory;    protected PizzaStore(SimplePizzaFactory simplePizzaFactory) {        this.simplePizzaFactory = simplePizzaFactory;    }    protected final Pizza orderPizza(String type){//        Pizza pizza=pizzafactory.createP(type);        Pizza pizza=simplePizzaFactory.createPizza(type);        pizza.prepare();        pizza.bake();        pizza.cut();        pizza.box();        return pizza;    }}

測试代码：

public static void main(String[] args){    PizzaStore chijiaPizzaStore=new PizzaStore(new SimplePizzaFactory());     chijiaPizzaStore.orderPizza("cheese");     chijiaPizzaStore.orderPizza("clam");    }

打印结果：

CheesePizza：pripare()CheesePizza：bake()CheesePizza：cut()CheesePizza：box()ClamPizza：pripare()ClamPizza：bake()ClamPizza：cut()ClamPizza：box()

从代码中能够看出，创建对象之前，事实上是把对象的共同操作方法抽象出来，为以后对象的扩展做准备，这个接口能够是接口类或者是抽象类，由详细的子类实现或者继承。可是对于简单工厂里的方法，仅仅确定创建哪个详细的对象。

来看一个比較通用的工厂模式框架代码：

抽象产品类：

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

详细产品类

public class ConcreteProduct1 implements Product{        @Override        public void method2() {                    }    }public class ConcreteProduct2 implements Product{        @Override        public void method2() {                    }    }

抽象工厂类：

public abstract  class Creator {    /**     *     * @param c     * @param 
     
       參数类型能够自行设置，通常为String，emum，Class等，也能够为空     * @return     */    public abstract 
      
        T createProducts(Class
       
         c);}
       
      
     

详细工厂类：

public class ConcreteFactory extends Creator {               @Override        public 
     
       T createProducts(Class
      
        c) {            Product product=null;            try {                product= (Product) Class.forName(c.getName()).newInstance();            } catch (InstantiationException e) {                e.printStackTrace();            } catch (IllegalAccessException e) {                e.printStackTrace();            } catch (ClassNotFoundException e) {                e.printStackTrace();            }            return (T) product;        }    }
      
     

详细代码測试类：

Creator creator=new ConcreteFactory();  Product product=  creator.createProducts(COncreteProduct2.class);

假设一个模块仅须要一个工厂类，没有必要把它生产出来，使用静态方法就能够啦，把上述的抽象工厂类直接替换为详细工厂类，并使用静态方法就能够，这样就变为简单工厂模式，或者是静态工厂模式。

写的不好，希望多提意见，共同进步学习！谢谢