4.工厂模式

最新推荐文章于 2023-06-01 18:53:35 发布
最新推荐文章于 2023-06-01 18:53:35 发布
阅读量121 收藏
点赞数 1
分类专栏： java设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46188681/article/details/118520415
版权
本文通过披萨订单系统的实例，详细介绍了简单工厂模式、工厂方法模式和抽象工厂模式的实现及应用场景。从单一的披萨种类扩展到不同地区的多种口味，展示了如何通过工厂模式遵循设计模式的依赖抽象原则，提高代码的扩展性和维护性。同时，以JDK中的Calendar类为例，说明了简单工厂模式在实际库中的运用。
摘要由CSDN通过智能技术生成

简单工厂模式

1.简单工厂模式

简单工厂模式的实际需求

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

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

在这里插入图片描述

  1. Pizza: 抽象父类
/** 将Pizza 做成抽象类
 * @author compass
 * @version 1.0
 * @date 2021-07-06 14:51
 */
public abstract class Pizza {
    protected  String name;

    // 准备披萨 因为不太的披萨会有不同的原材料 所以做成抽象方法
    public abstract void prepare();

    public void bake(){
        System.out.println("开始烘烤");
    }

    public void cut(){
        System.out.println("开始切割");
    }

    public void box(){
        System.out.println("开始包装");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
  1. CheesePizza：奶酪披萨
/** 奶酪披萨
 * @author compass
 * @version 1.0
 * @date 2021-07-06 14:54
 */
public class CheesePizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("选用奶酪披萨原材料");
    }

    @Override
    public void bake() {
       super.bake();
    }

    @Override
    public void cut() {
     super.cut();
    }

    @Override
    public void box() {
      super.box();
    }


}
  1. GreekPizza：希腊披萨
/** 希腊披萨
 * @author compass
 * @version 1.0
 * @date 2021-07-06 14:55
 */
public class GreekPizza  extends Pizza{
    @Override
    public void prepare() {
        System.out.println("选用希腊披萨原材料");
    }

    @Override
    public void bake() {
      super.bake();
    }

    @Override
    public void cut() {
       super.cut();
    }

    @Override
    public void box() {
      super.cut();
    }
}
  1. OrderPizza：表示披萨商店，可以根据用户的输入，制作相应的披萨
/**  披萨商店
 * @author compass
 * @version 1.0
 * @date 2021-07-06 14:57
 */
public class OrderPizza {


   public  OrderPizza( ){
       Pizza pizza=null;
       String orderType=null;
        do {
             orderType=getType();
            if ("greek".equals(orderType)){
                 pizza = new GreekPizza();
            }else if ("cheese".equals(orderType)){
                 pizza = new CheesePizza();
            }else {
                break;
            }
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }while (true);

    }

    private String getType()   {

        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        System.out.println("请输入需要订购的种类:");
        try {
            return br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }

    }
}
  1. PizzaStore：相当于客户端，发出订购披萨的请求
/** 客户端 发出订购任务
 * @author compass
 * @version 1.0
 * @date 2021-07-06 15:12
 */
public class PizzaStore {

    public static void main(String[] args) {
        OrderPizza orderPizza = new OrderPizza();
    }
}

·传统方式的优缺点分析:
·

  • 优点是比较好理解，简单易操作。
  • 缺点是违反了设计模式的ocp原则，即对扩展开放(提供方)，对修改关闭(使用方)。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码.
  • 比如我们这时要新增加一个Pizza的种类(Pepper披萨)，我们需要在使用方 OderPizza 中添加新的判断条件，违反开闭原则

改进思路

  1. 分析： 如果说新增 Pizza 需要修改代码，这可以接受， 但是如果我们在其它的地方也有创建 Pizza 的代码，就意味着，有很多处的代码都需要修改，而且这些创建 Pizza 的代码全都是冗余代码。
  2. 思路： 把创建Pizza对象封装到一个类中，这样我们有新的Pizza种类时，只需要修改该类就可， 其它有创建到Pizza对象的代码就不需要修改了 --> 简单工厂模式

在这里插入图片描述
改进后的简单工厂模式;

Pizza, CheesePizza, GreekPizza：代码不变

SimpleFactory：工厂类，根据用户输入，制作相应的 Pizza，此时 SimpleFactory 为提供方

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-06 16:28
 */
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("奶酪披萨");
        }
        return pizza;
    }


}

OrderPizza :表示披萨商店，可以根据用户的输入，制作相应的披萨

/**  披萨商店
 * @author compass
 * @version 1.0
 * @date 2021-07-06 14:57
 */
public class OrderPizza {

    // 定义一个简单工厂对象
    SimpleFactory simpleFactory;
    Pizza pizza = null;

    // 构造器
    public OrderPizza(SimpleFactory simpleFactory) {
        setFactory(simpleFactory);
    }

    public void setFactory(SimpleFactory simpleFactory) {
        String orderType = ""; // 用户输入的
        this.simpleFactory = simpleFactory; // 设置简单工厂对象
        do {
            orderType = getType();
            pizza = this.simpleFactory.createPizza(orderType);
            // 输出pizza
            if (pizza != null) { // 订购成功
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
                System.out.println();
            } else {
                System.out.println("订购披萨失败");
                break;
            }
        } while (true);
    }

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

}

PizzaStore : 客户端 发出订购任务

/** 客户端 发出订购任务
 * @author compass
 * @version 1.0
 * @date 2021-07-06 15:12
 */
public class PizzaStore {

    public static void main(String[] args) {
        OrderPizza orderPizza = new OrderPizza(new SimpleFactory());
    }
}

两者做比较：

在这里插入图片描述
还有一种静态简单工厂模式：也就是将 createPizza(String orderType)方法改为静态的即可，其他的地方做相应的修改即可

2.工厂方法模式

工厂方法模式的实际需求

看一个新的需求

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

思路一：简单工厂模式

  • 使用简单工厂模式， 创建不同的简单工厂类， 比如 BJPizzaSimpleFactory、LDPizzaSimpleFactory 等等。

  • 从当前这个案例来说， 也是可以的， 但是考虑到项目的规模， 以及软件的可维护性、 可扩展性并不是特别好，因为过多的工厂类会导致整个项目类膨胀

路二：使用工厂方法模式

工厂方法模式介绍

  • 工厂方法模式设计方案： 将披萨项目的实例化功能抽象成抽象方法， 在不同的口味点餐子类中具体实现。
  • 工厂方法模式： 定义了一个创建对象的抽象方法， 由子类决定要实例化的类。 工厂方法模式将对象的实例化推迟到子类

工厂方法模式应用案例

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

在这里插入图片描述

  1. Pizza：抽象父类，和之前的定义一样
/** 将Pizza 做成抽象类
 * @author compass
 * @version 1.0
 * @date 2021-07-06 14:51
 */
public abstract class Pizza {
    protected  String name;

    // 准备披萨 因为不太的披萨会有不同的原材料 所以做成抽象方法
    public abstract void prepare();

    public void bake(){
        System.out.println(name+":开始烘烤");
    }

    public void cut(){
        System.out.println(name+":开始切割");
    }

    public void box(){
        System.out.println(name+":开始包装");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
  1. BJCheesePizza：北京的奶酪披萨
/**
 * @author compass
 * @version 1.0
 * @date 2021-07-06 14:55
 */
public class BJCheesePizza extends Pizza {
    @Override
    public void prepare() {
        setName("北京的奶酪pizza");
        System.out.println("北京的奶酪pizza 准备原材料");
    }


}
  1. BJPepperPizza：北京的胡椒披萨
/**
 * @author compass
 * @version 1.0
 * @date 2021-07-06 14:54
 */
public class BJPepperPizza extends Pizza {
    @Override
    public void prepare() {
        setName("北京的胡椒pizza");
        System.out.println("北京的胡椒pizza 准备原材料");
    }




}
  1. LDCheesePizza：伦敦的奶酪披萨
/**
 * @author compass
 * @version 1.0
 * @date 2021-07-06 14:54
 */
public class LDCheesePizza extends Pizza {
    @Override
    public void prepare() {
        setName("伦敦的奶酪pizza");
        System.out.println("伦敦的奶酪pizza 准备原材料");
    }




}
  1. LDPepperPizza：伦敦的胡椒披萨
/**
 * @author compass
 * @version 1.0
 * @date 2021-07-06 14:55
 */
public class LDPepperPizza extends Pizza {
    @Override
    public void prepare() {
        setName("伦敦的胡椒pizza");
        System.out.println("伦敦的胡椒pizza 准备原材料");
    }


}
  1. OrderPizza：含有抽象方法的工厂父类，其抽象方法待子类去实现
/**  含有抽象方法的工厂父类，其抽象方法待子类去实现
 * @author compass
 * @version 1.0
 * @date 2021-07-06 14:57
 */
public abstract  class OrderPizza {

    // 定义一个抽象方法，createPizza , 让各个工厂子类自己实现
    abstract Pizza createPizza(String orderType);

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

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

}
  1. BJOrderFactory：北京披萨的生产工厂
/**
 * @author compass
 * @version 1.0
 * @date 2021-07-06 17:57
 */
public class BJOrderFactory  extends OrderPizza{
    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")) {
            pizza = new BJCheesePizza();
        } else if (orderType.equals("pepper")) {
            pizza = new BJPepperPizza();
        }
        return pizza;
    }

}
  1. LDOrderFactory：伦敦披萨的生产工厂
/**
 * @author compass
 * @version 1.0
 * @date 2021-07-06 17:57
 */
public class LDOrderFactory   extends OrderPizza{

        @Override
        Pizza createPizza(String orderType) {
            Pizza pizza = null;
            if (orderType.equals("cheese")) {
                pizza = new LDCheesePizza();
            } else if (orderType.equals("pepper")) {
                pizza = new LDPepperPizza();
            }
            return pizza;
        }



}
  1. PizzaStore：相当于客户端，发出订购披萨的请求
/**
 * @author compass
 * @version 1.0
 * @date 2021-07-06 18:00
 */
public class PizzaStore {

    public static void main(String[] args) {
        String loc = "bj"; // 假设这里是用户输入的位置信息
        if (loc.equals("bj")) {
            // 创建北京口味的各种Pizza
            new BJOrderFactory();
        } else {
            // 创建伦敦口味的各种Pizza
            new LDOrderFactory();
        }
    }

}

3.抽象工厂模式

抽象工厂模式的基本介绍

  • 抽象工厂模式： 定义了一个 interface 用于创建相关或有依赖关系的对象簇， 而无需指明具体的类
  • 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
  • 从设计层面看， 抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。
  • 将工厂抽象成两层， AbsFactory(抽象工厂) 和 具体实现的工厂子类。 程序员可以根据创建对象类型使用对应的工厂子类。 这样将单个的简单工厂类变成了工厂簇， 更利于代码的维护和扩展。

抽象工厂模式的案例
在这里插入图片描述

使用抽象工厂模式来完成披萨项目

代码实现

Pizza抽象父类以及Pizza的子类和上面一样

AbsFactory：工厂抽象层，定义制造 Bean 的抽象方法

/** 一个抽象工厂模式的抽象层（接口）
 * @author compass
 * @version 1.0
 * @date 2021-07-06 20:43
 */
public interface AbsFactory {

    Pizza createPizza(String orderType);
 }

BJFactory：北京工厂子类（提供方），负责制造北京各种口味的 Pizza

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-06 20:45
 */
public class BJFactory implements AbsFactory {
    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza=null;
        if (orderType.equals("cheese")){
            pizza=new BJCheesePizza();
        }else  if(orderType.equals("pepper")){
            pizza=new BJPepperPizza();
        }
        return pizza;
    }
}

LDFactory：伦敦工厂子类（提供方），负责制造伦敦各种口味的 Pizza

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-06 20:45
 */
public class LDFactory  implements AbsFactory{
    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza=null;
        if (orderType.equals("cheese")){
            pizza=new LDCheesePizza();
        }else  if(orderType.equals("pepper")){
            pizza=new LDPepperPizza();
        }
        return pizza;
    }
}

OrderPizza：使用方，负责消费 Pizza

/**
 * 
 *
 * @author compass
 * @version 1.0
 * @date 2021-07-06 14:57
 */
public class OrderPizza {

    AbsFactory factory;

    public OrderPizza(AbsFactory absFactory) {
      setAbsFactory(absFactory);
    }

    private void setAbsFactory(AbsFactory factory){
        Pizza pizza=null;
        // 用户输入
        String orderType="";
   this.factory=factory;
        do {
             orderType = getType();
             pizza = factory.createPizza(orderType);
            // 输出pizza 制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
            System.out.println();
        } while (true);
    }



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

}

PizzaStore：客户端，发出订购披萨的请求

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-06 18:00
 */
public class PizzaStore {

    public static void main(String[] args) {
    
        OrderPizza pizza = new OrderPizza( new BJFactory());
    }

}

抽象工厂模式总结

在这里插入图片描述

  • AbsFactory 仍然是简单工厂（简单工厂模式），但是工厂方法的具体实现需下沉到各个工厂子类（工厂方法模式），所以说抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
  • 抽象工厂模式分为两层：抽象层和实现层。AbsFactory 作为工厂抽象层，只对工厂规范进行定义，其具体的实现交由工厂子类
  • 简单工厂模式很难满足对多种不同类型的 Bean 进行创建，所以我们使用抽象工厂模式，定义一个工厂抽象层，但具体实现需下沉到各个工厂子类

4.JDK Calendar

JDK Calendar 中使用到了简单工厂模式

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-06 22:14
 */
public class Test {



        public static void main(String[] args) {

            // getInstance 是 Calendar 静态方法
            Calendar cal = Calendar.getInstance();
            // 注意月份下标从0开始，所以取月份要+1
            System.out.println("年:" + cal.get(Calendar.YEAR));
            System.out.println("月:" + (cal.get(Calendar.MONTH) + 1));
            System.out.println("日:" + cal.get(Calendar.DAY_OF_MONTH));
            System.out.println("时:" + cal.get(Calendar.HOUR_OF_DAY));
            System.out.println("分:" + cal.get(Calendar.MINUTE));
            System.out.println("秒:" + cal.get(Calendar.SECOND));

     

    }

}

Calendar.getInstance() 方法的实现

/**
 * Gets a calendar using the default time zone and locale. The
 * <code>Calendar</code> returned is based on the current time
 * in the default time zone with the default
 * {@link Locale.Category#FORMAT FORMAT} locale.
 *
 * @return a Calendar.
 */
public static Calendar getInstance()
{
    return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT));
}

createCalendar() 方法的实现：如果 provider == null，就会根据 caltype 的值，来创建具体的工厂子类对象

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.工厂模式小结

工厂模式的意义：将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。

三种工厂模式

简单工厂模式
工厂方法模式
抽象工厂模式

设计模式的依赖抽象原则

  • 创建对象实例时，不要直接 new 这个类，而是把这个new 类的动作放在一个工厂的方法中，并返回。有的书上说，变量不要直接持有具体类的引用。这样做的好处是：我们依赖的是一个抽象层（缓冲层），如果之后有什么变动，修改工厂类中的代码即可
  • 不要让类继承具体类，而是继承抽象类或者是实现interface(接口)
    不要覆盖基类中已经实现的方法

关于工厂模式，我之前也有一篇博客，这个老师讲的感觉创建对象的方式不太灵活，还需要改动代码，我这个，不需要改动任何代码，只需要你将需要创建的对象的类型传入即可，灵活性更强，是基于java的反射机制和泛型写的。

一句话： 不要面向具体编程，需要面向抽象编程，这样扩展性强，使用对象不要直接new，而是在中间加一层，让工厂类去代替你做new对象的这个动作，如果你手动去new，将来你的代码改动会比较大，变量不要直接持有具体类的引用

地址：java工厂模式

野生java研究僧
关注
专栏目录
大话设计模式之爱你一万年：第三章 创建型模式：工厂模式：我想让你坐在宝马里笑：4.工厂模式之工厂方法模式
悟纤学院
12-21 1万+
上面我们对于BMW520、BMW521都是只有一个工厂来进行生生产，扩展性就会比较差。 由于简单工厂模式中只有一个工厂类来对应这些产品，所以这可能会把我们的上帝累坏了，也累坏了我们这些程序员。 于是工厂方法模式作为救世主出现了。 工厂类定义成了接口，而每新增的车种类型，就增加该车种类型对应工厂类的实现，这样工厂的设计就可以扩展了，而不必去修改原来的代码。 简单来说为了解决简单工厂模式中工厂方法过多的if else问题，我们使用了工厂方法模式一个具体产品类由一个...
设计模式——工厂方法模式
姑娘眼中的明月色，就只有你一人，轻轻望去，才能发现。
04-18 2148
使用Java实现了工厂方法模式，并且通过实例代码来了解工厂方法模式，证明了工厂方法模式符合“OCP”原则。
工厂模式 - 总结
anlao4870的博客
10-15 105
1、简单工厂模式 　　简单工厂模式又叫静态工厂模式，核心为一个工厂类，工厂类中又一个静态工厂方法。静态工厂方法通过传入的参数进行判断从而决定生成哪个实例。 2、工厂方法模式 　　工厂方法模式在简单工厂模式的基础上，对静态工厂方法进行了抽象，去掉静态工厂中的参数。对象的创建交给了具体工厂。通过不断的添加具体工厂类从而实现“开闭”原则的拓展。另外。正因为对象的创建交给了具体工厂，...
设计模式之简单工厂模式
不落航班
01-23 418
检测换卡接口 public interface ICardChangeDetector { public void onStateChange(); } 单卡手机 public class SingleCardChangeDetector implements ICardChangeDetector { @Override public void onStateC
Java23种设计模式之工厂模式
wang_zqiang的专栏
01-25 165
  工厂工厂，顾名思义就是加工东西的。Java的工厂模式包含以下3种： 简单工厂模式 工厂方法模式 抽象工厂模式  1.简单工厂 使用场景：如果一个一些对象产品，已经确定不会再改动，就可以使用简单工厂模式 理解几个关键点 1）抽象产品角色：它一般是具体产品继承的父类或要实现的接口。 2）具体产品角色：工厂类创建的对象就是该角色的实例。 3）工厂类角色：含有...
通用工厂类Factory(C++实现)
辉哥
04-16 4733
灵光一闪：         抽象工厂模式经常被使用，那么同时也会多次写相同或类似的代码。能不能设计一个通用的工厂类，以避免重复设计工厂类呢？
Java工厂模式（随笔）
是个非常热爱生活、乐观、奋斗、努力的逗比青年
06-01 5474
三大工厂都是哪些？简单工厂模式工厂模式抽象工厂模式特殊工厂都是哪些？容器工厂模式超级工厂模式准确的来说工厂模式一共只有三种；但在我们程序员这里不止三种，还有两种，我们把它叫 ‘容器工厂模式’ 和 ‘超级工厂模式为什么它们没有增加到三大模式呢？因为它们都是基于‘简单工厂模式’扩展开辟出来的，解决了简单工厂模式存在违反开闭原则等弊端。Java简单工厂模式是一种创建型设计模式，它提供了一个工厂类，用于根据传入的参数来决定创建哪种类的实例；
设计模式——工厂模式
vincewm的博客
04-29 1955
工厂模式介绍、静态简单工厂模式、工厂方法模式、抽象工厂模式、JDK 源码分析
【C#设计模式】4-0. 简单工厂模式【创建型】
星Yeah 的博客
07-01 4079
简单工厂模式简单来说就是创建一个工厂类，通过输入的参数创建对象赋值给基类，完成对想要的派生类的调用，从而达成目标，具体的操作均在子类中完成，工厂类只负责运算逻辑和给基类赋值。.......................................
3.设计模式-抽象工厂模式1
08-03
抽象工厂模式是一种设计模式，属于创建型模式，它提供了一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。在Java编程中，这种模式可以帮助我们隔离具体类和抽象类之间的耦合，使得系统对扩展友好，...
C#设计模式源代码1.简单工厂模式 2.工厂方法模式 ...11种
04-25
1. **简单工厂模式**：这是一种创建型设计模式，用于创建对象。它提供了一个静态方法来创建对象，而不是让客户端直接实例化类。这样可以将对象的创建过程封装起来，简化客户端代码。 2. **工厂方法模式**：这也是...
简单工厂模式.zip
04-09
根据提供的文件名"简单工厂模式习题4"和"简单工厂模式习题5"，我们可以推测这些习题可能是为了帮助读者理解和实践简单工厂模式的核心概念和应用场景。 简单工厂模式通常包含以下角色： 1. **产品接口（Product）**...
【超强组合】基于淘金优化算法GRO-BP-Adaboost的数据分类预测算法Matlab实现.rar
10-08
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
VMware Workstation Pro 和 VMware Fusion 安装与配置指南
10-08
内容概要：本文档详细指导了如何在不同的主机环境下，通过 VMWare 的两款产品——Workstation Pro 和 Fusion 进行新虚拟机的构建流程以及具体的操作要点说明。 适用人群：希望在单一机器上部署多操作系统的工作环境或学习测试场景的技术人员和学生。 使用场景及目标：旨在帮助初学者搭建属于自己的虚拟机实验平台，从而方便进行软件测试或者研究操作系统相关的新特性等任务，同时也有利于团队间的协作和资源调配。 注意事项：文中涉及的具体操作如下载源文件、配置网络参数时要注意版权合法性问题和技术安全防范。此外还需依据各自电脑的软硬件条件适当增减虚拟机的资源设定。
科研经费管理系统 SSM毕业设计 源码+数据库+论文（JAVA+SpringBoot+Vue.JS）.zip
10-08
科研经费管理系统 SSM毕业设计 源码+数据库+论文（JAVA+SpringBoot+Vue.JS） 启动教程：https://www.bilibili.com/video/BV1GK1iYyE2B
使用Python Matplotlib进行图形输出与保存详解（包含详细的完整的程序和数据）
10-08
内容概要：本文详细介绍了使用 Python 的 Matplotlib 库来输出和保存图形的方法。不仅涉及了基本流程，如生成图表并将之导出成PNG、PDF和SVG等不同格式的内容，还包括高级话题如设置透明度、分辨率以及制作包含图形元素的HTML页面等。文章通过一个具体的示例代码讲解了各个环节的关键细节和技术要点。 适用人群：对数据可视化有兴趣的初学者及具有一定基础想要深入学习 Matplotlib 使用技巧的技术人员。 使用场景及目标：适用于需要掌握 Matplotlib 不同输出选项及其特点的应用场合，尤其是当需要生成用于打印或网页展示的高质量、可自定义外观的图形时。
【数字信号分离】基于matlab自然梯度算法盲信号分离（含串音信号 变步长）【含Matlab源码 8813期】.zip
10-08
CSDN海神之光上传的代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b或2023b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博客文章底部QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 功率谱估计： 故障诊断分析： 雷达通信：雷达LFM、MIMO、成像、定位、干扰、检测、信号分析、脉冲压缩 滤波估计：SOC估计 目标定位：WSN定位、滤波跟踪、目标定位 生物电信号：肌电信号EMG、脑电信号EEG、心电信号ECG 通信系统：DOA估计、编码译码、变分模态分解、管道泄漏、滤波器、数字信号处理+传输+分析+去噪（CEEMDAN）、数字信号调制、误码率、信号估计、DTMF、信号检测识别融合、LEACH协议、信号检测、水声通信
基于多元宇宙优化算法MVO优化CNN-BiGRU-Attention锂电池健康寿命预测算法研究Matlab实现.rar
最新发布
10-08
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
理解设计模式：工厂模式详解
4. 工厂模式的作用： 工厂模式通过提供一个统一的接口来创建对象，使得客户端代码无需关心具体的产品实现细节，只需要与抽象接口交互，降低了耦合度。此外，它使得添加新的产品类型变得容易，只需要新增一个具体产品...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值