设计模式之抽象工厂模式

抽象工厂模式：

       需要的类：抽象工厂，具体工厂，抽象产品，具体产品

   此模式符合开闭原则，能处理产品族业务。

 

抽象工厂：AbstractCarFactory

/**
 * 抽象工厂
 */
public interface AbstractCarFactory {
    //生产卡车的方法
    Trunk produceTrunk();
    //生产轿车的方法
    Sedan produceSedan();
}

具体工厂：BmwFactory

/**
 * 具体工厂：生产宝马的工厂
 */
public class BmwFactory implements AbstractCarFactory{

    @Override
    public Trunk produceTrunk() {
        return new BmwTrunk();
    }

    @Override
    public Sedan produceSedan() {
        return new BmwSedan();
    }
}

具体工厂：AudiFactory

/**
 * 具体工厂：生产奥迪的工厂
 */
public class AudiFactory implements AbstractCarFactory{
    @Override
    public Trunk produceTrunk() {
        return new AudiTrunk();
    }

    @Override
    public Sedan produceSedan() {
        return new AudiSedan();
    }
}

抽象产品：Trunk

/**
 * 抽象产品：卡车
 */
public interface Trunk {
    void buildTrunk();
}

抽象产品：Sedan

/**
 * 抽象产品：轿车
 */
public interface Sedan {
    void buildSedan();
}

具体产品：BmwTrunk

/**
 * 具体产品：宝马卡车
 */
public class BmwTrunk implements Trunk{
    @Override
    public void buildTrunk() {
        System.out.println("制造了一辆宝马卡车");
    }
}

具体产品：BmwSedan

/**
 * 制造宝马轿车
 */
public class BmwSedan implements Sedan{
    @Override
    public void buildSedan() {
        System.out.println("制造了一辆宝马轿车");
    }
}

具体产品：AudiTrunk

/**
 * 具体产品：奥迪卡车
 */
public class AudiTrunk implements Trunk{
    @Override
    public void buildTrunk() {
        System.out.println("制造了一辆奥迪卡车");
    }
}

具体产品：AudiSedan

/**
 * 具体产品：奥迪轿车
 */
public class AudiSedan implements Sedan{

    @Override
    public void buildSedan() {
        System.out.println("制造了一辆奥迪轿车");
    }
}

测试类：

public class Test {
    public static void main(String[] args){
        AbstractCarFactory bmwfactory = new BmwFactory();
        bmwfactory.produceTrunk().buildTrunk();
        bmwfactory.produceSedan().buildSedan();

        AbstractCarFactory audifactory = new AudiFactory();
        audifactory.produceSedan().buildSedan();
        audifactory.produceTrunk().buildTrunk();
    }
}

运行结果：