设计模式-抽象工厂模式

• Provide an interface for creating families of related or dependent objects without specifying their concrete classes.（为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。）

• 通用类图

​

先举一个抽象工厂的小例子，具体怎么用了解下

接口

//创建接口
public interface Car {
    //每个车都有颜色
    public void getColor();

    //每个车都有轮胎颜色
    public void getTire();

        //发动机
    public void engine();
}

接口抽象类

//接口抽象类
public abstract class AbstractAudiWhiteCar implements Car {
    //黑色奥迪车
    public void getColor(){
        System.out.println("白色奥迪车");
    }

    //黑色轮胎
    public void getTire(){
        System.out.println("白色轮胎");
    }

}

//接口抽象类
public abstract class AbstractAudiRedCar implements Car {
    //黑色奥迪车
    public void getColor(){
        System.out.println("红色奥迪车");
    }

    //黑色轮胎
    public void getTire(){
        System.out.println("红色轮胎");
    }

}

//接口抽象类
public abstract class AbstractAudiBlackCar implements Car {
    //黑色奥迪车
    public void getColor(){
        System.out.println("黑色奥迪车");
    }

    //黑色轮胎
    public void getTire(){
        System.out.println("黑色轮胎");
    }

}

接口实现类

//接口实现类
public class V6AudiBlackCar extends AbstractAudiBlackCar {
    @Override
    public void engine() {
        System.out.println("发动机是v6");
    }
}

//接口实现类
public class V6AudiRedCar extends AbstractAudiRedCar {
    @Override
    public void engine() {
        System.out.println("发动机是v6");
    }
}

//接口实现类
public class V6AudiWhiteCar extends AbstractAudiWhiteCar {
    @Override
    public void engine() {
        System.out.println("发动机是v6");
    }
}

//接口实现类
public class V12AudiBlackCar extends AbstractAudiBlackCar {
    @Override
    public void engine() {
        System.out.println("发动机是v12");
    }
}

//接口实现类
public class V12AudiRedCar extends AbstractAudiRedCar {
    @Override
    public void engine() {
        System.out.println("发动机是v12");
    }
}

//接口实现类
public class V12AudiWhiteCar extends AbstractAudiWhiteCar {
    @Override
    public void engine() {
        System.out.println("发动机是v12");
    }
}

//接口实现类
public class V6AudiBlackCar extends AbstractAudiBlackCar {
    @Override
    public void engine() {
        System.out.println("发动机是v6");
    }
}

生产车的工厂

public interface CarFactory {
    //黑色车
    public Car createAudiBlackCar();
    //红色车
    public Car createAudiRedCar();
    //白色车
    public Car createAudiWhiteCar();
}

生产v6车的工厂

public class V6Factory implements CarFactory {
    @Override
    public Car createAudiBlackCar() {
        return new V6AudiBlackCar();
    }

    @Override
    public Car createAudiRedCar() {
        return new V6AudiRedCar();
    }

    @Override
    public Car createAudiWhiteCar() {
        return new V6AudiWhiteCar();
    }
}

生产v12车工厂

public class V12Factory implements CarFactory {
    @Override
    public Car createAudiBlackCar() {
        return new V12AudiBlackCar();
    }

    @Override
    public Car createAudiRedCar() {
        return new V12AudiRedCar();
    }

    @Override
    public Car createAudiWhiteCar() {
        return new V12AudiWhiteCar();
    }
}

客户端调用

public class Client {
    public static void main(String[] args) {
        //生产v6发动机 黑色车
        CarFactory carFactory = new V6Factory();
        Car audiBlackCar = carFactory.createAudiBlackCar();
        audiBlackCar.engine();
        audiBlackCar.getColor();
        audiBlackCar.getTire();
        //生产v12发动机 红色车
        CarFactory carFactory1 = new V12Factory();
        Car audiRedCar = carFactory1.createAudiRedCar();
        audiRedCar.getTire();
        audiRedCar.getColor();
        audiRedCar.engine();
    }
}

下面是运行结果

​

image.png

• 注意：抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式

• 抽象工厂的优点

1.具有一定的封装性，每个产品实现类不是高层模块要关心的。
2.产品族里面为非公开状态。具体意思就是，我生产一个红颜色的车，可以生产两个黑颜色的车，这样的生产过程对调用工厂类高层模块是透明的。

• 抽象工厂的缺点

最大的缺点就是产品族扩展困难，比如我要在新增一个绿颜色的车。抽象类AbstractCreator要增加一个方法createProductC()，然后两个实现类都要修改。

以上就是抽象工厂模式的基本简单用法，欢迎大家查看并指出不足的地方，万分感谢