23种设计模式之简单工厂模式，工厂方法模式，抽象工厂模式详解

最新推荐文章于 2024-07-31 12:38:20 发布
最新推荐文章于 2024-07-31 12:38:20 发布
阅读量132 收藏
点赞数
分类专栏： 面试 java 设计模式 文章标签： 设计模式 工厂方法模式 抽象工厂模式 java 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42620326/article/details/119268737
版权
面试 同时被 3 个专栏收录
56 篇文章 2 订阅
订阅专栏
java
33 篇文章 0 订阅
订阅专栏
设计模式
8 篇文章 0 订阅
订阅专栏

工厂模式详解

1. 简单工厂模式

1.1 需求分析

看一个披萨的项目：要便于披萨种类的扩展，要便于维护。

  1. 披萨的种类很多，比如GreekPizz，CheesePizz等
  2. 披萨的制作工序有prepare，bake，cut，box
  3. 完成披萨店订购功能

1.2 使用传统方式实现

1.2.1 类图

在这里插入图片描述

1.2.2 代码实现

1.2.2.1 新建pizza抽象类
package factory.simplefactory.pizzastore.pizza;

/**
 * @author LongXi
 * @create 2021-07-31 8:47
 */
//将Pizza做成抽象类
public abstract class Pizza {
    //名字
    protected String name;
    //准备原材料，不同的披萨不一样，因此我们做成抽象方法
    public abstract void prepare();
    //烘烤
    public void bake(){
        System.out.println(name + " baking;");
    }
    public void cut(){
        System.out.println(name + " cutting;");
    }
    public void box(){
        System.out.println(name + " boxing;");
    }
    public void setName(String name){
        this.name = name;
    }

}
1.2.2.2 希腊披萨实现类
package factory.simplefactory.pizzastore.pizza;

/**
 * @author LongXi
 * @create 2021-07-31 8:52
 */
public class GreekPizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("给制作希腊披萨，准备原材料");
    }
}
1.2.2.3 奶酪披萨实现类
package factory.simplefactory.pizzastore.pizza;

/**
 * @author LongXi
 * @create 2021-07-31 8:52
 */
public class CheesePizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("给制作奶酪披萨，准备原材料");
    }
}
1.2.2.4 订购披萨类
package factory.simplefactory.pizzastore.order;

import factory.simplefactory.pizzastore.pizza.CheesePizza;
import factory.simplefactory.pizzastore.pizza.GreekPizza;
import factory.simplefactory.pizzastore.pizza.Pizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @author LongXi
 * @create 2021-07-31 8:55
 */
public class OrderPizza {
    public OrderPizza() {
        Pizza pizza = null;
        String orderType;//订购披萨类型
        do {
            orderType = getType();
            if (orderType.equals("greek")){
                pizza = new GreekPizza();
                pizza.setName("希腊披萨");
            }else if(orderType.equals("cheese")){
                pizza = new CheesePizza();
                pizza.setName("奶酪披萨");
            } else {
                break;
            }
            //输出披萨制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }while(true);
    }

    //加一个方法，可以获取客户希望订购的披萨种类
    private String getType(){
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入要订购的pizza种类：");
            String str = null;
            str = br.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}
1.2.2.5 披萨商店类
package factory.simplefactory.pizzastore.order;

/**
 * @author LongXi
 * @create 2021-07-31 9:08
 */
public class pizzaStore {
    public static void main(String[] args) {
        new OrderPizza();
    }
}
1.2.2.5 运行结果
请输入要订购的pizza种类：
greek
给制作希腊披萨，准备原材料
希腊披萨 baking;
希腊披萨 cutting;
希腊披萨 boxing;
请输入要订购的pizza种类：
cheese
给制作奶酪披萨，准备原材料
奶酪披萨 baking;
奶酪披萨 cutting;
奶酪披萨 boxing;
请输入要订购的pizza种类：
lol

Process finished with exit code 0

1.2.3 传统方式优缺点分析

  1. 优点：比较好理解，简单易操作
  2. 缺点：违反了设计模式的OCP原则，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码。

假如我们现在增加一个新的种类披萨：胡椒披萨

胡椒披萨实现类

package factory.simplefactory.pizzastore.pizza;

/**
 * @author LongXi
 * @create 2021-07-31 12:11
 */
public class PepperPizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("给制作胡椒披萨，准备原材料");
    }
}

订购披萨类也需要响应的更改，加入胡椒披萨判断分支

    public OrderPizza() {
        Pizza pizza = null;
        String orderType;//订购披萨类型
        do {
            orderType = getType();
            if (orderType.equals("greek")){
                pizza = new GreekPizza();
                pizza.setName("希腊披萨");
            }else if(orderType.equals("cheese")){
                pizza = new CheesePizza();
                pizza.setName("奶酪披萨");
            } else if(orderType.equals("pepper")){
                pizza = new PepperPizza();
                pizza.setName("胡椒披萨");
                break;
            }
            //输出披萨制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }while(true);
    }

执行结果

请输入要订购的pizza种类：
pepper
给制作胡椒披萨，准备原材料
胡椒披萨 baking;
胡椒披萨 cutting;
胡椒披萨 boxing;
请输入要订购的pizza种类：

1.3 改进思路

分析：修改代码可以接受，但是如果我们在其他的地方也有创建Pizza的代码，就意味着，也需要修改，而创建Pizza的代码，往往有多处。
思路：把创建Pizza对象封装到一个类张，这样我们有新的Pizza种类是，只需要修改该类就可，其他有创建到Pizza对象的代码就不需要修改了，这就是简单工厂模式。

1.4 什么是简单工厂模式

  1. 简单工厂模式是属于创建型模式，是工厂模式的一种。**简单工厂模式是又一个工厂对象决定创建出哪一种产品类的实例。**简单工厂模式是工厂模式家族中最简单实用的模式。
  2. 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为（代码）
  3. 在软件开发中，当我们会用到大量的创建某种，某类或者某批对象时，就会使用到工厂模式。

类图：
在这里插入图片描述

1.4.1 新建一个简单工厂类，用于生成pizza

package factory.simplefactory.pizzastore.order;

import factory.simplefactory.pizzastore.pizza.CheesePizza;
import factory.simplefactory.pizzastore.pizza.GreekPizza;
import factory.simplefactory.pizzastore.pizza.PepperPizza;
import factory.simplefactory.pizzastore.pizza.Pizza;

/**
 * @author LongXi
 * @create 2021-07-31 12:29
 */
//简单工厂模式
public class SimpleFactory {
    //根据OrderType返回Pizza对象
    public Pizza createPizza(String orderType){
        Pizza pizza = null;
        System.out.println("使用简单工厂模式");
        if (orderType.equals("greek")){
            pizza = new GreekPizza();
            pizza.setName("希腊披萨");
        }else if(orderType.equals("cheese")){
            pizza = new CheesePizza();
            pizza.setName("奶酪披萨");
        } else if(orderType.equals("pepper")){
            pizza = new PepperPizza();
            pizza.setName("胡椒披萨");
        }
        return pizza;
    }
}

1.4.2 修改订购披萨类

package factory.simplefactory.pizzastore.order;

import factory.simplefactory.pizzastore.pizza.Pizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @author LongXi
 * @create 2021-07-31 8:55
 */
public class OrderPizza {
   /* public OrderPizza() {
        Pizza pizza = null;
        String orderType;//订购披萨类型
        do {
            orderType = getType();
            if (orderType.equals("greek")){
                pizza = new GreekPizza();
                pizza.setName("希腊披萨");
            }else if(orderType.equals("cheese")){
                pizza = new CheesePizza();
                pizza.setName("奶酪披萨");
            } else if(orderType.equals("pepper")){
                pizza = new PepperPizza();
                pizza.setName("胡椒披萨");
            } else {
                break;
            }
            //输出披萨制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }while(true);
    }

    */

    public  OrderPizza (SimpleFactory factory){
        this.setSimpleFactory(factory);
    }
    //定义一个简单工厂对象
    SimpleFactory simpleFactory;

    Pizza pizza = null;
    public void setSimpleFactory(SimpleFactory simpleFactory) {
        this.simpleFactory = simpleFactory;

        do {
            pizza = this.simpleFactory.createPizza(this.getType());
            if (pizza != null){
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("对不起，没有该种类的披萨，订购披萨失败");
                break;
            }
        }while(true);

    }

    //加一个方法，可以获取客户希望订购的披萨种类
    private String getType(){
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入要订购的pizza种类：");
            String str = null;
            str = br.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

1.4.3 修改披萨商店类

package factory.simplefactory.pizzastore.order;

/**
 * @author LongXi
 * @create 2021-07-31 9:08
 */
public class pizzaStore {
    public static void main(String[] args) {
        //new OrderPizza();
        new OrderPizza(new SimpleFactory());
        System.out.println("退出程序");
    }
}

这样我们就完成了改进，如果再追加一种披萨，我们只需要更改简单工厂类就可以了，而不用去更改订购披萨的类。

1.5 简单工厂又叫静态工厂

2. 工厂方法模式

2.1 需求分析

披萨项目的新需求：客户在点披萨时，可以点不同口味的披萨，比如：北京的奶酪披萨，北京的胡椒披萨或者是伦敦的奶酪披萨，伦敦的胡椒披萨。

2.1.1 思路1：使用简单工厂模式

创建不用的简单工厂类，比如BJPizzaSimpleFactory， LDPizzaSimpleFactory等等，从当前这个案例来说，也是可以的。
但是考虑到项目的规模，以及软件的可维护性、可扩展性并不是特别好。

2.1.2 思路2：使用工厂方法模式

2.2 什么是工厂方法模式？

定义了一个创建对象的抽象方法，由子类决定要实例化的类。
工厂方法模式的核心思想是：将对象的实例化推迟到子类。

2.2.1 工厂方法模式设计方案

将披萨项目的实例化功能抽象成抽象方法，在不同口类点餐子类中具体实现。

2.3 代码实现

2.3.1 类图

在这里插入图片描述

2.3.2 上代码

2.3.2.1 披萨类
package factory.factoryMethod.pizzastore.pizza;

/**
 * @author LongXi
 * @create 2021-07-31 8:47
 */
//将Pizza做成抽象类
public abstract class Pizza {
    //名字
    protected String name;
    //准备原材料，不同的披萨不一样，因此我们做成抽象方法
    public abstract void prepare();
    //烘烤
    public void bake(){
        System.out.println(name + " baking;");
    }
    public void cut(){
        System.out.println(name + " cutting;");
    }
    public void box(){
        System.out.println(name + " boxing;");
    }
    public void setName(String name){
        this.name = name;
    }

}
2.3.2.2 四个实现类
/**
 * @author LongXi
 * @create 2021-07-31 13:15
 */
public class BJCheesePizza extends Pizza{

    @Override
    public void prepare() {
        setName("北京奶酪披萨");
        System.out.println("北京奶酪披萨 准备原材料");
    }
}

/**
 * @author LongXi
 * @create 2021-07-31 13:15
 */
public class BJPepperPizza extends Pizza{

    @Override
    public void prepare() {
        setName("北京胡椒披萨");
        System.out.println("北京胡椒披萨 准备原材料");
    }
}

/**
 * @author LongXi
 * @create 2021-07-31 13:15
 */
public class LDCheesePizza extends Pizza{

    @Override
    public void prepare() {
        setName("伦敦奶酪披萨");
        System.out.println("伦敦奶酪披萨 准备原材料");
    }
}


/**
 * @author LongXi
 * @create 2021-07-31 13:15
 */
public class LDPepperPizza extends Pizza{

    @Override
    public void prepare() {
        setName("伦敦胡椒披萨");
        System.out.println("伦敦胡椒披萨 准备原材料");
    }
}
2.3.2.3 订购披萨父类
package factory.factoryMethod.pizzastore.order;

import factory.factoryMethod.pizzastore.pizza.Pizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @author LongXi
 * @create 2021-07-31 8:55
 */
public abstract class OrderPizza {
    //定义一个抽象方法，cteatePizza
    abstract Pizza cteatePizza (String orderType);

    public OrderPizza() {
        Pizza pizza = null;
        String orderType = null;//订购披萨类型
        do {
            orderType = getType();
            //抽象方法，由工厂子类完成
            pizza = this.cteatePizza(orderType);
            //输出披萨制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }while(true);
    }




    //加一个方法，可以获取客户希望订购的披萨种类
    private String getType(){
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入要订购的pizza种类：");
            String str = null;
            str = br.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}
2.3.2.3 两个实现类
/**
 * @author LongXi
 * @create 2021-07-31 13:27
 */
public class BJOrderPizza extends OrderPizza{
    @Override
    Pizza cteatePizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")){
            pizza = new BJCheesePizza();
        } else if (orderType.equals("pepper")){
            pizza = new BJPepperPizza();
        }
        return pizza;
    }
}



/**
 * @author LongXi
 * @create 2021-07-31 13:27
 */
public class LDOrderPizza extends OrderPizza{
    @Override
    Pizza cteatePizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")){
            pizza = new LDCheesePizza();
        } else if (orderType.equals("pepper")){
            pizza = new LDPepperPizza();
        }
        return pizza;
    }
}
2.3.2.4 披萨商店类，主类
/**
 * @author LongXi
 * @create 2021-07-31 13:32
 */
public class PizzaStore {
    public static void main(String[] args) {
        String local = "BJ";
        if (local.equals("BJ")){
            // 创建北京口味的各种pizza
            new BJOrderPizza();
        }else {
            //创建伦敦口味的各种pizza
            new LDOrderPizza();
        }

    }
}
2.3.2.5 运行结果
请输入要订购的pizza种类：
pepper
北京胡椒披萨 准备原材料
北京胡椒披萨 baking;
北京胡椒披萨 cutting;
北京胡椒披萨 boxing;
请输入要订购的pizza种类：
cheese
北京奶酪披萨 准备原材料
北京奶酪披萨 baking;
北京奶酪披萨 cutting;
北京奶酪披萨 boxing;
请输入要订购的pizza种类：

3. 抽象工厂模式

3.1 什么是抽象工厂模式

  1. 抽象工厂模式：定义了一个interface用于创建相关或有依赖的对象簇，而无需指明具体的类
  2. 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合
  3. 从设计层面看，抽象工厂模式就是对简单工厂模式的改进（或者称为进一步的抽象）
  4. 将工厂抽象成两次，AbsFactors（抽象工厂）和具体实现的工厂子类。程序与可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。
    TIPS：
    在这里插入图片描述

3.2 类图

在这里插入图片描述

3.3 代码实现

3.3.1 披萨类

package factory.factoryMethod.pizzastore.pizza;

/**
 * @author LongXi
 * @create 2021-07-31 8:47
 */
//将Pizza做成抽象类
public abstract class Pizza {
    //名字
    protected String name;
    //准备原材料，不同的披萨不一样，因此我们做成抽象方法
    public abstract void prepare();
    //烘烤
    public void bake(){
        System.out.println(name + " baking;");
    }
    public void cut(){
        System.out.println(name + " cutting;");
    }
    public void box(){
        System.out.println(name + " boxing;");
    }
    public void setName(String name){
        this.name = name;
    }

}

3.3.2 4个实现类

/**
 * @author LongXi
 * @create 2021-07-31 13:15
 */
public class BJCheesePizza extends Pizza{

    @Override
    public void prepare() {
        setName("北京奶酪披萨");
        System.out.println("北京奶酪披萨 准备原材料");
    }
}

/**
 * @author LongXi
 * @create 2021-07-31 13:15
 */
public class BJPepperPizza extends Pizza{

    @Override
    public void prepare() {
        setName("北京胡椒披萨");
        System.out.println("北京胡椒披萨 准备原材料");
    }
}

/**
 * @author LongXi
 * @create 2021-07-31 13:15
 */
public class LDCheesePizza extends Pizza{

    @Override
    public void prepare() {
        setName("伦敦奶酪披萨");
        System.out.println("伦敦奶酪披萨 准备原材料");
    }
}


/**
 * @author LongXi
 * @create 2021-07-31 13:15
 */
public class LDPepperPizza extends Pizza{

    @Override
    public void prepare() {
        setName("伦敦胡椒披萨");
        System.out.println("伦敦胡椒披萨 准备原材料");
    }
}

3.3.3 抽象工厂接口

/**
 * @author LongXi
 * @create 2021-07-31 14:21
 */
//一个抽象工厂模式的抽象层(接口)
public interface AbsFactory {
    //让下面的工厂子类来具体实现
    public Pizza cteatePizza (String orderType);
}

3.3.4 两个重新工厂的实现类

/**
 * @author LongXi
 * @create 2021-07-31 14:23
 */
//这是一个工厂子类
public class BJFactory implements AbsFactory{

    @Override
    public Pizza cteatePizza(String orderType) {
        System.out.println("使用的抽象工厂模式");
        Pizza pizza = null;
        if (orderType.equals("cheese")){
            pizza = new BJCheesePizza();
        } else if (orderType.equals("pepper")){
            pizza = new BJPepperPizza();
        }
        return pizza;
    }
}


/**
 * @author LongXi
 * @create 2021-07-31 14:23
 */
//这是一个工厂子类
public class LDFactory implements AbsFactory{

    @Override
    public Pizza cteatePizza(String orderType) {
        System.out.println("使用的抽象工厂模式");
        Pizza pizza = null;
        if (orderType.equals("cheese")){
            pizza = new LDCheesePizza();
        } else if (orderType.equals("pepper")){
            pizza = new LDPepperPizza();
        }
        return pizza;
    }
}

3.3.5 订购披萨类

/**
 * @author LongXi
 * @create 2021-07-31 14:27
 */
public class OrderPizza {
    public OrderPizza(AbsFactory absFactory){
        setFactory(absFactory);
    }

    AbsFactory factory;
    private void setFactory(AbsFactory factory){
        Pizza pizza = null;
        String orderType = "";
        this.factory = factory;
        do{
            orderType = getType();
            pizza = this.factory.cteatePizza(orderType);
            if (pizza != null){
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }else {
                System.out.println("订购失败");
                break;
            }
        }while(true);
    }
    //加一个方法，可以获取客户希望订购的披萨种类
    private String getType(){
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入要订购的pizza种类：");
            String str = null;
            str = br.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

3.3.6 披萨商店类

/**
 * @author LongXi
 * @create 2021-07-31 14:35
 */
public class PizzaStore {
    public static void main(String[] args) {
        new OrderPizza(new BJFactory());
        new OrderPizza(new LDFactory());
    }
}

3.3.7 运行结果

请输入要订购的pizza种类：
cheese
使用的抽象工厂模式
北京奶酪披萨 准备原材料
北京奶酪披萨 baking;
北京奶酪披萨 cutting;
北京奶酪披萨 boxing;
请输入要订购的pizza种类：
pepper
使用的抽象工厂模式
北京胡椒披萨 准备原材料
北京胡椒披萨 baking;
北京胡椒披萨 cutting;
北京胡椒披萨 boxing;
请输入要订购的pizza种类：
chian
使用的抽象工厂模式
订购失败

4. 工厂模式JDK里的使用

日期类：Calendar

/**
 * @author LongXi
 * @create 2021-07-31 14:47
 */
public class TestCalendar {
    public static void main(String[] args) {

        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.get(Calendar.YEAR));
    }
}

DEBUG看核心代码:

    public static Calendar getInstance()
    {
        return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT));
    }

    private static Calendar createCalendar(TimeZone zone,
                                           Locale aLocale)
    {
        CalendarProvider provider =
            LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
                                 .getCalendarProvider();
        if (provider != null) {
            try {
                return provider.getInstance(zone, aLocale);
            } catch (IllegalArgumentException iae) {
                // fall back to the default instantiation
            }
        }

        Calendar cal = null;

        if (aLocale.hasExtensions()) {
            String caltype = aLocale.getUnicodeLocaleType("ca");
            if (caltype != null) {
                switch (caltype) {
                case "buddhist":
                cal = new BuddhistCalendar(zone, aLocale);
                    break;
                case "japanese":
                    cal = new JapaneseImperialCalendar(zone, aLocale);
                    break;
                case "gregory":
                    cal = new GregorianCalendar(zone, aLocale);
                    break;
                }
            }
        }
        if (cal == null) {
            // If no known calendar type is explicitly specified,
            // perform the traditional way to create a Calendar:
            // create a BuddhistCalendar for th_TH locale,
            // a JapaneseImperialCalendar for ja_JP_JP locale, or
            // a GregorianCalendar for any other locales.
            // NOTE: The language, country and variant strings are interned.
            if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
                cal = new BuddhistCalendar(zone, aLocale);
            } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
                       && aLocale.getCountry() == "JP") {
                cal = new JapaneseImperialCalendar(zone, aLocale);
            } else {
                cal = new GregorianCalendar(zone, aLocale);
            }
        }
        return cal;
    }

5. 工厂模式小结

  1. 工厂模式的意义
    将实例化对象的代码提取出来，放到一个类中，统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。
  2. 三种工厂模式
  3. 设计模式的依赖抽象原则
  • 创建对象实例，不要直接new类，而是把这个new类的动作放到一个工厂的方法中，并返回。有的书上说，变量不要直接持有具体类的引用。
  • 不要让类继承具体类，而是继承抽象类或者是实现interface(接口)
  • 不要覆盖基类中已经实现的方法。
23种设计模式之抽象工厂模式Java示例代码
04-16
### 23种设计模式之抽象工厂模式Java示例代码详解 #### 概述 抽象工厂模式（Abstract Factory Pattern）是面向对象设计模式中的一个重要成员，属于创建型模式的一种。它提供了一种创建一系列相关或相互依赖对象的...
Java设计模式之抽象工厂模式实例详解
08-29
Java设计模式之抽象工厂模式实例详解 Java设计模式之抽象工厂模式实例详解是指在软件设计中，通过提供一个创建一系列相关或相互依赖对象的接口，且无需指定它们具体的类别的方式来生成这些对象的模式。抽象工厂模式...
设计思想学习—抽象工厂模式
Atptro的博客
12-22 415
抽象工厂模式 抽象工厂模式（Abstract Factory）:为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。 抽象工厂模式组成 抽象工厂（Creator）角色：这是工厂方法模式的核心，定义了创建产品的方法。与应用系统无关。具体工厂角色必须实现这个接口才能创建对象。 具体工厂（Concrete Creator）角色：实现了抽象工厂角色的接口，含有与应用密切相关的逻辑，并且
04. 23种经典设计模式-14-抽象工厂模式
Java 程序源
08-27 212
1. 抽象工厂模式(Abstract Factory Pattern) Provie an interface for creating families of related or dependent objects without specifying theiur concrete classes. （为创建一组相关或相互依赖的对象提供一个接口, 而无须指定它们的实现类) 1.1 抽象工...
抽象工厂模式(JAVA反射)
dielu7895的博客
01-11 332
实例代码(JAVA):模式动机 在工厂方法模式中具体工厂负责生产具体的产品，每一个具体工厂对应一种具体产品，工厂方法也具有唯一性，一般情况下，一个具体工厂中只有一个工厂方法或者一组重载的工厂方法。但是有时候我们需要一个工厂可以提供多个产品对象，而不是单一的产品对象。 为了更清晰地理解工厂方法模式，需要先引入两个概念： •产品等级结构：产品等级结构即产品的继...
Java设计模式之创建型：工厂模式详解（简单工厂+工厂方法+抽象工厂）
张维鹏的博客
09-13 8万+
工厂模式将目的将创建对象的具体过程屏蔽隔离起来，从而达到更高的灵活性，工厂模式可以分为三类：简单工厂模式、工厂方法模式、抽象工厂模式；简单工厂模式的核心是定义一个创建对象的接口，将对象的创建和本身的业务逻辑分离。工厂方法模式将工厂抽象化，并定义一个创建对象的接口。每增加新产品，只需增加该产品以及对应的具体实现工厂类，由具体工厂类决定要实例化的产品是哪个，将对象的创建与实例化延迟到子类。抽象工厂模式用于创建相关对象的家族。当一个产品族中需要被设计在一起工作时，通过抽象工厂模式，保证客户端始终只使用同一个产品族
23 种设计模式详解（全23种）
热门推荐
人生智慧的博客
06-09 49万+
设计模式的分类 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 A、创建...
Java工厂模式详解：方法工厂模式与抽象工厂模式
2401_83447580的博客
07-28 1361
方法工厂模式（Factory Method Pattern）是一种创建型设计模式，它定义了一个用于创建对象的接口，但让子类决定要实例化的类是哪一个。工厂方法让类的实例化推迟到子类中进行。抽象工厂模式（Abstract Factory Pattern）提供了一种创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。方法工厂模式和抽象工厂模式都是用于创建对象的设计模式，但它们的应用场景和侧重点不同。方法工厂模式侧重于单个对象的创建，通过子类决定实例化哪个类；
Java设计模式之四：抽象工厂模式详细解析
Simon学Java
02-16 1666
抽象工厂模式是一种创建类模式，它提供了一种封装一组具有共同主题的单个工厂的方法。在抽象工厂模式中，客户端不需要知道实例是如何创建的，只需知道工厂的名字即可。这种模式可用于将一组具有共同主题的工厂对象的创建过程与他们的实际使用过程分离。抽象工厂模式（Abstract Factory Pattern）定义：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂模式是工厂方法模式的升级，它提供了一种接口，用于创建一系列相关的或相互依赖的对象，而不需要指定它们的具体类。
【设计模式】抽象工厂模式详解
一个只有绵薄之力的老年人
03-25 571
是一种为访问类提供一个创建一族相关或者相互依赖对象的接口，且访问类无须指定所要产品的具体类就可以得到同一族的不同等级的产品模式结构。抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可以生产多个等级的产品。当一个产品族中的多个对象被设计成一起工作时，可以保证客户端始终只使用同一产品族中的对象。当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。
设计模式详解：抽象工厂模式
乱世刀疤
10-09 1539
抽象工厂模式，使用率非常高的模式之一。
Java 设计模式-抽象工厂模式
最新发布
精神小牛马
07-31 1045
抽象工厂模式为一个产品家族提供了统一的创建接口。当需要这个产品家族的某一系列的时候，可以从抽象工厂中选出相对应的系列来创建一个具体的工厂类别。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式
Python设计模式之抽象工厂模式原理与用法详解
01-20
本文实例讲述了Python设计模式之抽象工厂模式原理与用法。分享给大家供大家参考，具体如下： 抽象工厂模式(Abstract Factory Pattern):提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的类 下面是一个...
Android编程设计模式之抽象工厂模式详解
08-28
其中，抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它允许创建一系列相关或相互依赖的对象，而不必指定它们的具体类。 **一、抽象工厂模式概念** 抽象工厂模式的核心思想在于提供一个抽象接口...
SpringCloud高频重点面试题，看这一篇就够了。
龙兮
07-28 3678
文章目录Eureka服务注册与发现1 Eureka基础知识1.1 什么是服务治理1.2 什么是服务注册与发现1.3 Eureka包含两个组件：Eureka Server 和 Eureka Client1.4 单机Eureka构建步骤1.4.1 服务端1.4.2 客户端1.4.3 将Eureka Client端中的服务消费端注册进Eureka Server称为Service Consumer1.5 集群Eureka构建步骤1.6 负载均衡1.7 Eureka自我保护（CAP里面的AP分支）1.7.1 产生原因
快速入门RabbitMq，看这一篇就够了。
龙兮
12-26 2049
RabbitMq3. RabbitMq之Hello World3.1 创建开发环境，添加maven依赖3.2 流程图3.3 生产者代码3.4 消费者代码3.5 测试用例4. 工作队列4.1 什么是工作队列？4.2 用代码实现工作队列4.2.1 抽取连接工程工具类4.2.2 消费者代码4.2.3 生产者代码4.2.4 测试，发送消息 3. RabbitMq之Hello World 3.1 创建开发环境，添加maven依赖 pom.xml <build> <plugin
Docker高级篇之可视化工具Portainer和CAdvisor+InfluxDB+Granfana
龙兮
07-24 1652
Docker高级篇之可视化工具Portainer和CAdvisor+InfluxDB+Granfana
Docker高级篇之Mysql主从复制、Redis集群扩容缩容配置案例详解
龙兮
07-08 1566
Docker高级篇之Mysql主从复制、Redis集群扩容缩容配置案例
Java高频重点面试题，看这一篇就够了。
龙兮
07-16 1499
1.==和equals区别？ 1）对于==，比较的是值是否相等 如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等； 如果作用于引用类型的变量，则比较的是所指向的对象的地址 2）对于equals方法，注意：equals方法不能作用于基本数据类型的变量，所有类从Object类中继承equals方法，比较的是是否是同一个对象 　　如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址； 　　诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

东北亚大中华区首席搬砖工具人

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值