死磕设计模式-工厂模式

四、工厂模式

4.1 传统方式

传统要获取一个类的对象，通常的方法是在本类中通过一个new操作符产生一个指定类的对象实例

public class Produce1 {  
    public Produce1(){  
        //Produce1的构造函数
    }  
}  

public class Produce2 {  
    public Produce2(){  
        //Produce2的构造函数
    }  
}  

public class Client {  
    public static void main(String[] args) {  
        Produce1 p1 = new Produce1();  
        Produce2 p2 = new Produce2();  
    }  
} 

很显然如果用上面的方式获取少数的Produce的对象是可行的，但多了就不行了，而且会导致类与类之间的耦合度非常高，于是出现了工厂模式，工厂模式就是屏蔽创建对象的具体过程，用户只需要调用工厂方法就可以得到对象的实例。

工厂模式按其复杂程度分为三类：简单工厂、工厂、抽象工厂模式。

4.2 简单工厂模式

特点：

一个抽象产品类，可以派生出多个具体产品类。

一个具体工厂类，用于生产产品。

简单工厂模式的类图如下：

Java代码如下：

abstract class Produce {  
    public create();
}  

public class Produce1 extends Produce {  
    public create() {  
        System.out.println("生产Produce1");  
    }  
}  
public class Produce2 extends Produce{  
    public create(){  
        System.out.println("生产Produce2");  
    }  
}  

public class Factory {  
    public Produce createProduce(int type) {  
        switch (type) {  

        case 1:  
            return new Produce1().create();  

        case 2:  
            return new Produce2().create();  

        default:  
            break;  
        }  
        return null;  
    }  
}  

4.3 工厂模式

特点：

一个抽象产品类，可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类只能创建一个具体产品类的实例。

工厂模式的类图如下：

Java代码如下：

abstract class Produce {  
    public create();
}  
public class Produce1 extends Produce {  
    public create() {  
        System.out.println("生产Produce1");  
    }  
}  
public class Produce2 extends Produce{  
    public create(){  
        System.out.println("生产Produce2");  
    }  
}  
interface Factory {  
    Produce createProduce();  
}  

public class Factory1 implements Factory{  

    public void createProduce() {  
        return new Produce1().create();  
    }  

}  
public class Factory2 implements Factory {  

    public void createProduce() {  
        return new Produce2().create();  
    }  
} 

4.4 抽象工厂模式

特点：

多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类可以创建多个具体产品类的实例。

抽象工厂模式的类图如下：

Java代码如下：

interface ProductA {

    void create();
}

interface ProductB {

    void create();
}

class ProductA1 implements ProductA{

    public void create() {
        System.out.println("生产ProductA1");
    }

}

class ProductA2 implements ProductA{

    public void create() {
        System.out.println("生产ProductA2");
    }

}

class ProductB1 implements ProductB{

    public void create() {
        System.out.println("生产ProductB1");
    }

}

class ProductB2 implements ProductB{

    public void create() {
        System.out.println("生产ProductB2");
    }

}
public interface Factory {

    ProductA createProductA();

    ProductB createProductB();

}
public class Factory1 implements Factory{

    public ProductA createProductA() {
        return new ProductA1();
    }

    public ProductB createProductB() {
        return new ProductB1();
    }

}

public class Factory2 implements Factory{

    public ProductA createProductA() {
        return new ProductA2();
    }

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

}

在Java的JDK中，我们能找到一个很典型的抽象工厂模型：迭代器。在Java JDK 1.2 引进了一个容器类接口，其中包含了一个iterator()方法，所有容器类均实现了该方法，iterator方法是一个工厂方法，它使得调用者不知道iterator对象是由哪个类实例化的。

比如list.iterator()；set.iterator()；我们不必关心iterator方法返回值是什么，只需要知道迭代器支持什么样的容器接口，才能遍历出集合中的元素。

List的Iterator的抽象工厂模式类图：