Android 工厂模式

Android 23种设计模式

前言

工厂模式是创建型模式，使我们常用/常见的模式之一。多用于需要生成复杂对象的地方。用new就可以完成创建的对象就无需使用。工厂模式降低了对象之间的耦合度，由于工厂模式依赖抽象的架构，实例化的任务交由子类去完成，所以有很好的扩展性。

工厂模式

定义：一个用于创建对象的接口，让子类决定实例化哪个类
工厂模式一般也就两大类：
普通工厂模式：生产具体的产品，创建的产品是类(Class)。
抽象工厂模式：生产抽象的产品，创建的产品是接口(Interface)。
一开始你可能理解不上来，当你看完这篇文章，你理解了，其实他们并不复杂，我们先来看一个普通工厂的例子
（这里扩展一点，虽然普通工厂表面上创建的是抽象类，但java特性里抽象类是不能被实例化的。我没每次创建的时候，实际上是以匿名内部类的方式创建。实际是它继承并创建的一个新的类。所以它仅仅是一个普通工厂）

普通工厂模式举例

我们举一个生产Nokia手机的例子。

public abstract class NokiaPhone {
    public abstract void powerOnPhone();
}

先试定义了一个抽象类，抽象出方法powerOnPhone()，模拟手机开机的动作。(ps:抽象类作用简单点说就是抽象出一些方法，需要子类去实现，自己不能实现。起到一个抽象的作用)
然后我们定义具体的手机

public class Nokia5200 extends NokiaPhone {
    @Override
    public void powerOnPhone() {
        Log.d("Factory","Nokia5200 power on");
    }
}

public class NokiaN97 extends NokiaPhone{
    @Override
    public void powerOnPhone() {
        Log.d("Factory","NokiaN97 power on");
    }
}

然后我们定义了具体的手机Nokia5200和NokiaN97两款手机。并实现了抽象方法powerOnPhone
现在产品定义好了，我们就要定义工厂了，首先我们也抽象出工厂的方法

public abstract class Factory {
    public abstract <T extends NokiaPhone> T createNokia(Class<T> clz);
}

工厂的方法无非就是生产手机，所以我们抽象出来了createNokia方法，现在我们来定义工厂

public class NokiaFactory extends Factory {
    @Override
    public <T extends NokiaPhone> T createNokia(Class<T> clz) {
        NokiaPhone nokiaPhone = null;
        try {
            nokiaPhone = (NokiaPhone) Class.forName(clz.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        } 
        return (T) nokiaPhone;
    }
}

NokiaFactory工厂也很简单就实现了抽象方法createNokia，来生产不同的手机。这里我们使用了反射方法

nokiaPhone = (NokiaPhone) Class.forName(clz.getName()).newInstance();

这句话的意思是通过类名(ClassName)来实例化具体的类，用的是反射机制来实现。
然后我们来看看我们怎么用工厂生产手机。

NokiaFactory nokiaFactory = new NokiaFactory();
Nokia5200 nokia5200 = nokiaFactory.createNokia(Nokia5200.class);
NokiaN97 nokiaN97 = nokiaFactory.createNokia(NokiaN97.class);

我们用工厂创建了两个手机，一个nokia5200，一个nokiaN97。然后我们开机试试

nokia5200.powerOnPhone();
nokiaN97.powerOnPhone();

看log

D/Factory: Nokia5200 power on
D/Factory: NokiaN97 power on

至此，一个工厂模式就写完了，可以看到工厂模式的代码结构其实很简单。有的读者可能会想为啥NokiaFactory为啥要用反射呢，其实用反射主要是为了代码简洁，如果不这么写，你可能像下面的代码这样写

// 方案一
public class NokiaFactoryNokia5200 extends Factory {

    @Override
    public <T extends NokiaPhone> T createNokia() {
        Nokia5200 nokia5200 = new Nokia5200();
        return (T) nokia5200;
    }
}

public class NokiaFactoryNokiaN97 extends Factory {

    @Override
    public <T extends NokiaPhone> T createNokia() {
        NokiaN97 nokiaN97 = new NokiaN97();
        return (T) nokiaN97;
    }
}
// 方案二
public class NokiaFactory extends Factory {
    @Override
    public <T extends NokiaPhone> T createNokia(Class<T> clz) {
        Log.d("Factory",clz.getSimpleName());
        if (clz.getSimpleName().equals("Nokia5200")) {
            Nokia5200 nokia5200 = new Nokia5200();
            return (T) nokia5200;
        } else if (clz.getSimpleName().equals("NokiaN97")) {
            NokiaN97 nokiaN97 = new NokiaN97();
            return (T) nokiaN97;
        }
        return null;
    }
}

普通工厂模式小结

1、上面两种方案，一是为每个手机单独创建一个工厂，或者通过带入的class来选择创建都能实现，但是如果手机型号过多，代码就显得很长，当然最好还是用反射的方法，这里只是为了进行一个说明。
2、上面NokiaFactoryNokia5200、NokiaFactoryNokiaN97这种情况也有适合用这种方式的地方。我们下面讲解抽象工厂的时候就会用不同工厂对应不同产品的方式来创建。并非一定是反射的方法。
3、最开始的例子还可以省略抽象方法，抽象方法只是为了更具体化，不过不建议这么做，抽象方法使我们的NokiaPhone更规范。代码可读性也更好。
4、普通工厂模的创建的产品是具体的类，这个例子的产品是NokiaPhone.class,虽然它是一个抽象类，但使用时已经创建的匿名内部类是一个具体的类。

抽象工厂模式例子

抽象工厂我们举例一个生产Iphone零件的例子。
我们先定义产品，这里是生产零件，我们定义两个抽象产品，一个CPU，一个电池。这里我把两个接口写在了一起，当然你也可以分开写成两个。

public interface component {
    public interface CPU {
        void showCpuName();
    }

    public interface Battery {
        void showBatteryCapacity();
    }
}

然后我们定义CPU的具体产品，一个A9，一个A10

public class A9 implements component.CPU {
    @Override
    public void showCpuName() {
        Log.d("AbstractFactory","A9");
    }
}

public class A10 implements component.CPU {
    @Override
    public void showCpuName() {
        Log.d("AbstractFactory","A10");
    }
}

然后是两种电池产品，一个1000ma，一个1200ma

public class Battery1000ma implements component.Battery {
    @Override
    public void showBatteryCapacity() {
        Log.d("AbstractFactory","battery is 1000ma");
    }
}
public class Battery1200ma implements component.Battery {
    @Override
    public void showBatteryCapacity() {
        Log.d("AbstractFactory","battery is 1200ma");
    }
}

产品定义好了，我们来定义工厂了,依旧先用抽象类，抽象出工厂类的方法

public abstract class Factory {
    public abstract component.CPU createCPU();
    public abstract component.Battery createBattery();
}

注意一点这里的抽象方法跟抽象工厂模式并无实际关系，不是因为这里使用抽象类而因此叫抽象工厂模式，而是因为工厂模式生产的产品。一个是component.CPU，一个是component.Battery。他们两个都是接口，都是抽象出来的，抽象工厂模式因此而来。
虽然java特性里，抽象类和接口不都能实例化。都是创建匿名内部类方式来创建对象，但普通工厂创建的是抽象类，还是对象的一种描述，而抽象工厂思想上还是创建的接口。接口编程，由此特性所以它叫抽象工厂。
接着我们看具体工厂的实现，这里我们将用不同的工厂对应不同的产品来举例

public class IPhone6Factory extends Factory {
    @Override
    public component.CPU createCPU() {
        return new A9();
    }

    @Override
    public component.Battery createBattery() {
        return new Battery1000ma();
    }
}

public class Iphone7Factory extends Factory {
    @Override
    public component.CPU createCPU() {
        return new A10();
    }

    @Override
    public component.Battery createBattery() {
        return new Battery1200ma();
    }
}

1、可以看到IPhone6Factory和Iphone7Factory两个工厂模式他们创建的产品相同，都是创建CPU和Battery这两个抽象产品。而这两个抽象产品又可以是同接口不同子类实例。

抽象工厂模式小结

1、抽象工厂模式创建的产品是接口，抽象出来的。
2、上面的例子其实跟普通工厂模式例子没太大的差别，除了产品不同，实现的思想都是一样的，只是这里用了不同的工厂对应不同的产品。普通工厂模式也可以这样用。
3、抽象工厂有一个显著的优点是分离接口与实现，用户根本不知道具体的实现是谁，客户仅仅是面向接口编程，使其从产品实现解耦，抽象工厂模式在切换产品类的时候更加灵活容易。

结束语

1、现在理解文章最开始的那句话是不是很好理解了
普通工厂模式：生产具体的产品，创建的产品是类(Class)
抽象工厂模式：生产抽象的产品，创建的产品是接口(Interface)
2、工厂模式的优点在上述两个例子的小结中已经阐述，工厂模式的缺点也比较明显，就是不太容易扩展新的产品类，需要去改具体的产品类和工厂类。
3、虽然美中不足，但工厂模式是运用非常广泛的一种模式。值得大家学习使用。