简单工厂模式（Simple Factory Pattern）又叫静态工厂方法模式（Static FactoryMethod Pattern）

：由一个工厂类根据传入的参数动态决定应该创建哪一种产品（产品类）。

UML图：

 工厂角色（Factory）-->SimpleFactory：创建所需要的产品对象，被客户端调用。

 抽象（abstract Product）-->Ball 产品角色：所有具体产品的父类，父类可以是接口也可以是抽象类，产品的公共接口。

 具体产品（Concrete Product）----> FootBall & BaketBall角色：简单工厂所创建的具体产品对象。

 

实例：Ball简单工厂

抽象（abstract Product）产品角色：public abstract class Ball

package com.maggie.simplefactory;public  abstract  class Ball {     private String color;    public Ball(String color) {         super ();         this .color = color;    }    public Ball() {         super ();    }    public String getColor() {         return color;    }    public  void setColor(String color) {         this .color = color;    }        public  abstract  void play();    }

 

具体产品（Concrete Product）角色：从public abstract class Balll继承，重写方法，也可添加自己的方法。

FootBall

package com.maggie.simplefactory;public  class FootBall extends Ball {
          @Override    public  void play() {
              String player = "the ball's color is "+ this .getColor()+",I am FootBall" ;        System.out.println(player);    }    public FootBall() {         super ();         // TODO Auto-generated constructor stub     }    public FootBall(String color) {         super (color);         // TODO Auto-generated constructor stub     }    }

 

BasketBall

package com.maggie.simplefactory;public  class BasketBall extends Ball {
          @Override    public  void play() {
              String player = "the ball's color is "+ this .getColor()+",I am BasketBall" ;        System.out.println(player);    }    public BasketBall() {         super ();         // TODO Auto-generated constructor stub     }    public BasketBall(String color) {         super (color);         // TODO Auto-generated constructor stub     }}

 

 

 工厂角色（SimpleFactory）：球生产厂类，静态方法，接收main传入的图形名称，找到相应的具体产品的class，实例化。

这里使用反射实现

package com.maggie.simplefactory;import java.lang.reflect.InvocationTargetException;public  class SimpleFactory {     public  static Ball createBall(Class c) {
              Ball ball = null ;        /*         * ball = (Ball)Class.forName(c.getName()).newInstance(); 无参数构造函数的实例         */        try {             // 有参数构造函数的实例            if (c.getName().contains("FootBall" )) {
                      ball = (Ball) c.getConstructor(String. class ).newInstance("white+black" );            } else  if (c.getName().contains("BasketBall" )){
                      ball = (Ball) c.getConstructor(String. class ).newInstance("orange" );            }        } catch (InstantiationException e) {             // TODO Auto-generated catch block             e.printStackTrace();        } catch (IllegalAccessException e) {             // TODO Auto-generated catch block             e.printStackTrace();        } catch (IllegalArgumentException e) {             // TODO Auto-generated catch block             e.printStackTrace();        } catch (InvocationTargetException e) {             // TODO Auto-generated catch block             e.printStackTrace();        } catch (NoSuchMethodException e) {             // TODO Auto-generated catch block             e.printStackTrace();        } catch (SecurityException e) {             // TODO Auto-generated catch block             e.printStackTrace();        }        return ball;    }}

客户端调用

package com.maggie.simplefactory;public  class Client {     public  static  void main(String[] args) {
              Ball ball = SimpleFactory.createBall(FootBall. class );        ball.play();                Ball ball2 = SimpleFactory.createBall(BasketBall. class );        ball2.play();    }}

输出的结果：

the ball's color is white+black,I am FootBallthe ball's color is orange,I am BasketBall

 

简单工厂模式使得客户端的代码变得简洁，不用去关心具体是怎么实现的

但是工厂类里面包含了所有的逻辑，如果需要添加新的产品，则就需要改变工厂类的各种逻辑，这就是简单工厂不好的地方。

因此简单工厂模式违背了开放-封闭原则的缺点