设计模式2——Factory设计模式

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();
    }
}

工厂模式中，重要的是工厂类，而不是产品类。产品类能够是多种形式，多层继承或者是单个类都是能够的。但要明确的，工厂模式的接口只会返回一种类型的实例，这是在设计产品类的时候须要注意的，最好是有父类或者共同实现的接口。

使用工厂模式，返回的实例必定是工厂建立的，而不是从其余对象中获取的。工厂模式返回的实例能够不是新建立的，返回由工厂建立好的实例也是能够的。

三种工厂模式的区别：

简单工厂 ： 用来生产同一等级结构中的任意产品，对于增长新的产品，无能为力。

抽象工厂 ：用来生产不一样产品族(由不一样产品组合成的一套产品)的所有产品，对于增长新的产品，无能为力；支持增长产品族。

工厂方法 ：用来生产同一等级结构中的固定产品，支持增长任意产品。