工厂模式

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

简单工厂（Simple Factory）模式：又称静态工厂方法模式（Static Factory Method Pattern）

工厂方法（Factory Method）模式：又称多态性工厂模式（Polymorphic Factory Pattern）或虚拟构造子模式（Virtual Construct Pattern）

抽象工厂（Abstract Factory）模式：又称工具箱模式（Kit或Tookit）

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

简单工厂模式（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