工厂模式

工厂模式分为三种模式，分别为：

•  简单工厂（Simple Factory）模式：又称静态工厂方法模式（Static Factory Method Pattern）
• 工厂方法（Factory Method）模式：又称多态性工厂模式（Polymorphic Factory Pattern）或虚拟构造子模式（Virtual Construct Pattern）
• 抽象工厂（Abstract Factory）模式：又称工具箱模式（Kit或Tookit）

下面就分别介绍一下这三种设计模式：

1.  简单工厂模式（Simple Factory）：

　　简单工厂模式就是由一个工厂类根据传入的参数量，来决定创建哪一种产品类的实例。（仔细理解这句话，非常重要）

结构图：

 

上图涉及三个类：

• 工厂类（Creator）：担任工厂模式的核心。工厂类在客户端的调用下直接创建对象，它往往由一个具体类java类实现。
• 抽象产品类（Product）：具体产品类的接口或抽象类。
• 具体产品类（ConcreteProduct）：工厂方法模式所创建的任何角色都是这个角色的实例

源代码实例：

抽象产品类（Product）：

Product.java:

public interface Product {
}

具体产品类（ConcreteProduct）：

ConcreteProductA.java:

public class ConcreteProductA implements Product{
    public ConcreteProductA(){
        System.out.println("具体产品类A");
    }
}

ConcreteProductB.java:

public class ConcreteProductB implements Product{
    public ConcreteProductB(){
        System.out.println("具体产品类B");
    }
}

工厂类（Creator）：

Creator.java:

public class Creator {
    
    public static Product factory(String which){
        if (which.equalsIgnoreCase("ConcreteProductA")) {
            return new ConcreteProductA();
        }else if (which.equalsIgnoreCase("ConcreteProductB")) {
            return new ConcreteProductB();
        }else {
            return null;
        }
    }
}

客户端：

public class Client {
    public static void  main(String[] args){
        Creator creator = new Creator();
        creator.factory("ConcreteProductB");
        creator.factory("ConcreteProductA");
        
    }
}

输出：

具体产品类B
具体产品类A

　　　　2、工厂方法模式（Factory Method）

 　　　　工厂方法模式中核心工厂类变为一个抽象类，仅负责给出具体工厂子类必须实现的接口，不再接触哪一个产品类被实例化这种细节。

结构中成员类和上面差不多,：

• 抽象工厂类（Creator）：为所有具体工厂类提供接口。
• 具体工厂类（ConcreteCreator）：担任这个角色是实现了抽象工厂接口的具体java类，并且受到应用程序的调用来创建产品。
• 抽象产品（Product）
• 具体产品（ConcreteProduct）

抽象方法将某一个产品和一个工厂进行了绑定，这是他与另外两个工厂模式的区别。下面注意看代码：源代码：

抽象产品（Product）：

public interface Product {

}

 具体产品（ConcreteProduct）类：

ConcreProductA.java:

public class ConcreteProductA implements Product{
    public ConcreteProductA(){
        System.out.println("具体产品类A");
    }
}

ConcreProductB.java:

public class ConcreteProductB implements Product{
    public ConcreteProductB(){
        System.out.println("具体产品类B");
    }
}

抽象工厂类（Creator）：

Creator.java:

public interface Creator {
    public Product factory();
}

具体工厂类（ConcreteCreator）：

ConcreteCreatorA.java:

public class ConcreteCreatorA implements Creator{

    @Override
    public Product factory() {
        return new ConcreteProductA();
    }
}

ConcreteCreatorB.java:

public class ConcreteCreatorB implements Creator{
    
    @Override
    public Product factory() {
        return new ConcreteProductB();
    }
    
}

客户端：

public class Client {

    public static void main(String[] args){
        Creator creatorA = new ConcreteCreatorA();
        creatorA.factory();
        Creator creatorB = new ConcreteCreatorB();
        creatorB.factory();
    }
}

输出：

具体产品类A
具体产品类B

　　　　3、抽象工厂模式（Abstract Factory）

　　抽象工厂模式是对象的创建模式，他是工厂方法模式的进一步扩展。使用抽象工厂模式，可以创建来自不同工厂的各种产品。

结构图中的角色：

• 抽象工厂类（Creator）
• 具体工厂类（ConcreteCreator）
• 抽象产品（Product）
• 具体产品（ConcreteProduct）

源代码：

抽象产品类（Product）：

ProductA.java

public interface ProductA {
}

ProductB.java

public interface ProductB {
}

具体产品类（ConcreteProduct）：

ProductA1.java

public class ProductA1 implements ProductA{
    
    public ProductA1(){
        System.out.println("具体产品A1");
    }
}

productA2.java、productB1.java、productB2.java与上类似，不在列出。

抽象工厂类（Creator）：

Creator.java

public interface Creator {
    
    public ProductA factoryA();
    public ProductB factoryB();
}

 具体工厂类（ConcreteCreator）：

ConcreteCreator1.java

public class ConcretCreator1 implements Creator{

    public ConcretCreator1(){
        System.out.println("具体工厂1:");
    }
    public ProductA factoryA(){
        return new ProductA1();
    }
    public ProductB factoryB(){
        return new ProductB1();
    }

}

ConcreteCreator2.java

public class ConcretCreator2 implements Creator{

    public ConcretCreator2(){
        System.out.println("具体工厂2:");
    }
    public ProductA factoryA() {
        return new ProductA2();
    }

    public ProductB factoryB() {
        return new ProductB2();
    }

}

 客户端：

public class client {
    public static void main(String[] args){
        //抽象工厂1
        Creator creator1 = new ConcretCreator1();
        creator1.factoryA();
        creator1.factoryB();
        Creator creator2 = new ConcretCreator2();
        creator2.factoryA();
        creator2.factoryB();
    }
}

 输出：

具体工厂1:
具体产品A1
具体产品B1
具体工厂2:
具体产品A2
具体产品B2