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

最新推荐文章于 2024-08-03 18:41:07 发布

kangswx

最新推荐文章于 2024-08-03 18:41:07 发布

阅读量107

点赞数

分类专栏：设计模式

本文链接：https://blog.csdn.net/kangswx/article/details/103544133

版权

设计模式专栏收录该内容

19 篇文章 0 订阅

订阅专栏

工厂方法模式中只能创建一类对象，但是不能创建多个类型的产品。
产品族是在抽象工厂模式中，在抽象工厂模式中，产品组是指有同一个工厂生产位于不同产品等级结构中的一组产品。
抽象工厂模式提供一个接口，用于创建相关或者依赖的对象的家族，而不需要明确指定具体类。
抽象工厂允许客户端使用抽象的接口来创建一组相关的产品，而不需要关心实际产出的具体产品是什么，这样，客户就可以从具体的产品中被解耦。
一般来说，产品种类单一，适合用工厂模式；如果有多种产品，每种产品又有不同的类型的时候，可以通过抽象工厂模式来创建。
抽奖工厂模式的UML图

抽奖工厂模式的实现过程

创建两个产品类

/**
 * 抽象产品类
 */
public abstract class Pizza {

    abstract void prepare();

    abstract void create();

    abstract void complete();
}

public abstract class Milk {

    abstract void prepare();

    abstract void create();

    abstract void complete();
}

创建具体的产品

/**
 * 蔬菜披萨
 */
public class PizzaVegg extends Pizza {

    @Override
    public void prepare() {
        System.out.println("准备蔬菜");
    }

    @Override
    public void create() {
        System.out.println("制作蔬菜");
    }

    @Override
    public void complete() {
        System.out.println("制作蔬菜成功");
    }

}

public class AppleMilk extends Milk {
    @Override
    void prepare() {
        System.out.println("准备苹果味牛奶");
    }

    @Override
    void create() {
        System.out.println("制作苹果味牛奶");
    }

    @Override
    void complete() {
        System.out.println("苹果味牛奶制作完成");
    }
}

创建抽象工厂类

public interface AbstractFactory {

    Pizza createPizza(String type);

    Milk createMilk(String type);
}

创建两个不同产品等级的具体工厂

public class ColdFoodFactory implements AbstractFactory {

    @Override
    public Pizza createPizza(String type) {
        Pizza pizza = null;
        if(type.equals("VEGG")){
            pizza = new PizzaVegg();
            pizza.prepare();
            pizza.complete();
        }
        return pizza;
    }

    @Override
    public Milk createMilk(String type) {
        Milk milk = null;
        if(type.equals("APPLE")){
            milk = new AppleMilk();
            milk.prepare();
            milk.complete();
        }
        return milk;
    }

}

/**
 * 生产的是一个产品族，包含了牛奶和披萨，产品的等级结构是Hot
 */
public class HotFoodFactory implements AbstractFactory {

    @Override
    public Pizza createPizza(String type) {
        Pizza pizza = null;
        if(type.equals("VEGG")){
            pizza = new PizzaVegg();
            pizza.prepare();
            pizza.create();
            pizza.complete();
        }

        return pizza;
    }

    @Override
    public Milk createMilk(String type) {
        Milk milk = null;
        if(type.equals("APPLE")){
            milk = new AppleMilk();
            milk.prepare();
            milk.create();
            milk.complete();
        }
        return milk;
    }

}

创建集体的店面类

public class Store {

    public static void comsume(String foodType, String type, String pizzaType){
        if("pizza".equals(foodType)){
            if("hot".equals(type)){
                HotFoodFactory hotFoodFactory = new HotFoodFactory();
                hotFoodFactory.createPizza(pizzaType);
            }
            if("cold".equals(type)){
                ColdFoodFactory coldFoodFactory = new ColdFoodFactory();
                coldFoodFactory.createPizza(pizzaType);
            }
        } else if("milk".equals(foodType)){
            if("hot".equals(type)){
                HotFoodFactory hotFoodFactory = new HotFoodFactory();
                hotFoodFactory.createMilk(pizzaType);
            }
            if("cold".equals(type)){
                ColdFoodFactory coldFoodFactory = new ColdFoodFactory();
                coldFoodFactory.createMilk(pizzaType);
            }
        }
    }

    public static void main(String[] args) {
        comsume("pizza", "cold", "VEGG");
    }
}

抽象工厂模式的优点
1. 抽奖工厂隔离了具体类的生成，客户端不需要知道具体的创建过程，所有的具体工厂都实现了抽象工厂中定义的公共接口，因此只需要改变具体的工厂实例，就可以改变整个软件系统的行为。
2. 当一个产品族中的多个对象被设计成一起工作时，能够保证客户端始终只是用同一个产品族中的对象。
抽象工厂模式的缺点
1. 添加新的行为时比较麻烦，如果添加一个新产品族对象时，需要更改接口及其下面的所有子类，很带来很大的麻烦(这个缺点是简单工厂模式也有的缺点)。