工厂设计模式

         在我们的开发过程中，工厂模式是应用最广泛的设计模式之一，当然也是最容易理解的设计模式之一；而对于工厂设计模式而言，它有以下的几个表现形式

 

工厂方法模式

 

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

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

简单事例：

/**
 * 抽象产品类
 */
public abstract class Product {

    // 产品类的抽象方法，由具体的产品类去实现
    public abstract void method();

}

/**
 * 具体的产品类A
 */
public class ConcreteProductA extends Product {
    @Override
    public void method() {
        Log.e("aaaa","这是具体的产品A");
    }
}

/**
 * 具体的产品类B
 */
public class ConcreteProductB extends Product {
    @Override
    public void method() {
        Log.e("aaaa","这是具体的产品B");
    }
}

/**
 * 抽象的工厂类
 */
public abstract class Factory {
    
    // 具体的产品对象
    public abstract Product createProduct();

}

/**
 * 具体的工厂类
 */
public class ConcreteFactory extends Factory {
    
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

总结一下：

工厂方法模式很简单，就是在具体的工厂里面去实例化自己需要的那个实例。

当然，在实际的开发过程中，我们可以通过反射去获取自己想要的那个实例，我们只需要稍微修改一下抽象工厂即可

/**
 * 抽象的工厂类
 */
public abstract class Factory {

    // 具体的产品对象
    public abstract <T extends Product> T createProduct(Class<T> clazz);

}

/**
 * 具体的工厂类
 */
public class ConcreteFactory extends Factory {

    @Override
    public <T extends Product> T createProduct(Class<T> clazz) {
        Product p = null;
        try {
            p = (Product) Class.forName(clazz.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) p;
    }
}

那么我们在这里考虑一个问题，如果我们的工厂只有一个的时候，我们可不可以去掉抽象工厂，答案肯定是可以的，这个时候我们可以这么写：

public class ConcreteFactory {

    public static Product createProduct() {
        return new ConcreteProductA();
    }
}

这种方式我们称之为简单工厂模式，它是工厂方法的一个弱化版本。

 

抽象工厂模式

 

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

标准例子如下：

/**
 * 抽象产品类A
 */

public abstract class AbstractProductA {

    public abstract void method();

}

/**
 * 抽象产品类B
 */

public abstract class AbstractProductB {

    public abstract void method();

}

/**
 * 具体产品类A1
 */

public class ConcreteProductA1 extends AbstractProductA {
    @Override
    public void method() {
         System.out.print(" 具体产品 A1 的方法");
    }
}

/**
 * 具体产品类A2
 */

public class ConcreteProductA2 extends AbstractProductA {
    @Override
    public void method() {
        System.out.print(" 具体产品 A2 的方法");
    }
}

/**
 * 具体产品类B1
 */

public class ConcreteProductB1 extends AbstractProductB {
    @Override
    public void method() {
        System.out.print(" 具体产品 B1 的方法");
    }
}

/**
 * 具体产品类B2
 */

public class ConcreteProductB2 extends AbstractProductB {
    @Override
    public void method() {
        System.out.print(" 具体产品 B2 的方法");
    }
}

/**
 * 抽象工厂类
 */

public abstract class AbstractFactory {

    public abstract AbstractProductA createProductA();

    public abstract AbstractProductB createProductB();

}

/**
 * 具体工厂类1
 */

public class ConcreteFactory1 extends AbstractFactory{

    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }

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

/**
 * 具体工厂类2
 */

public class ConcreteFactory2 extends AbstractFactory {

    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA2();
    }

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

虽然抽象工厂方法模式的类繁多，但是，主要还是4类：

AbstractFactory:抽象工厂角色，它声明了一组用于创建一种产品的方法，每一种方法对应一种产品

ConcreteFactory:具体工厂角色，它实现了在抽象工厂中定义的创建产品的方法，生成一种具体的产品

AbstractProduct:抽象产品角色，它为每种产品声明接口

ConcreteProduct:具体产品角色，它定义具体工厂生产的具体产品对象

 

抽象工厂方法模式在Android开发中使用的并不多，在源码当中看到的也比较少，主要是在开发过程中很少会出现多个产品种类的情况，大部分情况我们使用工厂模式即可解决