Android设计模式--工厂模式

一，定义

工厂模式与Android 设计模式--单例模式-CSDN博客，Android设计模式--Builder建造者模式-CSDN博客，Android设计模式--原型模式-CSDN博客一样，都是创建型设计模式。

工厂模式就是定义一个用于创建对象的接口，让子类决定实例化哪个类

二，使用场景

在任何需要生成复杂对象的地方，都可以使用工厂方法模式。复杂对象适合使用工厂模式，用new就可以完成创建的对象无需使用工厂模式。

三，工厂模式简单使用

工厂模式主要分为四个模块：

1，抽象工厂，其为工厂模式的核心

2，具体工厂，其实现了具体的业务逻辑

3，抽象产品，是工厂方法模式所创建的产品的父类

4，具体产品，为实现抽象产品的某个具体产品的对象

下面来看一个简单的案例

某手机工厂可以生产三种手机，分别是手机A，手机B，手机C。

创建一个抽象的产品接口：

public interface Phone {
    void call();
}

创建具体的产品类：

public class PhoneA implements Phone{
    private static final String TAG = "phoneA";

    @Override
    public void call() {
        Log.d(TAG,"我是手机A");
    }
}

public class PhoneB implements Phone{
    private static final String TAG = "PhoneB";
    @Override
    public void call() {
        Log.d(TAG,"我是手机B");
    }
}

创建一个抽象的工厂接口：

public interface Factory {

    Phone createPhone();
}

创建具体的工厂类：

public class FactoryPhoneA implements Factory{
    @Override
    public PhoneA createPhone() {
        return new PhoneA();
    }
}

public class FactoryPhoneB implements Factory{
    @Override
    public PhoneB createPhone() {
        return new PhoneB();
    }
}

使用：

FactoryPhoneA factoryA =new FactoryPhoneA();
PhoneA phone =factoryA.createPhone();
phone.call();
FactoryPhoneB factoryB=new FactoryPhoneB();
PhoneB phoneB =factoryB.createPhone();
phoneB.call();

输出：

四，使用反射的工厂模式

还是上面的例子

抽象工厂接口可以改造为：

public interface Factory<T extends Phone> {

    T createPhone(Class<T> tClass);
}

具体的工厂类改造为：

public class PhoneFactory<T extends Phone> implements Factory<T>{
    @Override
    public T createPhone(Class<T> tClass) {
        Phone phone =null;
        try {
            phone = (Phone) Class.forName(tClass.getName()).newInstance();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return (T) phone;
    }
}

这样在使用的时候，就class来动态的加载对象：

PhoneFactory phoneFactory =new PhoneFactory();
Phone phone1 = phoneFactory.createPhone(PhoneA.class);
phone1.call();
Phone phone2 = phoneFactory.createPhone(PhoneB.class);
phone2.call();

输出：