【创建型模式 】抽象工厂模式-java23种设计模式

介绍

抽象工厂方法模式由抽象工厂、具体工厂、抽象产品和具体产品等4个要素构成。

1. 抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
2. 具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
3. 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
4. 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

主要解决：主要解决接口选择的问题。

何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

简单工厂：当需要生成的产品不多且不会增加，一个具体工厂类就可以完成任务时，可删除抽象工厂类。这时工厂方法模式将退化到简单工厂模式。

实现 

定义抽象工厂

/**
 * @description 定义抽象工厂
 * @date 2019/7/31
 */
public interface AbstractFactory {

    public ShapeProduct newShape(String shape);

    public ColorProduct newColor(String color);

}

定义color产品的接口类

public interface ColorProduct {

    public void color();
}

color产品的实现类

/**
 * @description 具体产品:Red
 * @date 2019/7/31
 */
public class Red implements ColorProduct {
    @Override
    public void color() {
        System.out.println("****颜色 ： 红色*********");
    }
}

/**
 * @description 具体产品Yellow
 * @date 2019/7/31
 */
public class Yellow implements ColorProduct {
    @Override
    public void color() {
        System.out.println("****颜色 ： 黄色*********");
    }
}

定义shape的产品接口和实现类

/**
 * @description 定义产品接口
 * @date 2019/7/31
 */
public interface ShapeProduct {

    public void show();
}

/**
 * @description 三角形
 * @date 2019/7/31
 */
public class Triangle implements ShapeProduct {


    @Override
    public void show() {
        System.out.println("**形状 ： 三角形***");
    }
}

/**
 * @description 矩形
 * @date 2019/7/31
 */
public class Rectangle implements ShapeProduct {
    @Override
    public void show() {
        System.out.println("****形状 ： 矩形*********");
    }
}

实现抽象工厂

/**
 * @description 形状工厂
 * @date 2019/7/31
 */
public class ShapeFactory implements AbstractFactory {

    @Override
    public ShapeProduct newShape(String shape) {

        if(shape.equalsIgnoreCase("Triangle")){
            return new Triangle();
        } else if(shape.equalsIgnoreCase("Rectangle")){
            return new Rectangle();
        }
        return null;
    }

    @Override
    public ColorProduct newColor(String color) {
        return null;
    }
}


/**
 * @description 颜色工厂
 * @date 2019/7/31
 */
public class ColorFactory implements AbstractFactory {

    @Override
    public ShapeProduct newShape(String shape) {
        return null;
    }

    @Override
    public ColorProduct newColor(String color) {
        if(color.equalsIgnoreCase("RED")){
            return new Red();
        } else if(color.equalsIgnoreCase("Yellow")){
            return new Yellow();
        }
        return null;
    }

}

创建构造器，通过传递不同的参数获取不同的工厂

/**
 * @description 工厂生成器，选择需要的工厂
 * @date 2019/7/31
 */
public class FactoryProducer {

    /**
     * 获取所需要的工厂类
     * @param factory
     * @return
     */
    public static AbstractFactory getFactory(String factory){
        if(factory.equalsIgnoreCase("ShapeFactory")){
            return new ShapeFactory();
        }else if(factory.equalsIgnoreCase("ColorFactory")){
            return new ColorFactory();
        }
        return null;
    }
}

测试

public class Client {

    public static void main(String args[]){


        //形状工厂
        AbstractFactory factory = FactoryProducer.getFactory("ShapeFactory");

        //形状产品类 : 输出三角形
        ShapeProduct triangle = factory.newShape("Triangle");

        triangle.show();

        //矩形
        ShapeProduct rectangle = factory.newShape("Rectangle");

        rectangle.show();
    }
}

使用场景

抽象工厂模式通常适用于以下场景：

1. 当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。
2. 系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
3. 系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。