Android工廠模式詳解

一、工廠模式的概念

工廠模式是面向對象設計中最常用的設計模式之一。它是一種創建型模式，其主要思想是定義一個創建對象的接口，將對象的創建和使用分離開。

二、簡單工廠模式

簡單工廠模式(Simple Factory Pattern)又稱靜態工廠方法(Static Factory Method)模式，它是工廠模式的一種。簡單工廠模式是由一個工廠類根據傳入的參數，動態決定應該創建哪一個產品對象。簡單工廠模式只需要一個工廠類就可以完成所有的產品創建任務，而且這個工廠類可以被外界直接調用，而不需要暴露產品對象創建的邏輯。

以下是一個簡單工廠模式的實現示例：

//定義產品接口
public interface Product {
    void show();
}

//定義具體產品類
class ProductA implements Product {
    @Override
    public void show() {
        System.out.println("ProductA");
    }
}

class ProductB implements Product {
    @Override
    public void show() {
        System.out.println("ProductB");
    }
}

//定義工廠類
public class Factory {

    public static Product createProduct(int type) {
        switch (type) {
            case 0:
                return new ProductA();
            case 1:
                return new ProductB();
            default:
                return null;
        }
    }
}

//使用
public class Main {
    public static void main(String[] args) {
        Product product = Factory.createProduct(0);
        if (product != null) {
            product.show();
        }
    }
}

三、工廠方法模式

工廠方法模式(Factory Method Pattern)又稱工廠模式，它屬於創建型模式。工廠方法模式是定義一個創建產品對象的工廠接口，將實際創建工作推遲到子類中，這樣核心類就變成了抽象類。工廠方法模式可以根據需求定義多個具體的工廠類，具體工廠類負責創建具體的產品對象。

以下是一個工廠方法模式的實現示例：

//定義產品接口
public interface Product {
    void show();
}

//定義具體產品類
class ProductA implements Product {
    @Override
    public void show() {
        System.out.println("ProductA");
    }
}

class ProductB implements Product {
    @Override
    public void show() {
        System.out.println("ProductB");
    }
}

//定義工廠接口
public interface Factory {
    Product createProduct();
}

//定義具體工廠類
class FactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

class FactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

//使用
public class Main {
    public static void main(String[] args) {
        Factory factory = new FactoryA();
        Product product = factory.createProduct();
        product.show();
    }
}

四、抽象工廠模式

抽象工廠模式(Abstract Factory Pattern)是一種創建型模式，它提供了一種創建一系列相關或相互依賴對象的接口，而無需指定它們具體的類。抽象工廠模式通常用於創建一組產品族，而工廠方法模式通常用於創建一個產品。

以下是一個抽象工廠模式的實現示例：

//定義產品A接口
public interface ProductA {
    void show();
}

//定義產品B接口
public interface ProductB {
    void show();
}

//定義具體產品A類
class ConcreteProductA1 implements ProductA {
    @Override
    public void show() {
        System.out.println("ConcreteProductA1");
    }
}

class ConcreteProductA2 implements ProductA {
    @Override
    public void show() {
        System.out.println("ConcreteProductA2");
    }
}

//定義具體產品B類
class ConcreteProductB1 implements ProductB {
    @Override
    public void show() {
        System.out.println("ConcreteProductB1");
    }
}

class ConcreteProductB2 implements ProductB {
    @Override
    public void show() {
        System.out.println("ConcreteProductB2");
    }
}

//定義工廠接口
public interface AbstractFactory {
    ProductA createProductA();

    ProductB createProductB();
}

//定義具體工廠類
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

//使用
public class Main {
    public static void main(String[] args) {
        AbstractFactory factory = new ConcreteFactory1();
        ProductA productA = factory.createProductA();
        ProductB productB = factory.createProductB();
        productA.show();
        productB.show();
    }
}

五、工廠模式在Android中的應用

在Android中，我們可以使用工廠模式來實現對象的創建和管理，比如在開發中，通過工廠方法來創建不同的Fragment、Adapter等，來動態滿足不同需求。

以下是一個Android中使用工廠模式的示例：

//定義產品接口
public interface FragmentProduct {
    Fragment create();
}

//定義具體產品類
class HomeFragmentProduct implements FragmentProduct {
    @Override
    public Fragment create() {
        return new HomeFragment();
    }
}

class MessageFragmentProduct implements FragmentProduct {
    @Override
    public Fragment create() {
        return new MessageFragment();
    }
}

//定義工廠類
public class FragmentFactory {
    public static Fragment createFragment(int type) {
        FragmentProduct product = null;
        switch (type) {
            case 0:
                product = new HomeFragmentProduct();
                break;
            case 1:
                product = new MessageFragmentProduct();
                break;
        }
        if (product != null) {
            return product.create();
        } else {
            return null;
        }
    }
}

//使用
public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Fragment fragment = FragmentFactory.createFragment(0);
        getSupportFragmentManager().beginTransaction().replace(R.id.container, fragment).commit();
    }
}