设计模式之工厂模式

最新推荐文章于 2022-07-29 18:05:47 发布
最新推荐文章于 2022-07-29 18:05:47 发布
阅读量531 收藏 7
点赞数 1
分类专栏： 设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnds123321/article/details/118467580
版权

问题引入

需求，设计一个咖啡店点餐系统。设计一个咖啡类（Coffee），并定义其两个子类（美式咖啡【AmericanCoffee】和拿铁咖啡【LatteCoffee】）；再设计一个咖啡店类（CoffeeStore），咖啡店具有点咖啡的功能。 其UML类图如下：

实现代码如下：

  • Coffee.java
public abstract class Coffee {
    /**
     * 咖啡名称，抽象方法，必须被实现
     *
     * @return 返回咖啡名称
     */
    public abstract String getName();

    /**
     * 加糖
     */
    public void addSugar() {
        System.out.println("加糖");
    }

    /**
     * 加奶
     */
    public void addMilk() {
        System.out.println("加奶");
    }
}
  • AmericanCoffee.java
public class AmericanCoffee extends Coffee {
    @Override
    public String getName() {
        return "美式咖啡";
    }
}
  • LatteCoffee.java
public class LatteCoffee extends Coffee {
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}
  • CoffeeStore.java
public class CoffeeStore {

    /**
     * 生成咖啡方法
     *
     * @param type 指定要生成的咖啡类型：美式咖啡american和拿铁咖啡latte
     * @return 返回生成完成的咖啡
     */
    public Coffee orderCoffee(String type) {
        // 声明Coffee类型的变量，根据不同类型创建不同的coffee子类对象
        Coffee coffee = null;
        // 根据type生产不同的咖啡
        if ("american".equals(type)) {
            coffee = new AmericanCoffee();
        } else if ("latte".equals(type)) {
            coffee = new LatteCoffee();
        } else {
            throw new RuntimeException("对不起，没有你所点的咖啡");
        }
        // 加配料
        coffee.addSugar();
        coffee.addMilk();
        // 返回
        return coffee;
    }
}
  • Test.java
public class Test {
    public static void main(String[] args) {
        CoffeeStore coffeeStore = new CoffeeStore();
        // 生产美式咖啡
        Coffee americanCoffee = coffeeStore.orderCoffee("american");
        System.out.println(americanCoffee.getName());
        // 生产拿铁咖啡
        Coffee latteCoffee = coffeeStore.orderCoffee("latte");
        System.out.println(latteCoffee.getName());
    }
}

假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则。如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；所以说，工厂模式最大的优点就是：解耦。

按实际业务场景划分，工厂模式有 3 种不同的实现方式，分别是简单工厂模式、工厂方法模式和抽象工厂模式。

简单工厂模式

概述

简单工厂不是一种设计模式，反而比较像是一种编程习惯。

我们把被创建的对象称为“产品”，把创建产品的对象称为“工厂”。如果要创建的产品不多，只要一个工厂类就可以完成，这种模式叫“简单工厂模式”。（注：简单工厂模式只有一个工厂类，不同的产品都是在这一个工厂中创建完成的。）

在简单工厂模式中创建实例的方法通常为静态（static）方法，因此简单工厂模式（Simple Factory Pattern）又叫作静态工厂方法模式（Static Factory Method Pattern）。（注：在工厂类给创建产品的方法添加一个static关键字，就可以直接通过工厂类名方法创建方法，所以可以叫静态工厂方法模式）

简单来说，简单工厂模式有一个具体的工厂类，可以生成多个不同的产品，属于创建型设计模式。简单工厂模式不在 GoF 23 种设计模式之列。（注：其实本章讲了三种设计模式：简单工厂模式、工厂方法模式和抽象工厂模式，其中简单工厂模式不属于23种设计模式之列的，但后两者属于，所以本章同时讲了两种GOF设计模式）

结构

简单工厂模式的主要角色如下：

  • 简单工厂（SimpleFactory）：是简单工厂模式的核心，负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。（注：简单工厂类是一个普通的类，里面有一个创建产品的方法，该方法可以使用static关键字修饰，然后就可以直接通过类名调用方法了，该方法的返回值是抽象产品类Product，而该方法通常会给定一个参数，用来判断创建不同的产品）
  • 抽象产品（Product）：是简单工厂创建的所有对象的父类，负责描述所有实例共有的公共接口。（注：抽象产品类Product通常是一个接口，也可以是抽象类，该接口中可以定义产品的一些属性和行为方法）
  • 具体产品（ConcreteProduct）：是简单工厂模式的创建目标。（注：该类是继承或者实现Product类，实现里面的方法）

下图是结构的UML类图：

具体实现代码如下：（注：我是先创建抽象产品类Product，在该类中定义产品的属性和行为方法，接着创建具体产品类ConcreteProductA和ConcreteProductB，分别实现Product接口中的方法，再创建工厂类SimpleFactory.java，在该类中创建一个能够创建产品的方法，最后才是测试类Client.java）

  • Product.java
/**
 * @author lcl100
 * @create 2021-07-19 21:07
 * @desc 抽象产品类，定义产品的属性和行为方法
 */
public interface Product {
    /**
     * 展示产品
     */
    public void show();
}
  • ConcreteProductA.java
/**
 * @author lcl100
 * @create 2021-07-19 21:09
 * @desc 具体产品类A，实现Product接口
 */
public class ConcreteProductA implements Product {
    @Override
    public void show() {
        // 实现抽象产品类中的方法
        System.out.println("具体A产品...");
    }
}
  • ConcreteProductB.java
/**
 * @author lcl100
 * @create 2021-07-19 21:10
 * @desc 具体产品类B，实现Product接口
 */
public class ConcreteProductB implements Product {
    @Override
    public void show() {
        // 实现抽象产品类中的方法
        System.out.println("具体B产品...");
    }
}
  • SimpleFactory.java
/**
 * @author lcl100
 * @create 2021-07-19 21:12
 * @desc 简单工厂类
 */
public class SimpleFactory {
    /**
     * 简单工厂类中创建产品的方法
     *
     * @param name 传入的参数，用来区分创建不同的产品
     * @return 返回创建成功的产品
     */
    public static Product makeProduct(String name) {
        // 为了能够判断创建不同的产品，通常可以选择用if或者switch来实现
        switch (name) {
            case "A":// 如果传入的是'A'，那么则创建A产品
                return new ConcreteProductA();
            case "B":// 如果传入的是'B'，那么则创建B产品
                return new ConcreteProductB();
            default:// 如果传入其他字符，那么则返回null，表示没有符合的产品
                return null;
        }
    }
}
  • Client.java
/**
 * @author lcl100
 * @create 2021-07-19 22:04
 * @desc 测试类，对简单工厂制造产品的方法进行测试
 */
public class Client {
    public static void main(String[] args) {
        // 第一步，调用工厂方法创建产品，不需要创建工厂，因为是静态方法，可以直接通过类名调用方法
        Product product = SimpleFactory.makeProduct("A");// 传入参数A，表示创建A产品
        // 第二步，调用产品的方法
        product.show();
    }
}

而将上面的咖啡店案例用简单工厂模式改造后的UML类图如下：

代码

实现代码如下：

  • Coffee.java
public abstract class Coffee {
    /**
     * 咖啡名称，抽象方法，必须被实现
     *
     * @return 返回咖啡名称
     */
    public abstract String getName();

    /**
     * 加糖
     */
    public void addSugar() {
        System.out.println("加糖");
    }

    /**
     * 加奶
     */
    public void addMilk() {
        System.out.println("加奶");
    }
}
  • AmericanCoffee.java
public class AmericanCoffee extends Coffee {
    @Override
    public String getName() {
        return "美式咖啡";
    }
}
  • LatteCoffee.java
public class LatteCoffee extends Coffee {
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}
  • SimpleCoffeeFactory.java
public class SimpleCoffeeFactory {
    /**
     * 生成咖啡方法
     *
     * @param type 指定要生成的咖啡类型：美式咖啡american和拿铁咖啡latte
     * @return 返回生成完成的咖啡
     */
    public Coffee orderCoffee(String type) {
        // 声明Coffee类型的变量，根据不同类型创建不同的coffee子类对象
        Coffee coffee = null;
        // 根据type生产不同的咖啡
        if ("american".equals(type)) {
            coffee = new AmericanCoffee();
        } else if ("latte".equals(type)) {
            coffee = new LatteCoffee();
        } else {
            throw new RuntimeException("对不起，没有你所点的咖啡");
        }
        // 不需要加配料，加配料是咖啡店应该做的事情
        // 返回
        return coffee;
    }
}
  • CoffeeStore.java
public class CoffeeStore {

    /**
     * 生成咖啡方法
     *
     * @param type 指定要生成的咖啡类型：美式咖啡american和拿铁咖啡latte
     * @return 返回生成完成的咖啡
     */
    public Coffee orderCoffee(String type) {
        // 从简单咖啡工厂拿取生产的咖啡
        SimpleCoffeeFactory factory = new SimpleCoffeeFactory();
        // 调用工厂的方法生产咖啡
        Coffee coffee = factory.orderCoffee(type);
        // 加配料
        coffee.addSugar();
        coffee.addMilk();
        // 返回
        return coffee;
    }
}
  • Test.java
public class Test {
    public static void main(String[] args) {
        CoffeeStore coffeeStore = new CoffeeStore();
        // 生产美式咖啡
        Coffee americanCoffee = coffeeStore.orderCoffee("american");
        System.out.println(americanCoffee.getName());
        // 生产拿铁咖啡
        Coffee latteCoffee = coffeeStore.orderCoffee("latte");
        System.out.println(latteCoffee.getName());
    }
}

工厂（factory）处理创建对象的细节，一旦有了SimpleCoffeeFactory，CoffeeStore类中的orderCoffee()就变成此对象的客户，后期如果需要Coffee对象直接从工厂中获取即可。这样也就解除了和Coffee实现类的耦合，同时又产生了新的耦合，CoffeeStore对象和SimpleCoffeeFactory工厂对象的耦合，工厂对象和商品对象的耦合。

后期如果再加新品种的咖啡，我们势必要需求修改SimpleCoffeeFactory的代码，违反了开闭原则。

如上，为了练习简单工厂模式，我们还可以写很多案例，如人类工厂生产不同颜色皮肤的人类、手机工厂创建不同品牌的手机等等。具体可以参考代码。

优缺点

  • 优点
  1. 工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责，很方便的创建出相应的产品。工厂和产品的职责区分明确。
  2. 客户端无需知道所创建具体产品的类名，只需知道参数即可。（注：只需要给工厂类的创建产品的方法传入一个参数就可以创建我们需要的产品了，而不需要记住具体的类名，但可能需要记住参数。）
  3. 也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类。（注：后面会说明简单工厂模式搭配配置文件的使用。）
  • 缺点
  1. 简单工厂模式的工厂类单一，负责所有产品的创建，职责过重，一旦异常，整个系统将受影响。且工厂类代码会非常臃肿，违背高聚合原则。（注：简单工厂模式只需要一个工厂类，该工厂负责创建所有的产品，如果产品过多会增加工厂代码负担，如果工厂类出现异常代码，那么使用工厂创建的产品也会无法正常使用）
  2. 使用简单工厂模式会增加系统中类的个数（引入新的工厂类），增加系统的复杂度和理解难度。
  3. 系统扩展困难，一旦增加新产品不得不修改工厂逻辑，在产品类型较多时，可能造成逻辑过于复杂。（注：如果要添加新产品，必须修改工厂类的源代码，添加判断逻辑，而如果添加的产品过于多，那么逻辑会越发的复杂。）
  4. 简单工厂模式使用了 static 工厂方法，造成工厂角色无法形成基于继承的等级结构。（注：工厂类中的静态方法可以被继承，但是无法被重写，也就不能形成多态，而只能通过类名直接调用。）
  5. 增加新产品时还是需要修改工厂类的代码，违背了“开闭原则”。（注：如果要添加新产品，必须修改工厂类的源代码，添加判断逻辑，所以违背了开闭原则。）

扩展：静态工厂

在开发中也有一部分人将工厂类中的创建对象的功能定义为静态的，这个就是静态工厂模式，它也不是23种设计模式中的。代码如下：

    public static Coffee orderCoffee(String type) {
        // 声明Coffee类型的变量，根据不同类型创建不同的coffee子类对象
        Coffee coffee = null;
        // 根据type生产不同的咖啡
        if ("american".equals(type)) {
            coffee = new AmericanCoffee();
        } else if ("latte".equals(type)) {
            coffee = new LatteCoffee();
        } else {
            throw new RuntimeException("对不起，没有你所点的咖啡");
        }
        // 不需要加配料，加配料是咖啡店应该做的事情
        // 返回
        return coffee;
    }

工厂方法模式

概述

针对简单工厂模式的缺点（注：引入新的产品，必须修改工厂类源码，违反开闭原则。），使用工厂方法模式就可以解决问题，可以使系统在不修改原来代码的情况下引进新的产品，完全遵循开闭原则。

定义一个用于创建对象的接口，让子类决定实例化哪个产品类对象。工厂方法使一个产品类的实例化延迟到其工厂的子类。

结构

工厂方法模式的主要角色如下。

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

结构的UML类图如下：

 实现代码如下：

  • Product.java
/**
 * @author lcl100
 * @create 2021-07-20 22:32
 * @desc 抽象产品类，定义了产品的属性和行为方法
 */
public abstract class Product {
    /**
     * 展示产品的方法
     */
    public abstract void show();
}
  • ConcreteProductA.java
/**
 * @author lcl100
 * @create 2021-07-20 22:34
 * @desc 具体产品A，实现抽象产品类中的方法
 */
public class ConcreteProductA extends Product {
    @Override
    public void show() {
        System.out.println("具体产品A...");
    }
}
  • ConcreteProductB.java
/**
 * @author lcl100
 * @create 2021-07-20 22:35
 * @desc 具体产品B，继承抽象产品类，实现里面定义的抽象方法
 */
public class ConcreteProductB extends Product {
    @Override
    public void show() {
        System.out.println("具体产品B...");
    }
}
  • Factory.java
/**
 * @author lcl100
 * @create 2021-07-20 22:35
 * @desc 抽象工厂接口，定义了工厂创建产品的方法
 */
public interface Factory {
    /**
     * 工厂创建产品的方法
     *
     * @return 返回创建成功的产品
     */
    public Product createProduct();
}
  • ConcreteFactoryA.java
/**
 * @author lcl100
 * @create 2021-07-20 22:37
 * @desc 具体工厂A，注意，A工厂只生产A产品，而不会生产B产品
 */
public class ConcreteFactoryA implements Factory {

    @Override
    public Product createProduct() {
        // 创建具体A产品
        return new ConcreteProductA();
    }
}
  • ConcreteFactoryB.java
/**
 * @author lcl100
 * @create 2021-07-20 22:39
 * @desc 具体工厂B，注意，B工厂只能创建B产品
 */
public class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        // 创建具体产品B
        return new ConcreteProductB();
    }
}
  • Client.java
/**
 * @author lcl100
 * @create 2021-07-20 22:42
 * @desc 测试类
 */
public class Client {
    public static void main(String[] args) {
        // 为了创建B产品，所以我们只需要创建B工厂
        Factory BFactory = new ConcreteFactoryB();
        // 利用B工厂创建B产品
        Product product = BFactory.createProduct();
        // 调用B工厂的方法
        product.show();
    }
}

分为两个角色来理解可能更好点，抽象和具体本身是一对的，是可以联想的。

代码

 将上面的咖啡店案例改造为工厂方法模式的代码，其UML类图如下：

实现代码如下：

  • Coffee.java
public abstract class Coffee {
    /**
     * 咖啡名称，抽象方法，必须被实现
     *
     * @return 返回咖啡名称
     */
    public abstract String getName();

    /**
     * 加糖
     */
    public void addSugar() {
        System.out.println("加糖");
    }

    /**
     * 加奶
     */
    public void addMilk() {
        System.out.println("加奶");
    }
}
  • AmericanCoffee.java
public class AmericanCoffee extends Coffee {
    @Override
    public String getName() {
        return "美式咖啡";
    }
}
  • LatteCoffee.java
public class LatteCoffee extends Coffee {
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}
  • CoffeeFactory.java
public interface CoffeeFactory {
    /**
     * 创建咖啡对象的方法
     *
     * @return 返回创建的咖啡对象
     */
    Coffee createCoffee();
}
  • AmericanCoffeeFactory.java
public class AmericanCoffeeFactory implements CoffeeFactory{
    @Override
    public Coffee createCoffee() {
        // 生产美式咖啡
        return new AmericanCoffee();
    }
}
  • LatteCoffeeFactory.java
public class LatteCoffeeFactory implements CoffeeFactory {
    @Override
    public Coffee createCoffee() {
        // 生产拿铁咖啡
        return new LatteCoffee();
    }
}
  • CoffeeStore.java
public class CoffeeStore {
    private CoffeeFactory factory;

    public void setCoffeeFactory(CoffeeFactory coffeeFactory) {
        this.factory = coffeeFactory;
    }

    /**
     * 点咖啡
     * @return
     */
    public Coffee orderCoffee(){
        // 通过工厂生产咖啡
        Coffee coffee = factory.createCoffee();
        // 加配料
        coffee.addMilk();
        coffee.addSugar();
        // 返回
        return coffee;
    }
}
  • Test.java
public class Test {
    public static void main(String[] args) {
        // 1.创建咖啡店对象
        CoffeeStore coffeeStore = new CoffeeStore();

        // 2.生成美式咖啡
        // 2.1创建美式工厂类对象
        AmericanCoffeeFactory americanCoffeeFactory = new AmericanCoffeeFactory();
        // 2.2为咖啡店设置工厂类
        coffeeStore.setCoffeeFactory(americanCoffeeFactory);
        // 2.3生成美式咖啡
        Coffee americanCoffee = coffeeStore.orderCoffee();
        // 2.4打印咖啡名称
        System.out.println(americanCoffee.getName());

        // 3.生成拿铁咖啡
        // 3.1创建拿铁工厂类对象
        LatteCoffeeFactory latteCoffeeFactory = new LatteCoffeeFactory();
        // 3.2为咖啡店设置工厂类
        coffeeStore.setCoffeeFactory(latteCoffeeFactory);
        // 3.3生成拿铁咖啡
        Coffee latteCoffee = coffeeStore.orderCoffee();
        // 3.4打印咖啡名称
        System.out.println(latteCoffee.getName());
    }
}

优缺点

优点：

  • 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。（在简单工厂模式中需要知道参数来区别不同的产品，而在工厂方法模式中只需要知道具体工厂的名称就可以创建该工厂对应的产品。）
  • 灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。（新增加产品不需要修改工厂代码，只需要实现抽象工厂接口就可以新创建一个工厂，然后创建该工厂对应的产品，符合开闭原则。）
  • 典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。（在抽象工厂接口中使用的是抽象产品类，而不是具体产品类，所以满足了迪米特等法则）

缺点：

  • 类的个数容易过多，增加复杂度。（每新增一个产品，就必须增加一个能够生产该产品的工厂类，如果产品多了，工厂也会多，类的数量就会很多了。）
  • 增加了系统的抽象性和理解难度。（高层工厂类和产品都是抽象的。）
  • 抽象工厂只能生产一种产品，此弊端可使用抽象工厂模式解决。（我们可以看到抽象工厂类中只有一个创建产品的方法，只能创建一种产品，如果一个工厂要创建多个产品，就需要使用抽象工厂模式。）

应用场景：

  • 客户只知道创建产品的工厂名，而不知道具体的产品名。如 TCL 电视工厂、海信电视工厂等。
  • 创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。
  • 客户不关心创建产品的细节，只关心产品的品牌

抽象工厂模式

概述

前面介绍的工厂方法模式中考虑的是一类产品的生产，如畜牧场只养动物、电视机厂只生产电视机。

这些工厂只生产同种类产品，同种类产品称为同等级产品，也就是说：工厂方法模式只考虑生产同等级的产品，但是在现实生活中许多工厂是综合型的工厂，能生产多等级（种类） 的产品，如电器厂既生产电视机又生产洗衣机或空调，大学既有软件专业又有生物专业等。

本节要介绍的抽象工厂模式将考虑多等级产品的生产，将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族，下图所示横轴是产品等级，也就是同一类产品；纵轴是产品族，也就是同一品牌的产品，同一品牌的产品产自同一个工厂。

看下图，可能对同一产品族有清晰的认知：（例如服装厂中的上衣、帽子、裤子、鞋子，又如电脑厂中的内存条、显示器、主机、键盘等都是同一个产品族的。）

抽象工厂模式是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

使用抽象工厂模式一般要满足以下条件：

  • 系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。（例如电脑工厂可以创建CPU、内存条、显示器这属于同一产品族但属于不同等级结构的产品。）
  • 系统一次只可能消费其中某一族产品，即同族的产品一起使用。

结构

抽象工厂模式的主要角色如下：

  • 抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法，可以创建多个不同等级的产品。（例如：电脑抽象工厂提供了生产操作系统和电脑软件的方法，应该至少有生产两个不同产品的方法，毕竟如果只生产一个产品就可以采用工厂方法模式而不是抽象工厂模式。）

  • 具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。（具体工厂是实现抽象工厂的子类，可以有多个。例如生产32位系统的电脑工厂和生产64位系统的电脑工厂。）

  • 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。（定义了产品的规范，实际上抽象工厂接口中提供了几个生产不同产品的方法，抽象产品类就应该有几个，例如下图的Factory可以生产ProductA和ProductB，那么就会有这两个抽象产品类。）

  • 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它 同具体工厂之间是多对一的关系。（抽象产品类的具体实现类，实际上具体实现类应该与具体工厂类有关系。）

其UML类图如下：

 各实现代码类如下：

  • ProductA.java
/**
 * @author lcl100
 * @create 2021-07-21 22:43
 * @desc 抽象产品A，是工厂产品族中的一类，例如电脑工厂中的CPU产品，CPU又可以分为AMD和Intel生产的
 */
public abstract class ProductA {
    /**
     * 产品A的展示方法
     */
    public abstract void show();
}
  • ConcreteProductA1.java
/**
 * @author lcl100
 * @create 2021-07-21 23:02
 * @desc 具体A1产品
 */
public class ConcreteProductA1 extends ProductA {
    @Override
    public void show() {
        System.out.println("具体A1产品");
    }
}
  • ConcreteProductA2.java
/**
 * @author lcl100
 * @create 2021-07-21 23:03
 * @desc 具体A2产品
 */
public class ConcreteProductA2 extends ProductA {
    @Override
    public void show() {
        System.out.println("具体A2产品");
    }
}
  • ProductB.java
/**
 * @author lcl100
 * @create 2021-07-21 22:46
 * @desc 抽象产品B，是工厂产品族中的一类，例如电脑工厂中的内存条产品，内存条又可以分为金士顿和芝奇生产的
 */
public abstract class ProductB {
    /**
     * 产品B的展示方法
     */
    public abstract void show();
}
  • ConcreteProductB1.java
/**
 * @author lcl100
 * @create 2021-07-21 23:04
 * @desc 具体B1产品
 */
public class ConcreteProductB1 extends ProductB {
    @Override
    public void show() {
        System.out.println("具体B1产品");
    }
}
  • ConcreteProductB2.java
/**
 * @author lcl100
 * @create 2021-07-21 23:05
 * @desc 具体B2产品
 */
public class ConcreteProductB2 extends ProductB {
    @Override
    public void show() {
        System.out.println("具体B2产品");
    }
}
  • Factory.java
/**
 * @author lcl100
 * @create 2021-07-21 22:49
 * @desc 抽象工厂接口，可以用来生产同一产品族不同等级的产品，例如生产电脑的CPU配件、内存条配件等
 */
public interface Factory {
    /**
     * 创建产品族中的A产品，例如电脑的CPU配件
     *
     * @return 返回值是A产品的抽象类，即创建成功的A产品
     */
    public ProductA createProductA();

    /**
     * 创建产品族中的B产品，例如电脑的内存条配件
     *
     * @return 返回值是B产品的抽象类，即创建成功的B产品
     */
    public ProductB createProductB();
}
  • ConcreteFactory1.java
/**
 * @author lcl100
 * @create 2021-07-21 22:57
 * @desc 具体工厂1，用来生产该工厂能提供的产品族产品，例如联想工厂
 */
public class ConcreteFactory1 implements Factory{
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}
  • ConcreteFactory2.java
/**
 * @author lcl100
 * @create 2021-07-21 22:59
 * @desc 具体工厂2，用来生产该工厂能提供的产品族产品，例如苹果工厂
 */
public class ConcreteFactory2 implements Factory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

案例代码

还是上例，现咖啡店业务发生改变，不仅要生产咖啡还要生产甜点，如提拉米苏、抹茶慕斯等，要是按照工厂方法模式，需要定义提拉米苏类、抹茶慕斯类、提拉米苏工厂、抹茶慕斯工厂、甜点工厂类，很容易发生类爆炸情况。其中拿铁咖啡、美式咖啡是一个产品等级，都是咖啡；提拉米苏、抹茶慕斯也是一个产品等级；拿铁咖啡和提拉米苏是同一产品族（也就是都属于意大利风味），美式咖啡和抹茶慕斯是同一产品族（也就是都属于美式风味）。所以这个案例可以使用抽象工厂模式实现。UML类图如下：

实现代码如下：

  • Coffee.java
public abstract class Coffee {
    /**
     * 咖啡名称，抽象方法，必须被实现
     *
     * @return 返回咖啡名称
     */
    public abstract String getName();

    /**
     * 加糖
     */
    public void addSugar() {
        System.out.println("加糖");
    }

    /**
     * 加奶
     */
    public void addMilk() {
        System.out.println("加奶");
    }
}
  • AmericanCoffee.java
public class AmericanCoffee extends Coffee {
    @Override
    public String getName() {
        return "美式咖啡";
    }
}
  • LatteCoffee.java
public class LatteCoffee extends Coffee {
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}
  • Dessert.java
public abstract class Dessert {
    public abstract void show();
}
  • Tiramisu.java
public class Tiramisu extends Dessert {
    @Override
    public void show() {
        System.out.println("提拉米苏");
    }
}
  • MatchaMousse.java
public class MatchaMousse extends Dessert {
    @Override
    public void show() {
        System.out.println("抹茶慕斯");
    }
}
  • DessertFactory.java
public interface DessertFactory {
    /**
     * 生产咖啡
     *
     * @return
     */
    Coffee createCoffee();

    /**
     * 生产甜点
     *
     * @return
     */
    Dessert createDessert();
}
  • ItalyDessertFactory.java
public class ItalyDessertFactory implements DessertFactory {
    @Override
    public Coffee createCoffee() {
        // 返回意大利风味的拿铁咖啡
        return new LatteCoffee();
    }

    @Override
    public Dessert createDessert() {
        // 返回意大利风味的提拉米苏
        return new Tiramisu();
    }
}
  • AmericanDessertFactory.java
public class AmericanDessertFactory implements DessertFactory {

    @Override
    public Coffee createCoffee() {
        // 生产美式风味的咖啡
        return new AmericanCoffee();
    }

    @Override
    public Dessert createDessert() {
        // 生产美式风味的抹茶慕斯
        return new MatchaMousse();
    }
}
  • Test.java
public class Test {
    public static void main(String[] args) {
        // 创建的是意大利风味甜品工厂对象
        ItalyDessertFactory factory = new ItalyDessertFactory();
        // 获取拿铁咖啡和提拉米苏甜品
        Coffee coffee = factory.createCoffee();
        Dessert dessert = factory.createDessert();
        // 打印结果
        System.out.println(coffee.getName());
        dessert.show();
    }
}

如果要加同一个产品族的话，只需要再加一个对应的工厂类即可，不需要修改其他的类。

再提供一个实例，电脑分为32位系统架构和64位系统架构，而某些软件只能运行在32位的操作系统上，某些软件只能运行在64位的操作系统上，在这个案例中，操作系统和电脑软件是同一个产品产品族中不同等级的产品，而32位系统和64位系统是同一个产品族，32位软件和64位软件是同一个产品族，在这里面32位的电脑工厂只生产32位的电脑系统和软件，64位的电脑工厂只生产64位的电脑系统和软件，我觉得这个案例比上面的咖啡店案例要好理解点。其UML类图如下：

 具体源码请参考开放的源代码。

优缺点

抽象工厂模式除了具有工厂方法模式的优点外，其他主要优点如下。

  • 可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。（即同一个工厂类中可以生产不同的产品，它们属于不同等级，但不必要使用多个类来管理。）
  • 当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品族。
  • 抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。（当需要增加新的产品族时，只需要继承抽象类，自定义实现即可，不需要修改源代码。）

其缺点是：

  • 当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度。（虽然增加产品族很容易，但是增加新产品却不容易了，因为产品是由工厂生产，所以必须修改所有的工厂类。）

使用场景：

  • 当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。

  • 系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。

  • 系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。

模式扩展：简单工厂+配置文件

可以通过工厂模式+配置文件的方式解除工厂对象和产品对象的耦合。在工厂类中加载配置文件中的全类名，并创建对象进行存储，客户端如果需要对象，直接进行获取即可。 Spring中有源码就采用了这种方式。

第一步，定义配置文件

我们使用properties文件作为配置误文件，名称为bean.properties

american=工厂模式.模式扩展.AmericanCoffee
latte=工厂模式.模式扩展.LatteCoffee

第二步，改造工厂类

public class SimpleCoffeeFactory {

    private static Map<String, Coffee> map = new HashMap<>();

    // 静态成员变量用来存储创建的对象（键存储的是名称，值存储的是对应的对象），而读取配置文件以及创建对象写在静态代码块中，目的就是只需要执行一次。
    static {
        Properties prop = new Properties();
        InputStream is = SimpleCoffeeFactory.class.getClassLoader().getResourceAsStream("bean.properties");
        try {
            prop.load(is);
            // 遍历properties集合对象
            Set<Object> keySet = prop.keySet();
            for (Object key : keySet) {
                // 根据键获取值，全类名
                String className = prop.getProperty((String) key);
                // 根据全类名加载字节码对象
                Class clazz = Class.forName(className);
                Coffee obj = (Coffee) clazz.newInstance();
                map.put((String) key, obj);
            }
        } catch (IOException | IllegalAccessException | InstantiationException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 生成咖啡方法
     *
     * @param type 指定要生成的咖啡类型：美式咖啡american和拿铁咖啡latte
     * @return 返回生成完成的咖啡
     */
    public static Coffee orderCoffee(String type) {
        // 根据type生产不同的咖啡，不过从bean.properties中加载
        return map.get(type);
    }
}

一样能够成功使用。

源码引用

在JDK中的Collection.iterator()方法底层就使用了抽象工厂模式。

public class Demo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("令狐冲");
        list.add("风清扬");
        list.add("任我行");

        //获取迭代器对象
        Iterator<String> it = list.iterator();
        //使用迭代器遍历
        while(it.hasNext()) {
            String ele = it.next();
            System.out.println(ele);
        }
    }
}

上面的代码大家应该很熟，使用迭代器遍历集合，获取集合中的元素。而单列集合获取迭代器的方法就使用到了工厂方法模式。

Collection接口是抽象工厂类，ArrayList是具体的工厂类；Iterator接口是抽象商品类，ArrayList类中的Iter内部类是具体的商品类。在具体的工厂类中iterator()方法创建具体的商品类的对象。

注意：

  • DateForamt类中的getInstance()方法使用的是工厂模式；

  • Calendar类中的getInstance()方法使用的是工厂模式；

二木成林
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【Java设计模式】工厂模式
清风微醺的博客
08-28 261
点咖啡案例 需求:设计一个咖啡店点餐系统。 设计一个咖啡类(coffee)，并定义其两个子类(美式咖啡【ameriEanCoffeg】和拿铁咖啡【Lattecoffee】);再设计一个咖啡店类(coffeestore)，咖啡店具有点咖啡的功能。 package com.factory; public abstract class Coffee { public abstract String getName(); public void addSuger(){ System
常用的几种设计模式详解
热门推荐
lenkee的博客
04-09 1万+
设计模式的概述 设计模式分类 创建型模式 特点是将对象的创建与使用分离（解耦），有 单例、原型、工厂方法、抽象工厂、建造者等5种。 结构型模式 用于描述如何将类或对象按某种布局组成更大的结构，代理、适配器、桥接、装饰、享元、组合等7种。 行为型模式 用于描述类或对象之间相互协作共同完成 单个对象无法完成的任务，模板方法、策略命令、职责链、状态观察者、中介者、迭代器、访问者、备忘录、解释器等11种。 UML 包含了用例图、类图、对象图、状态图、活动图、时序图、协作图、构建图、部署图等9种。 类
设计模式之装饰模式：以售卖咖啡为例
07-02
根据售卖咖啡的过程，客户先选择一种口味的咖啡，又选择不同种类的配料，由于配料选择是不定的，符合装饰模式的应用情况。
java实现咖啡店模拟_装饰者模式学习：模拟咖啡馆的点单系统来剖析装饰者模式的使用 + 装饰者模式在java I/O 中的应用...
weixin_39614657的博客
02-24 536
通过模拟咖啡馆的点单系统来剖析装饰者模式的使用一)、传统的点单系统构建，每一个种类的咖啡都定义一个类弊端：如果为每一种混合咖啡都定义一个类，那么，会产生很多的类对象。混合咖啡的价格是在单品咖啡的基础上的，如若某一单品咖啡的价格发生改变，那么就要修改与之关联的所有的混合咖啡的价格。咖啡的共同属性：/*** 抛转引玉* --：咖啡订单系统* 1.咖啡店售卖四款基础咖啡* Es...
设计模式
coffeesunshine的博客
02-04 52
创建型模式： 各种工厂模式Factory、Abstract Factory；单例模式Singleton；构建器模式Builder；原型模式ProtoType。 结构型模式： 类、对象继承、组合方式。包括桥接模式Bridge；适配器模式Adapter；装饰者模式Decorator；代理模式Proxy；组合模式Composite；外观模式Facade；享元模式Flyweight等。 行为型模式： 类或对象之间交互、职责划分等。策略模式Strategy；解释器模式Interpreter；命令模式Command；观
设计模式之工厂模式总结
12-21
设计模式之工厂模式 什么是工厂模式？ 工厂模式是一种常见的设计模式，将我们创建对象的行为封装（因为创建对象的行为往往是重复的）然后直接调用工厂所给出的方法创建对象即可。 工厂模式有三种： 1. 简单工厂模式...
PHP设计模式之工厂模式定义与用法详解
12-20
工厂模式(Factory Design Pattern)作为一种创建型设计模式, 遵循了开放-封闭原则, 对修改封闭, 对扩展开放. 工厂方法(Factory Method)模式就是要创建”某种东西”. 对于工厂方法模式, 要创建的”东西”是一个产品,这...
设计模式之工厂模式1
08-08
如果还不理解的话，那我们就再详细一点咯，假如我们想在网页面里插入一些元素，而这些元素类型不固定，可能是图片，也有可能是连接，甚至可能是文本，根据工厂模式的定义，
Java设计模式之工厂模式
08-27
主要为大家详细介绍了Java设计模式之工厂模式，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
设计模式之一装饰模式（含源码）：以售卖咖啡，配料应用解读
vainfanfan的博客
07-02 2804
以售卖咖啡，在咖啡中添加不同的配料为例，体验装饰模式的好处： 装饰模式介绍 应用背景 UML设计 总结 装饰模式介绍 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl + Q 插入链接 Ctrl + L 插入代码 Ctrl + K 插入图片 Ctrl + G 提升标题 Ctrl + H 有序列表 Ctrl + O 无...
设计模式——（装饰者模式）（组合模式）
qq_45688193的博客
07-29 384
1.先写Drink主类，里面写入描述和价格的参数，并get/set，并写入一个抽象方法cost(),谁继承谁实现。有个咖啡店里面有各种咖啡和调料，让他们组合会非常麻烦，这时候出现了装饰者模式，咖啡作为主体，调料作为包装。创建学校类，继承刚才的组织类，创建一个数组用来存放院系，重写add，remove方法。先创建一个组织类，用来对学校，院系，专业的描述，让他们分别继承这个组织类。创建专业类，因为他是叶子节点，所以不用创建数组存放。创建一个院系类，创建一个数组用来存放专业类。2.创建咖啡类继承Drink。...
设计模式--03--创建型--02--工厂模式
na_tion的专栏
04-14 218
在篇介绍三种工厂的使用 简单工厂模式（不属于GOF的23种经典设计模式，实际开发中经常使用，故也作介绍） 工厂方法模式 抽象工厂模式 工厂模式最大的优点是解耦 以案例引入工厂模式--设计一个咖啡店点餐系统 设计一个咖啡类（Coffee），并定义其两个子类（美式咖啡【AmericanCoffee】和拿铁咖啡【LatteCoffee】）；再设计一个咖啡店类（CoffeeStore），咖啡店具有点咖啡的功能。 一、传统方式设计 源码地址：https://gitee.com/na-tion/d
设计模式之工厂方法模式
zoezhi的博客
04-13 366
工厂方法模式实验（2学时） 实验目的 理解简单工厂、工厂方法模式的概念 掌握工厂方法模式的用法 实验工具 计算机，安装JDK vscode或Eclipse 实验题目 参考给定制作咖啡的简单工厂例子，将其改成工厂方法模式实现 实验步骤 保留例子中的Coffee抽象类、LatteCoffee和EspressoCoffee类不变； 将原来的CoffeeStore变成抽象类，并去掉其中的SimpleCoffeeFactory相关信息，加入抽象的工厂方法用于构造各种咖啡： protected ab
设计模式-02简单工厂模式
Mrrr_Li的博客
02-08 117
简单工厂模式
装饰器模式实现咖啡店（Java代码实例）
米莱虾
09-29 1887
装饰器模式 装饰器模式是为了运行时动态的扩展一个类的功能。它谨循开闭原则，它实现的关键是继承和组合的结合使用，解耦对象之间的关系。装饰器模式充分展示了组合的灵活。利用它来实现扩展。它同时也是开闭原则的体现。 如果对某个类实现运行时功能动态的扩展， 这个时候就可以考虑使用装饰器模式。 应用场景 有一个咖啡店，销售各种各样的咖啡，拿铁，卡布奇洛，蓝山咖啡等，在冲泡前，会询问顾客是否要加糖，加奶，加薄荷等。这样不同的咖啡配上不同的调料就会卖出不同的价格。采用装饰器模式实现以下要求： （1）实现给出装饰器模
2.5万字详解23种设计模式—创建型模式（简单工厂、工厂方法、抽象工厂、单例-多线程安全详解、建造者、原型）的详细解读、UML类图
qc
05-05 497
2.5万字详解23种设计模式—创建型模式（简单工厂、工厂方法、抽象工厂、单例-多线程安全详解、建造者、原型）的详细解读、UML类图
spring用的是哪种工厂模式_【设计模式总结】对常用设计模式的一些思考（未完待续。。。）...
weixin_39828960的博客
12-14 78
设计模式用不用？如何用？标题是两个问题：1、什么情况下使用设计模式？2、使用哪种设计模式？首先回答一下对于第一个问题我的个人理解：对于代码来说，即使完全不使用设计模式，也是可以将整个流程写出来，将整个功能实现出来。使用设计模式的内因，主要来源于开发者对于设计模式本身的理解，因此谈论这个问题，首先要自问：我了解或者说熟悉几种设计模式？毕竟，懂都不懂，如何使用设计模式？使用设计模式的外因，主要来源于开...
C++ 设计模式之工厂模式怎么实现
最新发布
05-16
工厂模式是一种常见的创建型设计模式，用于创建对象，而不是通过直接调用构造函数来创建它们。工厂模式定义了一个接口，用于创建相关对象，但是让子类决定要实例化的类。在C++中，工厂模式可以通过以下步骤实现： 1...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值