分類

工廠模式主要是為建立物件提供過渡介面，以便將建立物件的具體過程遮蔽隔離起來，達到提高靈活性的目的。 工廠模式可以分為三類：

1）簡單工廠模式（Simple Factory） 2）工廠方法模式（Factory Method） 3）抽象工廠模式（Abstract Factory）

一、簡單工廠模式

定義

建立一個工廠（一個函式或一個類方法）來製造新的物件。

示例

public static Operation createOperate(string operate) {
    Operation oper = null;
    switch (operate)
    {
        case "+":
            {
            oper = new OperationAdd();
            break;
            }
        case "-":
            {
            oper = new OperationSub();
            break;
            }
        case "*":
            {
            oper = new OperationMul();
            break;
            }
        case "/":
            {
            oper = new OperationDiv();
            break;
            }
    }
    return oper;
   }
}
 

Android中的例項

Android原生的Context.getSystemService()介面，根據不同服務名稱，獲取不同服務物件返回。

public Object getSystemService(String name) {
            if (getBaseContext() == null) {
                throw new IllegalStateException("System services not available to Activities before onCreate()");
            }
            //........
            if (WINDOW_SERVICE.equals(name)) {
                return mWindowManager;
            } else if (SEARCH_SERVICE.equals(name)) {
                ensureSearchManager();
                return mSearchManager;
            }
            //.......
            return super.getSystemService(name);
        }
 

二、工廠方法模式

定義

是定義一個建立產品物件的工廠介面，讓其子類決定例項化哪一個類，將實際建立工作推遲到子類當中。

示例

public abstract class Product {
    public abstract void method();
}

public class ConcreteProduct extends Prodect {
    public void method(){
        System.out.println("我是具體產品！");
    }
}

public  abstract class Factory{
    public abstract Product createProduct();
}

public class ConcreteFactory extends Factory{

    public Product createProduct(){
        return new ConcreteProductA();
    }
}
 

Android中的例項

我們知道Iterator是迭代器，用來遍歷一個集合中的元素。而不同的資料結構遍歷的方式是不一樣的，所以迭代器的實現也是不同的。使用工廠方法模式將迭代器的具體型別延遲到具體容器類中，比較靈活，容易擴充套件。

public interface Iterable {
    /**      * Returns an iterator over elements of type {@code T}.      *      * @return an Iterator.      */
    Iterator iterator();

    //省略部分程式碼
}
private void testFactoryMethod() {
    List<String> list = new ArrayList<String>();
    Iterator<String> ite = list.iterator();

    Set<String> set = new HashSet<String>();
    ite = set.iterator();
}

不同的具體容器，返回不同的Iterator類，比如ArrayList類：

@Override
public Iterator iterator() {
    return new ArrayListIterator();
}

ArrayListIterator型別定義如下：

private class ArrayListIterator implements Iterator {
    /** Number of elements remaining in this iteration */
    private int remaining = size;

    /** Index of element that remove() would remove, or -1 if no such elt */
    private int removalIndex = -1;

    /** The expected modCount value */
    private int expectedModCount = modCount;

    public boolean hasNext() {
        return remaining != 0;
    }

    @SuppressWarnings("unchecked") public E next() {
        ArrayList ourList = ArrayList.this;
        int rem = remaining;
        if (ourList.modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        if (rem == 0) {
            throw new NoSuchElementException();
        }
        remaining = rem - 1;
        return (E) ourList.array[removalIndex = ourList.size - rem];
    }

    public void remove() {
        Object[] a = array;
        int removalIdx = removalIndex;
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        if (removalIdx < 0) {
            throw new IllegalStateException();
        }
        System.arraycopy(a, removalIdx + 1, a, removalIdx, remaining);
        a[--size] = null;  // Prevent memory leak
        removalIndex = -1;
        expectedModCount = ++modCount;
    }
}

三、抽象工廠模式

定義

為建立一組相關或者是相互依賴的物件提供一個介面，而不需要制定他們的具體類 抽象工廠模式是指當有多個抽象角色時，使用的一種工廠模式。抽象工廠模式可以向客戶端提供一個介面，使客戶端在不必指定產品的具體情況下，建立多個產品族中的產品物件。

示例

public abstract class AbstractProductA{
    public abstract void method();
}
public abstract class AbstractProdectB{
    public abstract void method();
}

public class ConcreteProductA1 extends AbstractProductA{
    public void method(){
        System.out.println("具體產品A1的方法！");
    }
}
public class ConcreteProductA2 extends AbstractProductA{
    public void method(){
        System.out.println("具體產品A2的方法！");
    }
}
public class ConcreteProductB1 extends AbstractProductB{
    public void method(){
        System.out.println("具體產品B1的方法！");
    }
}
public class ConcreteProductB2 extends AbstractProductB{
    public void method(){
        System.out.println("具體產品B2的方法！");
    }
}

public abstract class AbstractFactory{
    public abstract AbstractProductA createProductA();

    public abstract AbstractProductB createProductB();
}

public  class ConcreteFactory1 extends AbstractFactory{
    public  AbstractProductA createProductA(){
        return new ConcreteProductA1();
    }

    public  AbstractProductB createProductB(){
        return new ConcreteProductB1();
    }
}

public  class ConcreteFactory2 extends AbstractFactory{
    public  AbstractProductA createProductA(){
        return new ConcreteProductA2();
    }

    public  AbstractProductB createProductB(){
        return new ConcreteProductB2();
    }
}