工厂模式

Factory工厂设计模式为创建对象提供了一种抽象，而对使用者屏蔽了对象创建的具体细节过程，工厂模式有三种：简单工厂模式，抽象工厂模式和工厂方法模式。
(1).简单工厂模式：
又叫静态工厂模式，简单工厂只包括一个抽象产品类（该类可以是接口，也可以是具体的类），所有需要的产品类都是该抽象产品类的子类。简单工厂模式中工厂为具体产品工厂，产品为抽象产品，由工厂实例创建产品实例：


一个生成圆形和矩形的图形工厂，例子如下：

//图形接口  
interface Shape(){  
    public void draw();  
}  
//圆形  
class Circle implements Shape{  
    public void draw(){  
    System.out.println(“Circle is drawing”);  
}  
}  
//矩形  
class Rectangle implements Shape{  
    public void draw(){  
    System.out.println(“Rectangle is drawing”);  
}  
}  
//图形工厂  
class ShapeFactory{  
    public static Shape createShape(String name) throws InstantiationException,   
                                      IllegalAccessException,   
                                      ClassNotFoundException  
    {  
    //使用java的反射机制来产生对象实例  
    return (Shape)class.forName(name).newInstance();  
}  
}   
public class ShapeDemo{  
    public static void draw(Shape shape){  
    shape.draw();  
}  
    public static void main(String[] args){  
    draw(ShapeFactory.createShape(“Circle”));  
    draw(ShapeFactory.createShape(“Rectangle”));  
}  
}  

图形工厂负责具体图形的对象实例化工作，图形使用者使用时不需要关心图形对象的具体产生过程。
(2).抽象工厂模式：
抽象工厂模式中可以包括多个抽象产品类，每个抽象产品类可以产生出多个具体产品类，一个抽象工厂用于定义所需产品的组合形式，抽象工厂派生具体工厂类，这些具体工厂类就是简单工厂模式中的工厂类，具体工厂类负责具体产品实例的创建：


以软件皮肤为例，软件皮肤由样式style和颜色color组成，实现一套IOS风格的软件皮肤，一套Android风格的软件皮肤，通过抽象工厂实现软件皮肤自由切换例子如下：

//软件皮肤类   
class Skin{  
    private SkinFactory skinFactory;  
    public Skin(SkinFactory factory){  
    setSkinFactory(factory);  
}  
public void setSkinFactory(SkinFactory factory){  
    this.skinFactory = factory  
}  
public void showSkin(){  
    System.out.println(“Style=” + factory.getStyle().showStyle() + “, color=” + factory.getColor().showColor());  
}  
}  
//软件Style  
interface Style(){  
    public void showStyle();  
}  
//IOS style  
class IOSStyle implements Style{  
    public void showStyle(){  
    System.out.println(“This is IOS style”);  
}  
}  
//Android style  
class AndroidStyle implements Style{  
    public void showStyle(){  
    System.out.println(“This is Android style”);  
}  
}  
//软件Color  
interface Color(){  
    public void showColor();  
}  
//IOS color  
class IOSColor implements Color{  
    public void showColor(){  
    System.out.println(“This is IOS color”);  
}  
}  
//Android color  
class AndroidColor implements Color{  
    public void showColor(){  
    System.out.println(“This is Android color”);  
}  
}  
//抽象皮肤工厂  
interface SkinFactory{  
    public Style getStyle();  
    public Color getColor();  
}  
//IOS皮肤工厂  
class IOSSkinFactory implements SkinFactory{  
    public Style getStyle(){  
        return new IOSStyle();  
}  
    public Color getColor(){  
        return new IOSColor();  
}  
}  
//Android皮肤工厂  
class AndroidSkinFactory implements SkinFactory{  
    public Style getStyle(){  
        return new AndroidStyle();  
}  
    public Color getColor(){  
        return new AndroidColor();  
}  
}  
public class SkinDemo{  
    public static void main(String[] args){  
        //显示一套IOS皮肤  
    Skin skin = new Skin(new IOSSkinFactory());  
    skin.showSkin();  
    //换一套Android的皮肤  
    skin.setSkinFactory(new AndroidSkinFactory());  
    skin.showSkin();  
}  
}  

抽象工厂指定了产品组合形式，具体的工厂产生具体的产品，抽象工厂适用于多个产品相互组合的情况。
(3).工厂方法模式：
工厂方法中也只包含一个抽象产品类，抽象产品类可以派生出多个具体产品类。工厂方法定义一个用于创建产品的接口，让子类决定实例化哪一个类，使得类的实例化延迟到子类。


工厂方法模式例子如下：

//汽车接口  
interface ICar{  
    public void run();  
}  
//奔驰车  
class BenzCar implements ICar{  
    public void run(){  
    System.out.println(“Benz car run”);  
}  
}  
//宝马车  
class BMWCar implements ICar{  
    public void run(){  
    System.out.println(“BMW car run”);  
}  
}  
//抽象汽车工厂  
abstract class CarFactory{  
    public abstract ICar createCar();  
}  
//奔驰车工厂  
class BenzCarFactory extends CarFactory{  
    public ICar createCar(){  
    return new BenzCar();  
}  
}  
//宝马车工厂  
class BMWCarFactory extends CarFactory{  
    public ICar createCar(){  
    return new BMWCar();  
}  
}  
public class FactoryMethodDemo{  
    public static void main(String[] args){  
    CarFactory factory = new BenzCarFactory();  
    ICar car = factory.createCar();  
    car.run();  
    factory = new BMWCarFactory();  
    car = factory.createCar();  
    car.run();  
}  
}  

工厂模式中，重要的是工厂类，而不是产品类。产品类可以是多种形式，多层继承或者是单个类都是可以的。但要明确的，工厂模式的接口只会返回一种类型的实例，这是在设计产品类的时候需要注意的，最好是有父类或者共同实现的接口。
使用工厂模式，返回的实例一定是工厂创建的，而不是从其他对象中获取的。工厂模式返回的实例可以不是新创建的，返回由工厂创建好的实例也是可以的。
三种工厂模式的区别：
简单工厂 ： 用来生产同一等级结构中的任意产品，对于增加新的产品，无能为力。
工厂方法 ：用来生产同一等级结构中的固定产品，支持增加任意产品。
抽象工厂 ：用来生产不同产品族(由不同产品组合成的一套产品)的全部产品，对于增加新的产品，无能为力；支持增加产品族。