三 ，设计模式-工厂模式-抽象工厂模式

简介

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。根据里氏替换原则，任何接受父类型的地方，都应当能够接受子类型。因此，实际上系统所需要的，仅仅是类型与这些抽象产品角色相同的一些实例，而不是这些抽象产品的实例。换言之，也就是这些抽象产品的具体子类的实例。工厂类负责创建抽象产品的具体子类的实例。


当每个抽象产品都有多于一个的具体子类的时候，工厂角色怎么知道实例化哪一个子类呢？比如每个抽象产品 [1] 角色都有两个具体产品。抽象工厂模式提供两个具体工厂角色，分别对应于这两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。
每一个模式都是针对一定问题的解决方案，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式针对的是多个产品等级结构。

系统组成

1. 抽象工厂角色：这是工厂方法模式的核心，是具体工厂角色必须实现的接口。
2. 具体工厂角色： 实现了抽象工厂角色的实现类，它含有具体的业务逻辑代码。
3. 抽象产品角色：他是具体产品继承的父类或者是实现的接口。
4. 具体产品角色： 他是实现了抽象产品角色的子类或实现类，具体工厂所创建的对象就是它的实例。

成员关系

代码示例

/**
 * 抽象汽车工厂
 */
public interface CarFactory {

    /**
     * 生产轮胎
     * return 生产轮胎
     */
    public abstract ITire createTire();
    /**
     * 生产发动机
     * return 发动机
     */
    public abstract IEngine createEngine();
    /**
     * 生产制动系统
     * return 制动系统
     */
    public abstract IBrake createBrake();
}

/**
 * 具体的汽车工厂类(国产汽车)
 */
public class NormalCar implements CarFactory {
    @Override
    public ITire createTire() {
        return new NormalTire();
    }

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

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

/**
 * 具体的汽车工厂类(进口汽车)
 */
public class ImportCar implements CarFactory {
    @Override
    public ITire createTire() {
        return new SUVTire();
    }

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

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

/**
 * 生产轮胎接口
 */
public interface ITire {
    void tire();
}

/**
 * 生产动力系统接口
 */
public interface IBrake {
    void iBrake();
}

/**
 * 生产发动机接口
 */
public interface IEngine {
    void iEngine();
}

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

/**
 * SUV轮胎类
 */
public class SUVTire implements ITire {
    @Override
    public void tire() {
        System.out.println("SUV轮胎类");
    }
}

/**
 * 普通动力系统
 */
public class NormalBrake implements IBrake {
    @Override
    public void iBrake() {
        System.out.println("普通动力系统");
    }
}

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

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

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

  /**
 * 抽象方法工厂(测试)
 */
public class MainClass {

    public static void main(String[] args) {
        CarFactory carFactory = new NormalCar();
        carFactory.createTire().tire();
        carFactory.createEngine().iEngine();
        carFactory.createBrake().iBrake();


        CarFactory carFactory1=new ImportCar();
        carFactory1.createTire().tire();
        carFactory1.createEngine().iEngine();
        carFactory1.createBrake().iBrake();
    }
}

运行结果：

总结

1.系统不依赖于产品类实例如何被创建，组合和表达的细节。
2.系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。
3.同属于同一个产品族是在一起使用的。这一约束必须在系统的设计中体现出来。
4.系统提供一个产品类的库，所有产品以同样的接口出现，从而使客户端不依赖于实现。

在我们的实际开发中，经常存在多数据源之间的切换，我们就可以使用抽象工厂的方法定义多个数据源工厂具体实现类。