设计模式之--------工厂方法和抽象工厂方法

工厂方法模式

工厂方法模式的定义

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

工厂方法模式的使用场景

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

工厂方法模式的 UML 图

根据上面的类图，我们可以得出一个工厂方法模式的通用模板代码

/*
*  抽象产品类
* */
public abstract class Product {
    /*
    * 产品类的抽象方法 由具体的产品类去实现
    * */
    public abstract void method();
}

/*
 * 具体的产品B
 * */

public class ComcreteProductA extends Product{

    @Override
    public void method() {
        System.out.println("我是具体的产品A");
    }
}

/*
* 具体的产品B
* */

public class ConcreteProductB extends Product{
    @Override
    public void method() {
        System.out.println("我是具体的产品B");
    }
}

/*
* 抽象工厂类
* */
public abstract class Factory {
    /*
    * 抽象工厂方法
    * 具体生产什么由子类去实现
    *
    * */

    public abstract Product createProduct();
}

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

/*
* 客户类
* */
public class Client {
    public static void main(String[] args) {
        ConcreteFactory concreteFactory = new ConcreteFactory();
        Product product = concreteFactory.createProduct();
        product.method();
    }
}

上面的几个角色都很简单，主要分为四大模块。

一是抽象工厂，其为工厂方法模式的核心；

二是具体工厂，其实现了具体的业务逻辑；

三是抽象产品，是工厂模式所创建的产品的父类；

四是具体产品，为实现抽象产品的某个具体产品的对象。

我们也可以通过反射的方式更简洁地来生产具体的对象，此时需要工程方法的参数列表中传入一个class类决定哪一个产品类。

/*
* 抽象工厂类
* */
public abstract class Factory {
    /*
    * 抽象工厂方法
    * 具体生产什么由子类去实现
    *
    * */

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

/*
* 具体工厂类
* */
public class ConcreteFactory 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;
    }
}

/*
* 客户类
* */
public class Client {

    public static void main(String[] args) {
        ConcreteFactory concreteFactory = new ConcreteFactory();
        Product product = concreteFactory.createProduct(ConcreteProductB.class);
        product.method();
    }
}

在 Client 中，需要哪一个类的对象就传入哪一个类的类型即可，这种方法比较简洁、动态。

如果不喜欢上面的这种方式。我们一个为没一个产品定义一个具体的工厂，各司其职。

public class ConcreteFactoryA extends Factory{

    @Override
    public Product createProduct() {
        return new ComcreteProductA();
    }
}

public class ConcreteFactoryB extends Factory{

    @Override
    public Product createProduct() {
        return new ComcreteProductB();
    }
}

/*
* 客户类
* */
public class Client {
    public static void main(String[] args) {
        ConcreteFactory concreteFactoryb = new ConcreteFactoryA();
        Product producta = concreteFactorya.createProduct();
        producta.method();
        
        ConcreteFactory concreteFactoryb = new ConcreteFactoryB();
        Product productb = concreteFactoryb.createProduct();
        productb.method();
    }
}

像上面这种拥有多个工厂的方式我们称之为多工厂方法模式。

当只有一个工厂类是，我们可以将工厂的抽象类简化掉，将对应的工厂方法改为静态方法即可：

/*
* 抽象工厂类
* */
public class Factory {
 
    public stacic Product createProduct(){
        return new ConcreteProductB();
        //return new ConcreteProductA();
    }

}

像上面这种方式又称为简单工程模式或者静态工厂模式，它是工厂方法模式的一个弱化版本。

工厂方法模式的简单实现

一家汽车工厂主要是组装某款 SUV 车型，这个有分为 Q3、Q5、Q7 他们的内部结构差异不是很大，可以在同一条生产线上进行生产。

public abstract class AudiCar {
    /*
    * 汽车的抽象产品类
    * 定义汽车的一个行为方法， 车可以启动开走
    * */
    public abstract void drive();

    /*
    * 汽车的抽象产品类
    * 定义汽车的一个行为方法，车可以自动巡航
    * */
    public abstract void selfNavigation();
}

public abstract class AudiFactory {
    /*
    *  某车型的工厂方法
    * clz  具体的suv 型号类型
    * return 具体型号的suv 车对象
    * */
    public abstract <T extends AudiCar> T createAudiCar(Class<T> clz);
}

public class AudiCarFactory extends AudiFactory{
    @Override
    public <T extends AudiCar> T createAudiCar(Class<T> clz) {
        AudiCar car = null;
        try{
            car = (AudiCar) Class.forName(clz.getName()).newInstance();
        }catch (Exception e){
            e.printStackTrace();
        }
        return (T) car;
    }
}

public class AudiQ3 extends AudiCar{

    @Override
    public void drive() {
        System.out.println("Q3 启动啦");
    }

    @Override
    public void selfNavigation() {
        System.out.println("Q3 开始巡航啦");
    }
}

public class AudiQ5 extends AudiCar{
    @Override
    public void drive() {
        System.out.println("Q5 启动啦");
    }

    @Override
    public void selfNavigation() {
        System.out.println("Q5 开始巡航啦");
    }
}

public class AudiQ7 extends AudiCar{
    @Override
    public void drive() {
        System.out.println("Q7 启动啦");
    }

    @Override
    public void selfNavigation() {
        System.out.println("Q7 开始巡航啦");
    }
}

public class Client {
    public static void main(String[] args) {
        // 构建一个制造汽车的工厂对象
        AudiCarFactory factory = new AudiCarFactory();

        // 生产 Q3 并启动
        AudiQ3 audiQ3 = factory.createAudiCar(AudiQ3.class);
        audiQ3.drive();
        audiQ3.selfNavigation();

        // 生产 Q5 并启动
        AudiQ5 audiQ5 = factory.createAudiCar(AudiQ5.class);
        audiQ5.drive();
        audiQ5.selfNavigation();

        // 生产 Q7 并启动
        AudiQ7 audiQ7 = factory.createAudiCar(AudiQ7.class);
        audiQ7.drive();
        audiQ7.selfNavigation();
    }
}

抽象工厂模式

抽象工厂模式的定义

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

抽象工厂模式的使用场景

一个对象族有相同的约束时可以使用抽象工厂模式。就像是Android、ios、window、phone 下都有短信软件和拨号软件，它们所在的操作系统平台不一样，即使是同一家公司出品的软件，其代码的实现逻辑也是不同的，这时就可以使用抽象工厂方法模式。

抽象工厂模式的UML类图

根据类图可以得到一个抽象工厂模式的通用模式代码。

/*
* 抽象产品类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.println("具体产品 A1 的方法");
    }
}

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

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

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

/*
* 抽象工厂类
* */
public abstract class AbstractFactory {
    /*
    * 创建产品A 的方法
    * return 产品A对象
    * */
    public abstract AbstractProductA createProductA();

    /*
    * 创建产品B 的方法
    * return 产品b 对象
    * */
    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();
    }
}

上面的抽象工厂方法模式的类繁多，但是主要分为四类：

• AbstractFactory: 抽象工厂角色，他声明了一组用于创建一种产品的方法，没一个方法对应一种产品，如上述类图中的AbstractFactory 中就定义了两个方法，分别创建产品A 和产品B
• ConcreteFactory: 具体工厂角色，他实现了在抽象工厂中定义的创建产品的方法，生成一组具体产品，这些产品构成了一个产品种类，每一个产品都位于某个产品等级结构中，如上类图中的 ConcreteFactory1 和 ConcreteFactory2.
• AbstractProduct: 抽象产品角色，它为每种产品申明接口，比如上述类图中的AbstractProductA 和AbstractProductB
• ConcreteProduct: 具体产品角色，他定义了具体工厂生产的具体产品对象，实现抽象产品接口中申明的业务方法。

抽象工厂方法模式的简单实现

我们还是以汽车那个作为案例的基础。在Q3、Q5、Q7这个车系中，这三个汽车的轮胎、发动机和制动系统都不近相同，所以可以将抽象工厂模式应用到其中。

public interface ITire {
    /*
    * 轮胎
    * */
    void tire();
}

public class NormalTire implements ITire{
    @Override
    public void tire() {
        System.out.println("普通轮胎");
    }
}

public class SUVTire implements ITire{
    @Override
    public void tire() {
        System.out.println("越野轮胎");
    }
}

public interface IEngine {
    /*
    * 发动机
    * */
    void engine();
}

public class DomesticEngine implements IEngine{
    @Override
    public void engine() {
        System.out.println("国产发动机");
    }
}

public class ImportEngine implements IEngine{
    @Override
    public void engine() {
        System.out.println("进口发动机");
    }
}

public interface IBrake {
    /**
     * 制造系统
     */
    void brake();
}

public class NormalBrake implements IBrake{
    @Override
    public void brake() {
        System.out.println("普通制动");
    }
}

public class SeniorBrake implements IBrake{
    @Override
    public void brake() {
        System.out.println("高级制动");
    }
}

public abstract class CarFactory {
    /**
     * 生产轮胎
     * @return 轮胎
     */
    public abstract ITire createTire();

    /**
     * 生产发动机
     * @return 发动机
     */
    public abstract IEngine createEngine();

    /**
     * 生产制造系统
     *
     * @return 制造系统
     */
    public abstract IBrake createBrake();
}

public class Q3Factory extends CarFactory{
    @Override
    public ITire createTire() {
        return new NormalTire();
    }

    @Override
    public IEngine createEngine() {
        return new DomesticEngine();
    }

    @Override
    public IBrake createBrake() {
        return new NormalBrake();
    }
}

public class Q7Factory extends CarFactory{
    @Override
    public ITire createTire() {
        return new SUVTire();
    }

    @Override
    public IEngine createEngine() {
        return new ImportEngine();
    }

    @Override
    public IBrake createBrake() {
        return new SeniorBrake();
    }
}

public class Client {
    public static void main(String[] args) {
        // 构造一个生产Q3 的工厂
        Q3Factory q3Factory = new Q3Factory();
        q3Factory.createTire().tire();
        q3Factory.createEngine().engine();
        q3Factory.createBrake().brake();

        System.out.println("---------------------------------------");

        // 构造一个生产 Q7 的工厂
        Q7Factory q7Factory = new Q7Factory();
        q7Factory.createTire().tire();
        q7Factory.createEngine().engine();
        q7Factory.createBrake().brake();
    }
}

运行结果如下：

上面的代码中可以发现，如果我们还要增加一个Q5的工厂，就需要增加对应的轮胎、制动系统和发动机类，这就是抽象工厂的一个弊端，就是类的徒增，如果工厂类过多，势必导致类文件非常多。在实际开发中需要权衡慎用。

总结

优点：

一个显著的优点是分离接口与实现，客户端使用抽象工厂来创建需要的对象，而客户端根本就不知道具体的实现是谁，客户端只是面向产品的接口编程而已，使其从具体的产品实现中解偶，同时基于接口与实现的分离，使抽象该工厂方法模式在切换产品类时更加灵活、容易

缺点：

一是类文件的爆炸式增加二是不太容易扩展新的产品类，因为每当我们增加一个产品类时，就需要修改抽象工厂，那么所有的具体工厂类均会被修改。