工厂方法模式

定义

工厂方法模式的做用就是封装对象的建立，由子类决定要建立的对象是什么。

适用范围

工厂方法模式特别适合与须要建立复杂对象的场景

实现

首先能够看一下，工厂方法模式的UML类图

这样一个图看起来可能有点晕，下面就结合时下最流行的共享单车，写一个工厂方法模式的通用模式代码。

/** * 抽象单车产品 *简单起见，单车的制造方式（外观）和计费方式 做为单车类的两个方法 */

public interface Bicycle {
    /** * 单车生产方式 */
    String manufacture();

    /** * 单车计费方式 */
    String billing();
}

/** * Bicycle 抽象单车生产工厂 */

public interface BicycleFactory {

    Bicycle makeBicycle();
}


public class Mobike implements Bicycle {
    @Override
    public String manufacture() {
        System.out.print("摩拜单车---橙色---有定位功能");
        return "摩拜单车---橙色---有定位功能";
    }

    @Override
    public String billing() {
        System.out.print("Mobike每30分钟收费1元");
        return "Mobike每30分钟收费1元";
    }
}

public class MobikeFactory implements BicycleFactory {
    @Override
    public Bicycle makeBicycle() {
        return new Mobike();
    }
}

public class Ofo implements Bicycle {
    @Override
    public String manufacture() {
        System.out.print("ofo单车---黄色---密码不变");
        return "ofo单车---黄色---密码不变";
    }

    @Override
    public String billing() {
        System.out.print("ofo单车: 师生认证用户0.5元/小时，非师生用户1元/小时");
        return "ofo单车: 师生认证用户0.5元/小时，非师生用户1元/小时";
    }
}

public class OfoFactory implements BicycleFactory {
    @Override
    public Bicycle makeBicycle() {
        return new Ofo();
    }
}复制代码

在上面的代码中：

• Bicycle 抽象产品
• Mobike 和 Ofo 具体产品
• BicycleFactory 抽象工厂
• MobikeFactory 和 OfoFactory 具体的工厂

这就是工厂模式。全部的产品（Mobike和Ofo）有共同的父类 Bicycle，而每个产品又有各自的工厂（MobikeFactory和
OfoFactory）去负责建立本身；固然这里全部的产品能够有公共的工厂，在公共的工厂里经过参数负责生成不一样的产品。以下方式：

/** * 全部产品共用一个工厂 */
public class CommonFactory {
    public static Bicycle makeBicycle(String type) {
        switch (type) {
            case "mobike":
                return new Mobike();
            case "ofo":
                return new Ofo();
            default:
                return null;

        }

    }
}复制代码

我的感受，每一个产品使用各自的工厂是一种更有设计模式的作法，也就是更符合开闭原则；若是有了新产品，就没必要去修改原有的工厂，增长新的产品和工厂便可。

有个工厂，就很是方便咱们去建立不一样的对象了。

public class FactoryPatternActivity extends AppCompatActivity {
    private TextView bike_result;
    private BicycleFactory factory;
    private Bicycle mBicycle;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_factory_pattern);
        bike_result = V.f(this, R.id.bike_result);
    }


    public void MobikeClick(View view) {
        factory = new MobikeFactory();
        mBicycle = factory.makeBicycle();
        updateView(mBicycle);
    }

    public void OfoClick(View view) {
        factory = new OfoFactory();
        mBicycle = factory.makeBicycle();
        updateView(mBicycle);
    }
    private void updateView(Bicycle mBicycle) {
        bike_result.setText("");
        StringBuilder sb = new StringBuilder();
        sb.append(mBicycle.manufacture())
                .append("\n")
                .append(mBicycle.billing());
        bike_result.setText(sb.toString());
    }
}复制代码

在这里使用工厂模式，BicycleFactory 封装了Bicycle 对象具体生成的过程；当须要具体的对象时，调用每一个对象各自的工厂生成对象便可。试想，若是没有使用工厂模式，那么这里FactoryPatternActivity 将包含大量的代码去负责建立复杂的Bicycle对象，可是从MVP的角度来讲，这是彻底不属于Activity（View）的工做。

Android 中的Factory

BitmapFactory

在Android 系统中，说道Factory你们第一个想到的可能就是BitmapFactory了。研究过Bitmap的同窗应该清楚，BitmapFactory 为了方便开发者，提供了一系列的方法方便你们经过各类途径建立Bitmap。

这里能够看一下decodeStream(InputStream is) 方法：

public static Bitmap decodeStream(InputStream is) {
        return decodeStream(is, null, null);
    }复制代码

能够看到，这里又会去调用别的方法；最终上述的全部方法，异曲同工都会调用到一些native的方法去真正的完成Bitmap的建立。其实按照上面的UML图来讲，严格来讲BitmapFactory 的实现并非工厂方法模式；只能说是简单工厂。在BitmapFactory类中对于惟一的产品Bitmap只有惟一的工厂BitmapFactory，它全部的生产方法都是静态的；若是要新增一种生产Bitmap的方式，就得修改惟一的工厂（BitmapFactory）。所以，从设计模式的角度来讲，彻底不符合开闭原则。

这里并非说BitmapFactory这个类的写法很差，只是恰好从工厂方法模式的角度找了一个你们熟悉的类作了一个分析，Android系统的代码其实写的很好。BitmapFactory 这个类里包含的方法已经够你们使用，所以它设计成这个样子是彻底合理的。

onCreate 方法

《Android 源码设计模式解析于实战》这本书中提到 onCreate 方法是的实现能够说是工厂模式，的确从广义角度来讲，经过不一样的参数(R.layout.acitity) 建立出了不一样的View；的确是能够算是工厂模式。至于具体代码的实现逻辑，这里就不拾人牙慧了。

总结

总的来讲，工厂模式就是种瓜得瓜，种豆得豆；根据不一样的输入建立不一样类型的对象。经过上面的实例其实能够总结出规律，当咱们在代码中写了不少if-else或者是switch时，是否是能够考虑如下使用工厂模式，也许咱们就是在建立不经过的对象，也许只是本身没有发现。

---

工厂方法模式真的感受只能意会，不能言传。看别人写的东西老是忘掉，这样本身写一遍才算理解了。