设计模式——工厂方法模式

工厂方法模式

定义：通过定义一个用于创建对象的接口，让子类决定实例化哪个类

需要生成复杂对象的地方，可以使用工厂模式，如果只用new就可以完成创建的对象无需使用工厂模式

四大模块：抽象工厂类、具体工厂类、抽象产品、具体产品。需要哪一个产品就去生产哪一个产品

其实比较简单吧，工厂模式有比较好的扩展性

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

public class ProductA extends Product {
    @Override
    public void method() {}
}

public class ProductB extends Product {
    @Override
    public void method() {}
}


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

public class FactoryA extends Factory {
    @Override
    protected Product createProduct() {
        return new ProductA();
    }
}

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

// 调用
Factory factoryA = new FactoryA();
Product productA = factory.createProduct();
productA.method();

Factory factoryB = new FactoryB();
Product productB = factory.createProduct();
productA.method();

如果采用反射写更加简单：

public abstract class Factory {
    public abstract <T extends Product> T createProduct(Class<T> clz);
}

class FactoryImpl extends Factory{
    @Override
    public <T extends Product> T createProduct(Class<T> clz) {
        Product product = null;
        try {
            product = (Product) Class.forName(clz.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) product;
    }
}

// 调用
Factory factory = new FactoryImpl();
Product product = factory.createProduct(Product.class);
product.method();

简单工厂/静态工厂模式

如果我们确定工厂类只有一个，我们就可以将抽象简化掉，直接用静态方法就可以

一个产品基类，若干产品类继承这个基类，一个工厂类静态方法根据传入的不同参数来生产产品，也算达到工厂模式的一个基本功能，将实例化对象的操作封装起来，这里我是直接想到迪米特原则，最少知道原则，调用者只是想要一个对象实例，而不想关心它是如何创建的。其实在android开发中遇到的问题大多也就是简单工厂就能解决了的

public abstract class Product {
    public abstract void method()  
}
public class ProductA extends Product {
    public void method() 
}
public class ProductB extends Product {
    public void method()
}
public class ProductC extends Product {
    public void method()
}

public class Factory {
    public static createProduct(String name) {
        switch(name) {
            case "A": 
                return new ProductA();
            case "B": 
                return new ProductB();
            case "C": 
                return new ProductC();
            default: 
                return null;
        }
    }
}

// main方法中调用
Product product = Factory.createProduct("A");
product.method();

对于Android呢，其实Activity的onCreate()方法可以看作是一个工厂方法模式的create()方法，onCreate()方法中的setContentView()相当于构造了一个view

工厂方法模式是一个具有可扩展性的设计模式，但是添加越来越多的产品，会导致类的结构复杂化，我们应该酌情考虑是否需要使用工厂方法模式

抽象工厂模式

定义：为创建一组相关或者相互依赖的对象提供一个接口，而不需要指定它们的具体类

其实一开始看了一些书籍还没弄明白抽象工厂和工厂方法有什么区别，还特别纳闷，不都是那个意思吗？其实多读几遍就明白了，它们的区别在于：一个和一组

工厂方法模式：市里面有生产汽车的工厂，我们想引进一种新的汽车，那么需要找到新的车企工厂来生产，就需要新增一个汽车类和一个工厂类了，它们分别去继承它们的抽象类，而且每个工厂只能生产自家的汽车产品，所以我们只有一个抽象产品类

抽象工厂模式：其实相当于是把工厂方法模式又抽了一层出来，细分了一级，要生产一组东西的，那比如说市里面的中餐馆都在卖热菜类、凉菜类、主食类，但是每个餐馆对一个的类别的菜谱不同，这就相当于一个工厂可以产三个产品了，我们会有三个抽象产品类

假设我们现在有餐厅A，餐厅B，而它们有热菜、凉菜、主食，我们来练习一个抽象工厂：

abstract class HotMenu {
    abstract void method();
}
abstract class ColdMenu {
    abstract void method();
}
abstract class MainMenu {
    abstract void method();
}

class HotMenuA extends HotMenu {
    @Override
    void method() {}
}
class HotMenuB extends HotMenu {
    @Override
    void method() {}
}

class ColdMenuA extends ColdMenu {
    @Override
    void method() {}
}
class ColdMenuB extends ColdMenu {
    @Override
    void method() {}
}

class MainMenuA extends MainMenu {
    @Override
    void method() {}
}
class MainMenuB extends MainMenu {
    @Override
    void method() {}
}



abstract class Restaurant {
    abstract HotMenu createHotMenu();
    abstract ColdMenu createColdMenu();
    abstract MainMenu createMainMenu();
}

class RestaurantA extends Restaurant {
    @Override
    HotMenu createHotMenu() {
        return new HotMenuA();
    }
    @Override
    ColdMenu createColdMenu() {
        return new ColdMenuA();
    }
    @Override
    MainMenu createMainMenu() {
        return new MainMenuA();
    }
}

class RestaurantB extends Restaurant {
    @Override
    HotMenu createHotMenu() {
        return new HotMenuB();
    }
    @Override
    ColdMenu createColdMenu() {
        return new ColdMenuB();
    }
    @Override
    MainMenu createMainMenu() {
        return new MainMenuB();
    }
}


// 调用
Restaurant restaurantA = new RestaurantA();
restaurantA.createHotMenu().method();
restaurantA.createColdMenu().method();
restaurantA.createMainMenu().method();

Restaurant restaurantB = new RestaurantB();
restaurantB.createHotMenu().method();
restaurantB.createColdMenu().method();
restaurantB.createMainMenu().method();

想要理解抽象工厂模式，其实最关键的一点就是明确有多个抽象产品，一个工厂可以生产多个不同类型的产品

抽象工厂分离了接口和实现，但是抽象工厂需要管理更加多的类，一旦增加新的工厂，就需要新增若干个产品类；如果增加新的产品，必须修改抽象工厂，而且所有的具体工厂都要修改

总结

关于工厂模式，一开始其实挺不好理解的，也搞不懂到底会应用在什么地方。其实随着工作经验的增加，对于这些东西慢慢的也就理解了。

Android对于工厂方法的应用不是很多，抽象工厂基本就更少了，常见的就是说Activity的onCreate()方法中setContentView()返回一个View对象，Service中onBind返回一个Binder对象。先到这里，过段时间再回来。