Spring学习记录

news2025/1/12 13:35:40

目录

工厂模式的三种形态

简单工厂模式

代码：

运行结果：

 总结：

工厂模式

代码：

运行结果：

总结：

 抽象工厂模式

代码：

 运行结果：

 总结：

bean的单例与多例  设置     scope属性设置：默认singleton   多例：prototype

默认下：【启动容器的时候就创建对象了】

设置

scope为：prototype【启动容器的时候不会创建对象】【在调getBean才创建】

scope 还有多个值：

工厂模式的三种形态

工厂模式通常有三种形态：

  • 第一种：简单工厂模式（Simple Factory）：不属于23种设计模式之一。简单工厂模式又叫做：静态 工厂方法模式。简单工厂模式是工厂方法模式的一种特殊实现。
  • 第二种：工厂方法模式（Factory Method）：是23种设计模式之一。
  • 第三种：抽象工厂模式（Abstract Factory）：是23种设计模式之一。

简单工厂模式

简单工厂模式的角色包括三个：

  • 抽象产品 角色
  • 具体产品 角色
  • 工厂类 角色

代码：

package com.dong.factory;

/**
 * 抽象产品角色
 */
public abstract class Weapon {
    public abstract void attack();
}

package com.dong.factory;

/**
 * 具体产品角色
 */
public class Tank extends Weapon{

    public void attack() {
        System.out.println("坦克开炮！！！！！");
    }
}

package com.dong.factory;

/**
 * 具体产品角色
 */
public class Warcraft extends Weapon{

    public void attack() {
        System.out.println("战斗机扔下小男孩！！！！！");
    }
}

package com.dong.factory;

/**
 * 工厂类角色
 */
public class WeaponFactory {
    public static Weapon get(String weaponType){
        if (weaponType==null||weaponType.trim().length()==0) {
            return null;
        }
        Weapon weapon=null;
        if ("TANK".equals(weaponType)){
            weapon=new Tank();
        } else if ("WARCRAFT".equals(weaponType)) {
            weapon=new Warcraft();
        }else {
            throw new RuntimeException("不⽀持该武器！");
        }
        return weapon;
    }
}

package com.dong.factory;

/**
 * 客户端程序
 */
public class Test {
    public static void main(String[] args) {
        Weapon weapon=WeaponFactory.get("TANK");
        weapon.attack();
        Weapon weapon1=WeaponFactory.get("WARCRAFT");
        weapon1.attack();
    }
}

运行结果：

 总结：

工厂模式

工厂方法模式既保留了简单工厂模式的优点，同时又解决了简单工厂模式的缺点。

工厂方法模式的角色包括：

  • 抽象工厂角色
  • 具体工厂角色
  • 抽象产品角色
  • 具体产品角色

代码：

package com.dong.factory.method;

/**
 * 抽象产品角色
 */
public abstract class Weapon {
    public abstract void attack();
}

package com.dong.factory.method;

/**
 * 具体产品角色
 */
public class Dagger extends Weapon{
    @Override
    public void attack() {
        System.out.println("炸军舰。。。。");
    }
}

package com.dong.factory.method;

/**
 * 具体产品角色
 */
public class Gun extends Weapon {
    @Override
    public void attack() {
        System.out.println("开枪射击。。。。");
    }
}


package com.dong.factory.method;

/**
 * 抽象⼯⼚⻆⾊
 */
public abstract class WeaponFactory {
    public abstract Weapon get();
}

package com.dong.factory.method;

/**
 * 具体⼯⼚⻆⾊
 */
public class GunFactory extends WeaponFactory{
    @Override
    public Weapon get() {
        return new Gun();
    }
}

package com.dong.factory.method;

/**
 * 具体⼯⼚⻆⾊--生产具体产品
 */
public class DaggerFactory extends WeaponFactory{
    @Override
    public Weapon get() {
        return new Dagger();
    }
}

package com.dong.factory.method;

/**
 * 客户端程序
 */
public class Test {
    public static void main(String[] args) {
        WeaponFactory weaponFactory=new DaggerFactory();
        Weapon dagger=weaponFactory.get();
        dagger.attack();

        WeaponFactory weaponFactory1=new GunFactory();
        Weapon gun=weaponFactory1.get();
        gun.attack();
    }
}

运行结果：

总结：

 

 抽象工厂模式

  • 抽象工厂模式相对于工厂方法模式来说，就是工厂方法模式是针对一个产品系列的，而抽象工厂模式是针对多个产品系列的，即工厂方法模式是一个产品系列一个工厂类，而抽象工厂模式是多个产品系列一个工厂类。
  • 抽象工厂模式特点：抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。它有多个抽象产品类，每个抽象产品类可以派生出多个具体产品类，一个抽象工厂类，可以派生出多个具体工厂类，每个具体工厂类可以创建多个具体产品类的实例。每一个模式都是针对一定问题的解决方案，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式针对的是多个产品等级结果。

抽象工厂中包含4个角色：

  • 抽象工厂角色
  • 具体工厂角色
  • 抽象产品角色
  • 具体产品角色

抽象工厂模式的类图如下：

抽象工厂模式代码如下：

代码：

package com.dong.product;

/**
 * 武器产品族
 * @author dong
 * @version 1.0
 * @className Weapon
 * @since 1.0
 **/
public abstract class Weapon {
    public abstract void attack();
}

package com.dong.product;

/**
 * 武器产品族中的产品等级1
 * @author dong
 * @version 1.0
 * @className Gun
 * @since 1.0
 **/
public class Gun extends Weapon{
    @Override
    public void attack() {
        System.out.println("开枪射击！");
    }
}

package com.dong.product;

/**
 * 武器产品族中的产品等级2
 * @author dong
 * @version 1.0
 * @className Dagger
 * @since 1.0
 **/
public class Dagger extends Weapon{
    @Override
    public void attack() {
        System.out.println("砍丫的！");
    }
}

package com.dong.product;

/**
 * 水果产品族
 * @author dong
 * @version 1.0
 * @className Fruit
 * @since 1.0
 **/
public abstract class Fruit {
    /**
     * 所有果实都有一个成熟周期。
     */
    public abstract void ripeCycle();
}

package com.dong.product;

/**
 * 水果产品族中的产品等级1
 * @author dong
 * @version 1.0
 * @className Orange
 * @since 1.0
 **/
public class Orange extends Fruit{
    @Override
    public void ripeCycle() {
        System.out.println("橘子的成熟周期是10个月");
    }
}

package com.dong.product;

/**
 * 水果产品族中的产品等级2
 * @author dong
 * @version 1.0
 * @className Apple
 * @since 1.0
 **/
public class Apple extends Fruit{
    @Override
    public void ripeCycle() {
        System.out.println("苹果的成熟周期是8个月");
    }
}

package com.dong.factory;

import com.dong.product.Fruit;
import com.dong.product.Weapon;

/**
 * 抽象工厂
 * @author dong
 * @version 1.0
 * @className AbstractFactory
 * @since 1.0
 **/
public abstract class AbstractFactory {
    public abstract Weapon getWeapon(String type);
    public abstract Fruit getFruit(String type);
}

package com.dong.factory;

import com.dong.product.Dagger;
import com.dong.product.Fruit;
import com.dong.product.Gun;
import com.dong.product.Weapon;

/**
 * 武器族工厂
 * @author dong
 * @version 1.0
 * @className WeaponFactory
 * @since 1.0
 **/
public class WeaponFactory extends AbstractFactory{

    public Weapon getWeapon(String type){
        if (type == null || type.trim().length() == 0) {
            return null;
        }
        if ("Gun".equals(type)) {
            return new Gun();
        } else if ("Dagger".equals(type)) {
            return new Dagger();
        } else {
            throw new RuntimeException("无法生产该武器");
        }
    }

    @Override
    public Fruit getFruit(String type) {
        return null;
    }
}

package com.dong.factory;

import com.dong.product.*;

/**
 * 水果族工厂
 * @author dong
 * @version 1.0
 * @className FruitFactory
 * @since 1.0
 **/
public class FruitFactory extends AbstractFactory{
    @Override
    public Weapon getWeapon(String type) {
        return null;
    }

    public Fruit getFruit(String type){
        if (type == null || type.trim().length() == 0) {
            return null;
        }
        if ("Orange".equals(type)) {
            return new Orange();
        } else if ("Apple".equals(type)) {
            return new Apple();
        } else {
            throw new RuntimeException("我家果园不产这种水果");
        }
    }
}

package com.dong.client;

import com.dong.factory.AbstractFactory;
import com.dong.factory.FruitFactory;
import com.dong.factory.WeaponFactory;
import com.dong.product.Fruit;
import com.dong.product.Weapon;

/**
 * @author dong
 * @version 1.0
 * @className Client
 * @since 1.0
 **/
public class Client {
    public static void main(String[] args) {
        // 客户端调用方法时只面向AbstractFactory调用方法。
        AbstractFactory factory = new WeaponFactory(); // 注意：这里的new WeaponFactory()可以采用 简单工厂模式 进行隐藏。
        Weapon gun = factory.getWeapon("Gun");
        Weapon dagger = factory.getWeapon("Dagger");

        gun.attack();
        dagger.attack();

        AbstractFactory factory1 = new FruitFactory(); // 注意：这里的new FruitFactory()可以采用 简单工厂模式 进行隐藏。
        Fruit orange = factory1.getFruit("Orange");
        Fruit apple = factory1.getFruit("Apple");

        orange.ripeCycle();
        apple.ripeCycle();
    }
}

 运行结果：

 总结：

抽象工厂模式的优缺点：

  • 优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
  • 缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在AbstractFactory里加代码，又要在具体的里面加代码。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/577950.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

chatgpt赋能python：Python父类调用子类：多态性的核心思想

chatgpt赋能python：Python父类调用子类：多态性的核心思想

Python父类调用子类：多态性的核心思想 多态性是面向对象编程(OOP)的核心思想之一，它允许不同的对象在调用同一个方法时产生不同的行为。Python是一门支持多态性的编程语言。在Python中，使用父类调用子类的方法是实现多态性的关键之一。 什么…
阅读更多...
考研C语言第五章

考研C语言第五章

5.2 数组基础知识 注意要点： 1.下标0开始 2.没有定义的地方是0 5.3 数组访问越界与数组传递 访问越界，定义超过前面定义的数组长度，占据了后面定义数据的地方 非常危险！ 在循环里面往往容易造成越界 数组传递 1.函数引用时…
阅读更多...
AI一键抠图

AI一键抠图

前言 由于需要批量抠图，原本是想用MODNet的，可惜最新的模型官方不开源，旧模型扣的人物边缘有白边。最后发现了PP飞桨。 飞桨（PaddlePaddle）以百度多年的深度学习技术研究和业务应用为基础，集深度学习核心训…
阅读更多...
【JDK】一、jdk17的下载与安装配置(图文说明超详细)

【JDK】一、jdk17的下载与安装配置(图文说明超详细)

JDK17的下载与安装 前言一、JDK17下载1、官方下载地址 （ Oracle中国的官方网站） 二、JDK17安装1、先看一下我现在的java版本和环境变量2、开始新的安装第一步：双击下载的jdk-17.0.7_windows-x64_bin.exe 进入到安装页面第二步：jdk…
阅读更多...
内存管理之内存寻址(笔记)

内存管理之内存寻址(笔记)

计算机体系结构中的核心问题之一就是如何有效的进行内存寻址。因为所有运算的前提都是要先从内存中取地数据。所以内存寻址技术在一定程度上代表了计算机技术。 1. 图灵机和冯诺依曼体系 图灵机：图灵机是一种通用自动的机器模型，通过二段无线延申的纸带…
阅读更多...
C++Primer——第一讲

C++Primer——第一讲

重制CPrimer 目录 一、第一个程序 二、代码 二、题目 前言 我们会从一个C程序开始&#xff0c;这里默认您已经安装了Dev-C或其他的IDE软件。 一、第一个程序 下面这串代码是可以输出“Hello world”的代码。 #include<bits/stdc.h> using namespace std; int main(){…
阅读更多...
Arduino+ESP8266 MCU开发板 ----带你开发DHT11温湿度开发项目

Arduino+ESP8266 MCU开发板 ----带你开发DHT11温湿度开发项目

目录 PC调试过程如图 手机APP可在各大商场APP中下载 手机APP调试结果/效果如图 ESP8266 MUC介绍 ESP8266 MUC主要特点&#xff1a; 步1&#xff1a;下载Arduino&#xff0c;本次不多做说明&#xff0c;本次使用的arduino软件为老版本的&#xff0c;新版本有关的问题本人…
阅读更多...
统计学的假设检验

统计学的假设检验

假设检验的核心其实就是反证法。反证法是数学中的一个概念&#xff0c;就是你要证明一个结论是正确的&#xff0c;那么先假设这个结论是错误的&#xff0c;然后以这个结论是错误的为前提条件进行推理&#xff0c;推理出来的结果与假设条件矛盾&#xff0c;这个时候就说明这个假…
阅读更多...
总结881

总结881

学习目标&#xff1a; 月目标&#xff1a;5月&#xff08;1800基础部分&#xff0c;背诵15篇短文&#xff09; 周目标&#xff1a;1800高等数学部分并完成错题记录&#xff0c;英语背3篇文章并回诵 每日必复习&#xff08;5分钟&#xff09; 前天错题纠错&#xff0c;线代部…
阅读更多...
Solidity拓展：数据类型的转换

Solidity拓展：数据类型的转换

1.数据类型隐式转换 (自动) 同一类型之间的转换:由低长度转换为高长度int8-int16-int32int256,但int不能自动转换成uint&#xff0c;因为放不下负数所以直接不让转换,且 int8 不能转换成 uint256 &#xff08;因为 uint256 不能涵盖某些值&#xff0c;例如&#xff0c; -1&…
阅读更多...
Android解决xutils数据库kotlin添加List数组问题

Android解决xutils数据库kotlin添加List数组问题

Android解决xutils数据库kotlin添加List数组问题 前言&#xff1a; 上一篇我们讲解了xutils中数据库版本升级的使用和问题&#xff0c;这篇博客讲解xutils中数据库添加list数据的问题&#xff0c;这个库真的是很强大&#xff0c;但是数据库的使用真不友好&#xff0c;添加一个…
阅读更多...
从零开始手搓一个STM32与机智云的小项目——硬件介绍

从零开始手搓一个STM32与机智云的小项目——硬件介绍

文章目录 前言硬件简介选型1.主控2.电源3.电机驱动4.舵机驱动5.USB转TTL6.其他模块 原理图绘制1.STM32最小系统1.电源输入2.晶振选择3.复位电路4.BOOT选择电路5.下载电路 2.电源部分及与PC通信部分3.功能模块的实现1.串口2.定时器输入捕获与输出比较3.硬件SPI4.ADC5.温湿度传感…
阅读更多...
学校食堂明厨亮灶 yolov8

学校食堂明厨亮灶 yolov8

学校食堂明厨亮灶可以yolov8网络模型技术&#xff0c;学校食堂明厨亮灶通过对厨师的穿戴情况行为举止等进行监测。YOLOv8 算法的核心特性和改动可以归结为如下&#xff1a;提供了一个全新的 SOTA 模型&#xff0c;包括 P5 640 和 P6 1280 分辨率的目标检测网络和基于 YOLACT 的…
阅读更多...
C++环形缓冲区设计与实现：从原理到应用的全方位解析

C++环形缓冲区设计与实现：从原理到应用的全方位解析

C环形缓冲区设计与实现&#xff1a;从原理到应用的全方位解析 一、环形缓冲区基础理论解析&#xff08;Basic Theory of Circular Buffer&#xff09;1.1 环形缓冲区的定义与作用&#xff08;Definition and Function of Circular Buffer&#xff09;1.2 环形缓冲区的基本原理&…
阅读更多...
SAP-MM-内向外向交货单

SAP-MM-内向外向交货单

1、内向&外向交货单概念 外向交货&#xff08;outbound delivery&#xff09;是用在客户与企业之间的交货单&#xff0c;而内向交货&#xff08;inbound delivery&#xff09;则是用在供应商与企业之间的交货单&#xff1b;换言之&#xff0c;外向交货多用于SD 模块&#…
阅读更多...
基于MAX-10 FPGA 超声波测距模块HC_SR04

基于MAX-10 FPGA 超声波测距模块HC_SR04

文章目录 一、介绍超声波测距模块HC_SR04二、模块框图三、模块编写1. 测距信号源2. 距离计算3. 数码管模块4. 顶层模块 四、实验现象总结 一、介绍超声波测距模块HC_SR04 HC-SR04是一种基于超声波的测距模块。该模块向前15度内发送超声波并接收回响&#xff0c;通过发出超声波…
阅读更多...
第一章:简单的C程序设计基础

第一章:简单的C程序设计基础

一、C语言词汇 在C语言中使用的词汇分为&#xff1a;关键字、标识符、常量、运算符、分隔符、注释符等。 1.1关键字 1.2标识符 在程序中使用的变量名或函数名等统称为标识符&#xff1b;标识符的命名规则如下&#xff1a; &#xff08;C语言区分大小写&#xff09; 不能是关…
阅读更多...
一个简单的基于C/S模型的TCP通信实例

一个简单的基于C/S模型的TCP通信实例

1 TCP协议 1.1 概念 TCP是一种面向连接的、可靠的协议&#xff0c;有点像打电话&#xff0c;双方拿起电话互通身份之后就建立了连接&#xff0c;然后说话就行了&#xff0c;这边说的话那边保证听得到&#xff0c;并且是按说话的顺序听到的&#xff0c;说完话挂机断开连接。也…
阅读更多...
2023 华为 Datacom-HCIE 真题题库 08--含解析

2023 华为 Datacom-HCIE 真题题库 08--含解析

单项选择 1.[试题编号&#xff1a;190385] &#xff08;单选题&#xff09;以下关于BGP/MPLSIPVPN路由交互的描述&#xff0c;错误的是哪一项? A、PE与CE之间交互的是IPv4路由信息 B、出口PE可以通过BGP、IGP或静态路由的方式向远端CE发送IPv4路由 C、入口PE将从CE接收到的I…
阅读更多...
数组（1）

数组（1）

文章目录 目录1. 一维数组的创建和初始化1.1 一维数组的创建1.2 一维数组的初始化 2. 一维数组的使用3. 一维数组在内存中的存储4. 二维数组的创建和初始化4.1 二维数组的创建4.2 二维数组的初始化 5. 二维数组的使用6. 二维数组在内存中的存储7. 数组越界8. 数组作为函数参数 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023