设计模式之工厂模式

Java工厂模式

工厂模式可以分为以下几类：

• 静态工厂模式（Static Factory）
• 简单工厂模式（Simple Factory）
• 工厂方法模式（Factory Method）
• 抽象工厂模式（Abstract Factory）

静态工厂模式

常见于我们的工具类，如TextUtil，基本类型包装类(Integer)等。
Effective Java 第一条介绍使用静态工厂方法代替构造器有如下优势：

• 他们有名称，当一个类需要多个带有相同签名的构造器时，就用静态工厂方法代替构造器
• 不必每次掉用的时候都创建一个新对象。
• 可以返回原类型的任何子类对象。
• 在创建参数化类型实例对象的时候，使代码变得更加简洁。

简单工厂模式

由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。

角色组成：
工厂（Creator)角色：它是简单工厂模式的核心，负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需要的产品对象。
抽象产品角色：它负责描述所有实例所共有的公共接口。
具体产品角色：是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

实例：

//抽象产品角色
public interface IProduct {
    public void saleProduct();
}
//具体产品角色
public class Product_A implements IProduct {
    @Override
    public void saleProduct(){
        ...        
    }

}
//具体产品角色
public class Product_B implements IProduct {
    @Override
    public void saleProduct(){
        ...        
    }

}
//工厂角色
public class Creator {
    public IProduct createProduct(int productFlag){
        switch(productFlag){
            case 1:
                return new Product_A();
            case 2:
                return new Product_B();
            default:
                return null; 
        }
    }
}

工厂方法模式

是简单工厂模式的衍生，定义一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法模式把类实例化的过程推迟到子类。

角色组成：
抽象工厂（Creator)角色：工厂方法模式的核心，任何在模式中创建的对象的工厂必须实现这个接口。
具体工厂（Concrete Creator)角色：实现抽象工厂接口的具体工厂类，包含应用程序的逻辑。
抽象产品（Product)角色：产品对象的共同父类或共同拥有的接口。
具体产品（Concrete Product)角色：实现了抽象产品角色定义的接口，其具体产品有专门的具体工厂创建。

实例：

实例：
//抽象工厂
public interface Creator{
       public Light factory();
}
//抽象产品
public interface Light{
    public void TurnOn();
    public void TrunOff();
}
//具体产品
public class BullbLight implements Light{
    public void TurnOn(){
    }

    public void TrunOff(){
    }
}
//具体产品
public class TubeLight implements Light{
    public void TurnOn(){
    }

    public void TrunOff(){
    }
}
//具体工厂
public class BullbCreator implements Creator{
       public Light factory(){
        return new BullbLight();
    }
}
//具体工厂
public class TubeCreator implements Creator{
       public Light factory(){
        return new TubeLight();
    }
}
public class Client{
       public static void main(String[] args){
              Creator create = new BullbCreator();
          Light bullbLight = create.factory();
          bullbLight.TurnOn();

              Creator create1 = new TubeCreator();
          Light tubebLight = create.factory();
          tubebLight.TurnOn();

       }
}

抽象工厂模式

提供一个接口，用于创建相关的或依赖对象的家族，而不需要明确指定具体类。

实例：

//抽象工厂角色
public interface AbstractFactory{
　　public ProductA createProductA();
　　public ProductB createProductB();
}

//抽象产品类A
public interface AbstractProductA {
}

//抽象产品类B
public interface AbstractProductB {
}

//具体产品类ProdcutA1
public class ProductA1 implements AbstractProductA {
　　public ProductA1()
　　{
　　}
}

//具体产品类ProdcutA2
public class ProductA2 implements AbstractProductA {
　　public ProductA2()
　　{
　　}
}

//具体产品类ProductB1
public class ProductB1 implements AbstractProductB {
　　public ProductB1()
　　{
　　}
} 

//具体产品类ProductB2
public class ProductB2 implements AbstractProductB {
　　public ProductB2()
　　{
　　}
}

//具体工厂类1
public class ConcreteFactory1 implements AbstractFactory{
　　public AbstractProductA createProductA(){
　　return new ProductA1();
　　}
　　public AbstractProductB createProductB(){
　　return new ProductB1();
    }
}

//具体工厂类2
public class ConcreteFactory2 implements Creator{
　　public AbstractProductA createProductA(){
　　return new ProductA2();
　　}
　　public AbstractProductB createProductB(){
　　return new ProductB2();
　　}
} 

总结

（1）简单工厂模式是由一个具体的类去创建其他类的实例，父类是相同的，父类是具体的。
（2）工厂方法模式是有一个抽象的父类定义公共接口，子类负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成。
（3）抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。

参考：

Java设计模式二：抽象工厂模式(Abstract Factory)/工厂方法(Factory Method)
学习：java设计模式—工厂模式