设计模式之抽象工厂模式

刚看到抽象工厂模式，发现抽象工厂模式是很想的，抽象工厂模式定义如下：为创建一组相关或相互依赖的对象提供一个接口，而且不需要指定它们的具体类

抽象工厂模式的通用类图如下：

每一个模式都是针对一定问题的解决方案。抽象工厂模式与工厂方法模式的最大区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则需要面对多个产品等级结构

下面用一个汽车制造的例子来说一下抽象工厂模式

汽车制造类图如下：

汽车的制造主要有：发动机、轮胎、车门、座椅等等，本例之介绍发动机和轮胎的制造

现在要生产两种车辆：宝马和奔驰，宝马和奔驰的发动机和轮胎都有各自的要求，所以提取抽象，即发动机Engine和轮胎抽象类Tire，具体的区别交由各自的实现类，根据抽象工厂模式的定义，既然存在不同的产品,那么就需要不同的工厂负责生产。

具体代码如下：

/**
 * 发动机抽象类
 *
 */
public abstract class Engine {

    //抽象逻辑定义
}

/**
 *宝马汽车的发动机 
 *
 */
public class BMWEngine extends Engine {

}

/**
 * 奔驰汽车的发动机
 *
 */
public class BenzEngine extends Engine {

}

/**
 * 发动机工厂的抽象类
 *
 */
public abstract class EngineFactory {

    public abstract Engine createEngine();
}

/**
 * 宝马发动机工厂类
 *
 */
public class BMWEngineFactory extends EngineFactory {

    /**
     * @return
     * @see com.huashao.chapter.car.EngineFactory#createEngine()
     */
    @Override
    public Engine createEngine() {
        // TODO Auto-generated method stub
        return new BMWEngine();
    }

}

/**
 * 奔驰发动机的工厂类
 *
 */
public class BenzEngineFactory extends EngineFactory {

    /**
     * @return
     * @see com.huashao.chapter.car.EngineFactory#createEngine()
     */
    @Override
    public Engine createEngine() {
        // TODO Auto-generated method stub
        return new BenzEngine();
    }

}

/**
 *汽车轮胎的抽象类 
 *
 */
public abstract class Tire {

    //抽象逻辑定义，例如生产轮胎的尺寸，材质等等
}

/**
 * 宝马轮胎
 *
 */
public class BMWTire extends Tire {

}

/**
 * 
 *奔驰轮胎
 */
public class BenzTire extends Tire {

}

/**
 * 轮胎的抽象工厂类
 *
 */
public abstract class TireFactory {

    public abstract Tire createTire();
}

/**
 * 宝马轮胎工厂类
 *
 */
public class BMWTireFactory extends TireFactory {

    /**
     * @return
     * @see com.huashao.chapter.car.TireFactory#createTire()
     */
    @Override
    public Tire createTire() {
        // TODO Auto-generated method stub
        return new BMWTire();
    }

}

/**
 * 奔驰轮胎工厂类
 *
 */
public class BenzTireFactory extends TireFactory {

    /**
     * @return
     * @see com.huashao.chapter.car.TireFactory#createTire()
     */
    @Override
    public Tire createTire() {
        // TODO Auto-generated method stub
        return new BenzTire();
    }

}

public class CarEngineer {
    
    private String carType;

    private Engine engine;

    private Tire tire;

    private EngineFactory engineFactory;

    private TireFactory tireFactory;
    
    public void createCar(){
        
        if("BMW".equalsIgnoreCase(carType)){
            engineFactory=new BMWEngineFactory();
            
            engine=engineFactory.createEngine();
            
            tireFactory=new BMWTireFactory();
            
            tire=tireFactory.createTire();
        }
        
        if("Benz".equalsIgnoreCase(carType)){
            engineFactory=new BenzEngineFactory();
            
            engine=engineFactory.createEngine();
            
            tireFactory=new BenzTireFactory();
            
            tire=tireFactory.createTire();
        }
    }
}

抽象工厂模式的优点：

良好的封装，客户端不需要关心具体的实现类，客户端只需要关注接口即可

抽象工厂模式的缺点：

不易扩展新产品，例如上面汽车制造的例子，如果现在增加一个车门的制造，那么我们需要定义一个车门的抽象类，定义宝马和奔驰的车门实现类，增加车门的抽象工厂类，定义宝马和奔驰车门生产的工厂类，如果不止这两种车呢？想想吧，我们需要写多少类