抽象工厂方法模式

定义

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

使用场景

一个对象族有相同的约束时可以使用抽象工厂模式。例如生产一部车需要很多部件：轮胎、发动机、制动系统等，不同的型号会有不同的部件，而这些部件之间又是相互依赖的。这时候就可以考虑使用抽象工厂模式。

关键点

抽象工厂—声明一组用于创建一个产品的方法，每个方法对应生产一种产品或者称之为组件

具体工厂—抽象工厂的实现类，实现了在 抽象工厂中定义的创建产品的方法，生产一组具体产品，这些产品又可以组装成一个产品种类。

抽象产品—为每种产品声明接口

具体产品—定义具体工厂需要生产的具体产品对象

实现(以生产一辆车为例)

声明三个组件接口-即抽象产品的角色

/**
 * 抽象产品组件—制动系统
 */
public interface IBrake {

    void brake();

}

/**
 * 抽象产品组件—发动机
 */
public interface IEngine {

    void engine();

}

/**
 * 抽象产品组件—轮胎
 */
public interface ITire {

    void tire();

}

组件的具体实现类—具体产品的角色

/**
 * 具体产品组件—1号制动系统
 */
public class Brake1 implements IBrake {
    @Override
    public void brake() {

    }
}

/**
 * 具体产品组件—2号制动系统
 */
public class Brake2 implements IBrake {
    @Override
    public void brake() {

    }
}


/**
 * 具体产品角色—1号发动机
 */
public class Engine1 implements IEngine {

    @Override
    public void engine() {

    }

}

/**
 * 具体产品角色—2号发动机
 */
public class Engine2 implements IEngine {

    @Override
    public void engine() {

    }

}

/**
 * 具体的产品组件—1号轮胎
 */
public class Tire1 implements ITire {

    @Override
    public void tire() {

    }
}


/**
 * 具体的产品组件—2号轮胎
 */
public class Tire2 implements ITire {

    @Override
    public void tire() {

    }
}

抽象工厂和具体工厂

/**
 * 抽象工厂—声明一组用于创建一个产品的方法
 */
public abstract class AbstractFactory {

    /**
     * 生产轮胎
     */
    public abstract ITire createTire();

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

    /**
     * 生产制动系统
     */
    public abstract IBrake createBrake();

}

/**
 * 具体工厂—专门生产1号车相关组件
 */
public class Car1Factory extends AbstractFactory {

    @Override
    public ITire createTire() {
        return new Tire1();
    }

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

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


/**
 * 具体工厂—专门生产2号车相关组件
 */
public class Car2Factory extends AbstractFactory {

    @Override
    public ITire createTire() {
        return new Tire2();
    }

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

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

使用

AbstractFactory factory = new Car1Factory();   
factory.createTire().tire();
factory.createEngine().engine();
factory.createBrake().brake();

小结

抽象工厂是一种用户不需要关心内部实现，只需要使用一种工厂就可以生产一组相关性很高的对象的创建型模式，类与类之间通过抽象产生依赖，每一个类又负责具体的单一角色，完全符合软件设计原则。

优点:

1.分离接口的实现，客户端使用抽象工厂来创建需要的对象，而不需要关心具体的内部实现，耦合度较低，同时基于接口的实现和隔离，使得软件设计更加灵活、容易

缺点:

1.类文件太多

2.不太容易扩展新的产品类，因为每当增加一个新的产品类时，每一个抽象产品组件都需要增加实现，同时添加新的工厂类。