Java设计模式【之】抽象工厂模式【场景：生产咖啡】

最新推荐文章于 2024-09-16 16:03:53 发布

长毛山顶洞人

最新推荐文章于 2024-09-16 16:03:53 发布

阅读量694

点赞数

分类专栏：《Java-设计模式》

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/m0_37969197/article/details/123936318

版权

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

《Java-设计模式》专栏收录该内容

9 篇文章 1 订阅

订阅专栏

Java设计模式【之】抽象工厂模式【场景：生产咖啡】

1.抽象工厂模式
2.场景代码实现
3.源码下载
《七大设计原则》
《目录：Java设计模式》
《幕》

1.抽象工厂模式

抽象工厂模式
创建对象实例时，不要直接 new 类, 而是把这个new 类的动作放在一个工厂的方法中，并返回。
在工厂方法的基础上，进一步抽象工厂类,将工厂抽象成两层，AbsFactory(抽象工厂) 和具体实现工厂子类。
调用者根据创建对象类型使用对应的工厂子类。
这样将单个的简单工厂类变成了工厂簇，利于代码的维护和扩展

使用场景：工厂存在扩展的可能，且扩展后工厂的生产方式存在差异

2.场景代码实现

2.1.场景

生产咖啡
存在两个品牌的咖啡，不同地域的厂家，生产顺序相同，生产方式不通

2.2.咖啡抽象


/**
 * 咖啡抽象
 */
abstract class Coffee {

    String name;

    public Coffee(String name) {
        this.name = name;
        //准备材料
        materials();
        //生产
        produce();
    }

    //准备材料
    abstract void materials();

    //生产
    abstract void produce();
}

2.3.咖啡的两种品牌实现

class 星巴克 extends Coffee {

    public 星巴克(String name) {
        super(name);
    }

    @Override
    void materials() {
        System.out.println(name + "：【星巴克-原材料：咖啡豆+糖】");
    }

    @Override
    void produce() {
        System.out.println("生产结果：星巴克咖啡x50g \n");

    }
}

class 雀巢 extends Coffee {
    public 雀巢(String name) {
        super(name);
    }

    @Override
    void materials() {
        System.out.println(name + "：【雀巢-原材料：咖啡豆】");
    }

    @Override
    void produce() {
        System.out.println("生产结果：雀巢咖啡x10g\n");
    }
}

2.4.抽象工厂


/**
 * 咖啡工厂
 */
abstract class AbstractCoffeeFactory {

    abstract Coffee createCoffee(String type);

}

2.5.抽象工厂的不同地域实现

/**
 * 杭州咖啡工厂
 */
class HangZhouCoffeeFactory extends AbstractCoffeeFactory {

    public Coffee createCoffee(String type) {
        Coffee c = null;
        switch (type) {
            case "星巴克":
                c = new 星巴克("杭州特加工");
                break;
            case "雀巢":
                c = new 雀巢("杭州特加工");
                break;
            default:
                System.out.println("杭州特加工：" + type + " :不存在！！！\n");
                break;
        }
        return c;
    }
}

/**
 * 上海咖啡工厂
 */
class ShangHaiCoffeeFactory extends AbstractCoffeeFactory {

    public Coffee createCoffee(String type) {
        Coffee c = null;
        switch (type) {
            case "星巴克":
                c = new 星巴克("上海特色");
                break;
            case "雀巢":
                c = new 雀巢("上海特色");
                break;
            default:
                System.out.println("上海特色：" + type + " :不存在！！！\n");
                break;
        }
        return c;
    }
}

2.6.测试


/**
 * 抽象工厂
 * <p>
 * 创建对象实例时，不要直接 new 类, 而是把这个new 类的动作放在一个工厂的方法中，并返回。
 * 在工厂方法的基础上，进一步抽象工厂类,将工厂抽象成两层，AbsFactory(抽象工厂) 和具体实现工厂子类。
 * 调用者根据创建对象类型使用对应的工厂子类。
 * 这样将单个的简单工厂类变成了工厂簇， 利于代码的维护和扩展
 * <p>
 * 使用场景：工厂存在扩展的可能，且扩展后工厂的生产方式存在差异
 */
public class _Test {

    public static void main(String[] args) {

        /**
         * 上海工厂
         */
        Coffee sh_kf_1 = new ShangHaiCoffeeFactory().createCoffee("星巴克");
        Coffee sh_kf_2 = new ShangHaiCoffeeFactory().createCoffee("雀巢");
        Coffee sh_kf_3 = new ShangHaiCoffeeFactory().createCoffee("牛栏山");

        /**
         * 杭州工厂
         */
        Coffee hz_kf_1 = new HangZhouCoffeeFactory().createCoffee("星巴克");
        Coffee hz_kf_2 = new HangZhouCoffeeFactory().createCoffee("雀巢");
        Coffee hz_kf_3 = new HangZhouCoffeeFactory().createCoffee("牛栏山");

        /**
         * 新增后
         */
        //        Coffee ? = new ???CoffeeFactory().createCoffee("?");
        //        Coffee ? = new ???CoffeeFactory().createCoffee("?");
        //        Coffee ? = new ???CoffeeFactory().createCoffee("?");

    }

}