韩顺平设计模式之工厂模式

最新推荐文章于 2024-09-04 15:29:36 发布
最新推荐文章于 2024-09-04 15:29:36 发布
阅读量491 收藏 1
点赞数
分类专栏： 韩顺平设计模式 文章标签： java 设计模式 简单工厂模式 工厂方法模式 抽象工厂模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qinwang_gz/article/details/120268856
版权

目录

一、简单工厂模式

1.看一个具体的需求

2.使用传统的方式来完成

2.1思路分析(类图)

2.2看老师代码的演示

 2.3传统的方式的优缺点

3.基本介绍

4.使用简单工厂模式

二、工厂方法模式

1.看一个新的需求

2.思路 1

3.思路 2

4.工厂方法模式介绍

5.工厂方法模式应用案例

三、抽象工厂模式

1.基本介绍

 2.抽象工厂模式应用实例

四、工厂模式在 JDK-Calendar 应用的源码分析

五、工厂模式小结

一、简单工厂模式

1.看一个具体的需求

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

（1）披萨的种类很多(比如 GreekPizz、CheesePizz 等)；

（2） 披萨的制作有 prepare，bake, cut, box；

（3）完成披萨店订购功能。

2.使用传统的方式来完成

2.1思路分析(类图)

 编写 OrderPizza.java 去订购需要的各种 Pizza

2.2看老师代码的演示

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制作过程
//            pizza.prepare();
//            pizza.bake();
//            pizza.cut();
//            pizza.box();
//        } while (true);
//    }

 2.3传统的方式的优缺点

（1）优点是比较好理解，简单易操作。

（2） 缺点是违反了设计模式的 ocp原则，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码.

（3） 比如我们这时要新增加一个 Pizza的种类(Pepper披萨)，我们需要做如下修改.

如果我们增加一个 Pizza类，只要是订购 Pizza 的代码都需要修改.

（4） 改进的思路分析

分析：修改代码可以接受，但是如果我们在其它的地方也有创建 Pizza的代码，就意味着，也需要修改，而创建 Pizza的代码，往往有多处。

思路：把创建 Pizza对象封装到一个类中，这样我们有新的 Pizza种类时，只需要修改该类就可，其它有创建到 Pizza对象的代码就不需要修改了.-> 简单工厂模式

3.基本介绍

 （1）简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式。

（2）简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)。

（3）在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式。

4.使用简单工厂模式

（1）简单工厂模式的设计方案: 定义一个可以实例化 Pizaa对象的类，封装创建对象的代码。

（2）看代码示例

package com.atguigu.factory.simplefactory.pizzastore.order;

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

//简单工厂类
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;
    }

    public static Pizza createPizza2(String orderType) {
        Pizza pizza = null;
        System.out.println("使用简单工厂模式 2");
        if (orderType.equals("greek")) {
            pizza = new GreekPizza();
            pizza.setName(" 希腊披萨 ");
        } else if (orderType.equals("cheese")) {
            pizza = new CheesePizza();
            pizza.setName(" 奶酪披萨 ");
        }
        return pizza;
    }

}


//OrderPizza.java


package com.atguigu.factory.simplefactory.pizzastore.order;

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

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

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制作过程
//            pizza.prepare();
//            pizza.bake();
//            pizza.cut();
//            pizza.box();
//        } while (true);
//    }

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

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

    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();
            } else {
                System.out.println(" 订购披萨失败 ");
                break;
            }
        } while (true);
    }

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

二、工厂方法模式

1.看一个新的需求

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

2.思路 1

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

3.思路 2

使用工厂方法模式。

4.工厂方法模式介绍

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

5.工厂方法模式应用案例

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

（2）思路分析图解

//OrderPizza.java


package com.atguigu.factory.factorymethod.pizzastore.order;

import com.atguigu.factory.factorymethod.pizzastore.pizza.Pizza;

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

/**
 * @author wjd
 * @date 2021年09月13日 10:08
 */
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();
        } while (true);
    }

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


//BJOrderPizza.java 


package com.atguigu.factory.factorymethod.pizzastore.order;

import com.atguigu.factory.factorymethod.pizzastore.pizza.BJCheesePizza;
import com.atguigu.factory.factorymethod.pizzastore.pizza.BJPepperPizza;
import com.atguigu.factory.factorymethod.pizzastore.pizza.Pizza;

/**
 * @author wjd
 * @date 2021年09月13日 10:12
 */
public class BJOrderPizza 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;
    }
}

//LDOrderPizza.java


package com.atguigu.factory.factorymethod.pizzastore.order;

import com.atguigu.factory.factorymethod.pizzastore.pizza.LDCheesePizza;
import com.atguigu.factory.factorymethod.pizzastore.pizza.LDPepperPizza;
import com.atguigu.factory.factorymethod.pizzastore.pizza.Pizza;

/**
 * @author wjd
 * @date 2021年09月13日 10:15
 */
public class LDOrderPizza 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.基本介绍

（1）抽象工厂模式：定义了一个 interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类

（2）抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。

（3）从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。

（4） 将工厂抽象成两层，AbsFactory(抽象工厂) 和 具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。

（5）类图

 2.抽象工厂模式应用实例

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

package com.atguigu.factory.absfactory.pizzastore.order;

import com.atguigu.factory.absfactory.pizzastore.pizza.Pizza;

/**
 * @author wjd
 * @date 2021年09月13日 10:33
 */
//一个抽象工厂模式的抽象层（接口）
public interface AbsFactory {
    //让下面的工厂子类来 具体实现
    public Pizza createPizza(String orderType);
}

//BJFactory.java


package com.atguigu.factory.absfactory.pizzastore.order;

import com.atguigu.factory.absfactory.pizzastore.pizza.BJCheesePizza;
import com.atguigu.factory.absfactory.pizzastore.pizza.BJPepperPizza;
import com.atguigu.factory.absfactory.pizzastore.pizza.Pizza;

/**
 * @author wjd
 * @date 2021年09月13日 10:39
 */
//这是一个工厂子类
public class BJFactory implements AbsFactory {

    @Override
    public Pizza createPizza(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;
    }
}

//LDFactory.java


package com.atguigu.factory.absfactory.pizzastore.order;

import com.atguigu.factory.absfactory.pizzastore.pizza.LDCheesePizza;
import com.atguigu.factory.absfactory.pizzastore.pizza.LDPepperPizza;
import com.atguigu.factory.absfactory.pizzastore.pizza.Pizza;

/**
 * @author wjd
 * @date 2021年09月13日 10:39
 */
//这是一个工厂子类
public class LDFactory implements AbsFactory {

    @Override
    public Pizza createPizza(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;
    }
}

//OrderPizza.java


package com.atguigu.factory.absfactory.pizzastore.order;

import com.atguigu.factory.absfactory.pizzastore.pizza.Pizza;

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

/**
 * @author wjd
 * @date 2021年09月13日 11:58
 */
public class OrderPizza {
    AbsFactory factory;

    //构造器
    public OrderPizza(AbsFactory factory) {
        setFactory(factory);
    }

    private void setFactory(AbsFactory factory) {
        Pizza pizza = null;
        String orderType = "";//用户输入
        this.factory = factory;
        do {
            orderType = getType();
            //factory 可能是背景的工厂子类，也可能是伦敦的工厂子类
            pizza = factory.createPizza(orderType);
            if (pizza != null) {//订购ok
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("订购失败");
                break;
            }
        } while (true);
    }

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

四、工厂模式在 JDK-Calendar 应用的源码分析

（1）JDK 中的 Calendar类中，就使用了简单工厂模式

（2）源码分析+Debug源码+说明

源码部分

package com.atguigu.jdk;

import java.util.Calendar;

/**
 * @author wjd
 * @date 2021年09月13日 15:37
 */
public class Factory {
    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));
    }
}

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;
    }

五、工厂模式小结

（1）工厂模式的意义

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

（2）三种工厂模式 (简单工厂模式、工厂方法模式、抽象工厂模式)

（3）设计模式的依赖抽象原则

  • 创建对象实例时，不要直接 new 类, 而是把这个 new 类的动作放在一个工厂的方法中，并返回。有的书上说，变量不要直接持有具体类的引用。
  • 不要让类继承具体类，而是继承抽象类或者是实现 interface(接口)。
  • 不要覆盖基类中已经实现的方法。
行云流水Gz
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
工厂模式详细说明(带图超经典)
03-18
工厂模式详细说明(带图超经典),工厂模式,java,php,c++,c,c#
三层架构+工厂模式（经典案例）带图，带说明
11-08
三层架构+工厂模式（经典案例）带图，带说明 非常适合框架设计者，非常经典，里面关于每一层就详细的说明。
设计模式之工厂模式
smile radiantly
11-24 180
一：简单工厂模式 1.看一个具体需求 看一个披萨的项目：要便于披萨种类的扩展，要便于维护 1)披萨的种类很多(比如 GreekPizz、CheesePizz 等) 2)披萨的制作有 prepare，bake, cut, box 3)完成披萨店订购功能。 2.传统方式来完成 编写 OrderPizza.java 去订购需要的各种 Pizza public class OrderPizza { ...
23种设计模式之工厂模式
space_qi的博客
12-31 294
23种设计模式之工厂模式 文章目录23种设计模式之工厂模式参考资料一、简介定义特点优点通用类图应用场景二、实现分类静态（简单）工厂模式工厂(方法)模式三、总结 参考资料 Java设计模式：23种设计模式全面解析（超级详细） 韩顺平老师的Java设计模式（图解+框架源码剖析） 秦小波老师的《设计模式之禅》 下文如有错漏之处，敬请指正 一、简介 定义 通过类或方法创建对象 特点 工厂模式是一种创建型设计模式 实现创建者和调用者的分离 优点 良好的封装性，代码结构清晰，只要知道产品的类名（或约束字符串
韩顺平设计模式之设计模式概述
行云流水Gz的专栏
09-09 382
目录 一、设计模式介绍 二、设计模式类型 一、设计模式介绍 （1）设计模式是程序员在面对同类软件工程设计问题所总结出来的有用的经验，模式不是代码，而是某类问题的通用解决方案，设计模式（Design pattern）代表了最佳的实践。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。 （2） 设计模式的本质提高 软件的维护性，通用性和扩展性，并降低软件的复杂度。 （3）<<设计模式>> 是经典的书，作者是 Erich Gamma、Richard He
【韩顺平】设计模式七大原则
QinLaoDeMaChu的博客
05-01 512
目录1. 设计模式常用的七大原则:1.1 设计模式的目的:1.2 单一职责原则 1. 设计模式常用的七大原则: 设计模式常用的七大原则有: 单一职责原则 接口隔离原则 依赖倒转原则 里氏替换原则 开闭原则 ocp 迪米特法则 合成复用原则 1.1 设计模式的目的: 编写软件过程中，程序员面临着来自耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性等多方面的挑战，设计模式是为了让程序(软件)，具有更好的 代码重用性 (即: 相同功能的代码，不用多次编写) 可读性 (即: 编程规范性,便于其他程序员的阅
韩顺平设计模式之单例模式
行云流水Gz的专栏
09-10 455
一、单例模式介绍 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。 比如 Hibernate的 SessionFactory，它充当数据存储源的代理，并负责创建 Session对象。SessionFactory并不是轻量级的，一般情况下，一个项目通常只需要一个 SessionFactory就够，这是就会使用到单例模式。 二、单例模式的八种方式 （1）饿汉式(静态常量) （2）饿汉式（静态代码块） （
韩顺平设计模式资料.rar
09-10
本套资料《韩顺平设计模式》由知名IT讲师韩顺平在2019年整理发布，旨在深入解析设计模式的原理和应用。 1. **单例模式**：确保一个类只有一个实例，并提供全局访问点。在Java中，单例模式通常通过私有构造器和静态...
韩顺平_Java设计模式笔记.docx
01-16
### 韩顺平_Java设计模式笔记知识点详解 #### 1. Java设计模式内容介绍 ##### 1.1.1 先看几个经典的面试题 - **原型设计模式问题** - **UML类图**：原型模式的核心在于定义了一个`Prototype`接口，该接口声明了...
韩顺平_java设计模式笔记
11-07
韩顺平老师的Java设计模式课程通过生活中的实例和Spring框架中的应用，深入浅出地讲解了这些模式。 首先，我们来看一下原型设计模式。原型模式主要用于对象的复制，分为浅拷贝和深拷贝。浅拷贝只复制对象的引用，而...
尚硅谷_韩顺平_图解Java设计模式
10-09
后续章节会继续深入探讨其他六大原则，以及23种经典设计模式，如工厂模式、单例模式、建造者模式、观察者模式等。这些模式是软件开发中的常用工具，掌握它们对于提升软件工程的实践能力至关重要。此外，这份笔记还会...
韩顺平-设计模式1
08-08
例如，可能会涉及到单例模式、工厂模式等常见的设计模式问题。 接着，课程强调了设计模式的重要性。设计模式不仅能够提高代码的可读性和可维护性，还能促进团队之间的沟通，因为它们提供了一套通用的语言和框架。...
bilibili 韩顺平Java后端学习路线
China_HADES的博客
06-13 6299
java后端技术路线是一个相对完整的学习路线，所以大家不用把所有的都学完再去找工作，不用这样子，其实你只要学到第四个，第五个阶段，再做一些项目，再刷一些题，其实就可以开始准备找工作了 视频链接：https://www.bilibili.com/video/BV14K4y177Qk...
韩顺平图解Java设计模式
嘟爷java超神学堂
08-27 2966
今天分享一部设计模式相关的视频，好好复习帮助还是很大的。课程介绍1) 优秀的程序应该是这样的：阅读时，感觉很优雅；新增功能时，感觉很轻松；运行时，感觉很快速,这就需要设计...
工厂模式（简单工厂模式、工厂方法模式优缺点，使用场景）
热门推荐
cxy_zxl的博客
05-12 2万+
工厂模式，优缺点以及存在的意义1.简单工厂模式（静态工厂模式）1.工厂方法模式 工厂模式的本质 实例化对象不使用new，用工厂方法代替 将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现解耦 - oop七大原则 开闭原则：一个软件的实体应当对扩展开放，对修改关闭 依赖倒转原则：要针对接口编程，不要针对实现编程 迪米特法则：只与你直接的朋友通信，而避免和陌生人通信 应用场景 JDK中Calendar的getInstance方法 JDBC中的Connection对象的获取 Spring.
【JavaWeb】JDBC&Druid&Tomcat入门使用
lklalmq的博客
09-04 1075
预编译SQL语句并执行：预防SQL注入问题获取 PreparedStatement 对象// SQL语句中的参数值，使用？占位符替代?// 通过Connection对象获取，并传入对应的sql语句设置参数值上面的sql语句中参数使用?进行占位，在之前之前肯定要设置 这些?的值。PreparedStatement对象：setXxx(参数1，参数2)：给?赋 值Xxx：数据类型；如 setInt (参数1，参数2)参数：参数1：？的位置编号，从1 开始参数2：？的值执行SQL语句。
okhttp，retrofit,rxjava 是如何配合工作的 作用分别是什么
最新发布
追梦的鱼儿
09-04 560
OkHttp、Retrofit 和 RxJava 是 Android 开发中常用的三种库，它们各自有不同的作用，并且可以很好地配合工作来实现网络请求和响应的处理。
韩顺平Java设计模式精华笔记：面试题解析与实战应用
这些原则通过类图的形式得以直观展示，并举例说明了开闭原则在工厂模式中的运用。 接着，文档介绍了金融借贷平台项目中的状态转换图，展示了如何在实际业务场景中运用设计模式来管理复杂的状态变化。解释器设计模式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值