23种设计模式--简单工厂模式、工厂方法模式、抽象工厂模式

Mr_凡夫沒有俗子

已于 2022-10-19 22:16:54 修改

阅读量301

点赞数

分类专栏： 23种设计模式文章标签：设计模式简单工厂模式工厂方法模式抽象工厂模式

于 2022-10-19 22:12:34 首次发布

本文链接：https://blog.csdn.net/dujiesheng/article/details/127415850

版权

23种设计模式专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1、简单工厂模式

1.1、介绍

简单工厂模式属于创建型模式，是工厂模式的一中，简单工厂模式是由一个工厂决定出创建哪一种产品的实例，简单工厂在工厂模式中最简单，也是最实用的模式。
在软件实际开发中，我们用到大量创建某种，某类或者某批对象时，就会用到简单工厂模式。

1.2、UML类图

1.3、代码示例

角色

抽象产品：定义了产品的规范，描述了产品的主要特性和功能。
具体产品：实现或者继承抽象产品的子类
具体工厂：提供了创建产品的方法，调用者通过该方法来获取产品。

定义咖啡抽象类

/**
 * 抽象产品：定义一个咖啡抽象类
 */
public abstract class Coffee {

    //定义一个抽象获取咖啡名字的方法
    public abstract String getName();

}

定义咖啡具体实现类

/**
 * 具体产品：咖啡具体实现类
 */
public class AmericanCoffee extends Coffee {

    @Override
    public String getName() {
        return "美式咖啡";
    }

}

/**
 * 具体产品：拿铁咖啡实现类
 */
public class LatteCoffee extends Coffee {

    @Override
    public String getName() {
        return "拿铁咖啡";
    }

}

定义咖啡工厂类

/**
 * 具体工厂：咖啡工厂
 */
public class CoffeeFactory {

    /**
     * 获取咖啡的方法，按照不同类型，创建不同的咖啡
     *
     * @param type 类型
     * @return 返回咖啡具体实现类
     */
    public static Coffee getCoffee(String type) {
        Coffee coffee = null;
        if (type.equals("american")) {
            coffee = new AmericanCoffee();
        } else if (type.equals("latte")) {
            coffee = new LatteCoffee();
        } else {
            throw new RuntimeException("没有这种咖啡");
        }
        return coffee;
    }

}

提供者

/**
 * 提供者
 */
public class CoffeeStore {

    public Coffee orderCoffee(String type) {
        return CoffeeFactory.getCoffee(type);
    }

}

测试类

/**
 * 测试类
 */
public class Test {

    public static void main(String[] args) {
        //实例化咖啡Store
        CoffeeStore coffeeStore = new CoffeeStore();
        //获取拿铁咖啡
        Coffee latte = coffeeStore.orderCoffee("latte");
        //打印名称
        System.out.println(latte.getName());
    }

}

2、工厂方法模式

2.1、介绍

定义一个创建对象的接口，让子类决定去实例化哪个对象，工厂方法模式使一个类的实例化过程延迟到其他工厂的子类。

2.2、UML类图

2.3、代码示例

角色

抽象工厂：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品。
具体工厂：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
抽象产品：定义了产品的规范，描述了产品的主要特性和功能。
具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

抽象产品

/**
 * 抽象产品：定义一个咖啡抽象类
 */
public abstract class Coffee {

    //定义一个抽象获取咖啡名字的方法
    public abstract String getName();

}

具体产品

/**
 * 具体产品：咖啡具体实现类
 */
public class AmericanCoffee extends Coffee {

    @Override
    public String getName() {
        return "美式咖啡";
    }

}

/**
 * 具体产品：拿铁咖啡实现类
 */
public class LatteCoffee extends Coffee {

    @Override
    public String getName() {
        return "拿铁咖啡";
    }

}

抽象工厂

/**
 * 抽象工厂
 */
public interface CoffeeFactory {

    //声明一个创建咖啡的方法
    Coffee createCoffee();

}

具体工厂

/**
 * 具体工厂：美式咖啡工厂
 */
public class AmericanCoffeeFactory implements CoffeeFactory {

    @Override
    public Coffee createCoffee() {
        return new AmericanCoffee();
    }

}

/**
 * 具体工厂：拿铁咖啡工厂
 */
public class LatteCoffeeFactory implements CoffeeFactory {

    @Override
    public Coffee createCoffee() {
        return new LatteCoffee();
    }

}

提供者

/**
 * 提供者：咖啡Store
 */
public class CoffeeStore {

    //咖啡工厂
    private CoffeeFactory factory;

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

    //创建咖啡，由子类工厂决定
    public Coffee orderCoffee() {
        return factory.createCoffee();
    }
    
}

测试类

/**
 * 测试类
 */
public class Test {

    public static void main(String[] args) {
        //声明工厂为美式咖啡生产工厂
        CoffeeFactory coffeeFactory = new AmericanCoffeeFactory();
        //创建咖啡Store
        CoffeeStore coffeeStore = new CoffeeStore();
        //设置工厂
        coffeeStore.setFactory(coffeeFactory);
        //调用生产方法
        Coffee coffee = coffeeFactory.createCoffee();
        //打印咖啡名称
        System.out.println(coffee.getName());
    }

}

3、抽象工厂模式

3.1、介绍

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

3.2、UML类图

3.3、代码示例

角色

抽象工厂：提供了创建产品的接口，它包含多个创建产品的方法，可以创建多个不同等级的产品。
具体工厂：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
抽象产品：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

抽象产品-咖啡

/**
 * 抽象产品：定义一个咖啡抽象类
 */
public abstract class Coffee {

    //定义一个抽象获取咖啡名字的方法
    public abstract String getName();

}

具体产品咖啡实现类

/**
 * 具体产品：咖啡具体实现类
 */
public class AmericanCoffee extends Coffee {

    @Override
    public String getName() {
        return "美式咖啡";
    }

}

/**
 * 具体产品：拿铁咖啡实现类
 */
public class LatteCoffee extends Coffee {

    @Override
    public String getName() {
        return "拿铁咖啡";
    }

}

抽象产品-甜点

/**
 * 定义甜点抽象类
 */
public abstract class Dessert {

    //定义show方法
    public abstract String show();

}

具体甜点产品实现类

/**
 * 具体产品
 */
public class Musi extends Dessert {

    @Override
    public String show() {
        return "抹茶慕斯";
    }

}

/**
 * 具体产品
 */
public class Tiramisu extends Dessert {

    @Override
    public String show() {
        return "提拉米苏";
    }

}

定义抽象工厂

/**
 * 定义抽象工厂
 */
public interface Factory {

    //创建咖啡
    Coffee createCoffee();

    //创建甜点
    Dessert createDessert();

}

具体工厂

/**
 * 具体工厂
 */
public class AmericanFactory implements Factory {

    @Override
    public Coffee createCoffee() {
        return new AmericanCoffee();
    }

    @Override
    public Dessert createDessert() {
        return new Musi();
    }

}

/**
 * 具体工厂
 */
public class ItalyFactory implements Factory {

    @Override
    public Coffee createCoffee() {
        return new LatteCoffee();
    }

    @Override
    public Dessert createDessert() {
        return new Tiramisu();
    }

}

测试类

//测试类
public class Test {

    public static void main(String[] args) {
        //创建美式工厂
        Factory factory = new AmericanFactory();
        //创建咖啡
        Coffee coffee = factory.createCoffee();
        //输出姓名
        System.out.println(coffee.getName());
    }

}