设计模式详解

1.创建类型

1.1 简单工厂

@startuml
' 抽象产品接口
interface Product {+ Operation(): string
}' 具体产品A
class ConcreteProductA {+ Operation(): string
}' 具体产品B
class ConcreteProductB {+ Operation(): string
}' 工厂类
class Factory {+ CreateProduct(type: string): Product
}' 关系定义
ConcreteProductA --|> Product
ConcreteProductB --|> Product
Factory --> Product: 创建 >
@enduml

代码示例

// 产品接口
interface Shape {void draw();
}// 具体产品：圆形
class Circle implements Shape {@Overridepublic void draw() {System.out.println("绘制圆形");}
}// 具体产品：矩形
class Rectangle implements Shape {@Overridepublic void draw() {System.out.println("绘制矩形");}
}// 简单工厂类
class ShapeFactory {// 根据类型创建不同形状public static Shape getShape(String type) {if (type == null) {return null;}if (type.equalsIgnoreCase("CIRCLE")) {return new Circle();} else if (type.equalsIgnoreCase("RECTANGLE")) {return new Rectangle();}return null;}
}

package mainimport "fmt"// 产品接口
type Shape interface {Draw()
}// 具体产品：圆形
type Circle struct{}func (c *Circle) Draw() {fmt.Println("绘制圆形")
}// 具体产品：矩形
type Rectangle struct{}func (r *Rectangle) Draw() {fmt.Println("绘制矩形")
}// 简单工厂
type ShapeFactory struct{}func (f *ShapeFactory) CreateShape(shapeType string) Shape {switch shapeType {case "circle":return &Circle{}case "rectangle":return &Rectangle{}default:return nil}
}

1.2 工厂方法

@startuml
interface Product {+ operation(): void
}class ConcreteProductA implements Product {+ operation(): void
}class ConcreteProductB implements Product {+ operation(): void
}interface Factory {+ createProduct(): Product
}class ConcreteFactoryA implements Factory {+ createProduct(): Product
}class ConcreteFactoryB implements Factory {+ createProduct(): Product
}Factory <|-- ConcreteFactoryA
Factory <|-- ConcreteFactoryB
Product <|-- ConcreteProductA
Product <|-- ConcreteProductB
ConcreteFactoryA --> ConcreteProductA: creates
ConcreteFactoryB --> ConcreteProductB: creates
@enduml

代码示例

// 产品接口
interface Product {void operation();
}// 具体产品A
class ConcreteProductA implements Product {@Overridepublic void operation() {System.out.println("执行ConcreteProductA的操作");}
}// 具体产品B
class ConcreteProductB implements Product {@Overridepublic void operation() {System.out.println("执行ConcreteProductB的操作");}
}// 工厂接口
interface Factory {Product createProduct();
}// 具体工厂A，负责创建ProductA
class ConcreteFactoryA implements Factory {@Overridepublic Product createProduct() {return new ConcreteProductA();}
}// 具体工厂B，负责创建ProductB
class ConcreteFactoryB implements Factory {@Overridepublic Product createProduct() {return new ConcreteProductB();}
}// 客户端代码
public class FactoryMethodDemo {public static void main(String[] args) {// 使用工厂A创建产品AFactory factoryA = new ConcreteFactoryA();Product productA = factoryA.createProduct();productA.operation();// 使用工厂B创建产品BFactory factoryB = new ConcreteFactoryB();Product productB = factoryB.createProduct();productB.operation();}
}


package mainimport "fmt"// 产品接口
type Product interface {Operation()
}// 具体产品A
type ConcreteProductA struct{}func (p *ConcreteProductA) Operation() {fmt.Println("执行ConcreteProductA的操作")
}// 具体产品B
type ConcreteProductB struct{}func (p *ConcreteProductB) Operation() {fmt.Println("执行ConcreteProductB的操作")
}// 工厂接口
type Factory interface {CreateProduct() Product
}// 具体工厂A
type ConcreteFactoryA struct{}func (f *ConcreteFactoryA) CreateProduct() Product {return &ConcreteProductA{}
}// 具体工厂B
type ConcreteFactoryB struct{}func (f *ConcreteFactoryB) CreateProduct() Product {return &ConcreteProductB{}
}// 客户端代码
func main() {// 使用工厂A创建产品Avar factoryA Factory = &ConcreteFactoryA{}productA := factoryA.CreateProduct()productA.Operation()// 使用工厂B创建产品Bvar factoryB Factory = &ConcreteFactoryB{}productB := factoryB.CreateProduct()productB.Operation()
}

1.3 抽象工厂

@startuml
interface AbstractFactory {+ createProductA(): AbstractProductA+ createProductB(): AbstractProductB
}class ConcreteFactory1 implements AbstractFactory {+ createProductA(): AbstractProductA+ createProductB(): AbstractProductB
}class ConcreteFactory2 implements AbstractFactory {+ createProductA(): AbstractProductA+ createProductB(): AbstractProductB
}interface AbstractProductA {+ operationA(): void
}class ProductA1 implements AbstractProductA {+ operationA(): void
}class ProductA2 implements AbstractProductA {+ operationA(): void
}interface AbstractProductB {+ operationB(): void+ anotherOperationB(AbstractProductA): void
}class ProductB1 implements AbstractProductB {+ operationB(): void+ anotherOperationB(AbstractProductA): void
}class ProductB2 implements AbstractProductB {+ operationB(): void+ anotherOperationB(AbstractProductA): void
}AbstractFactory <|-- ConcreteFactory1
AbstractFactory <|-- ConcreteFactory2
AbstractProductA <|-- ProductA1
AbstractProductA <|-- ProductA2
AbstractProductB <|-- ProductB1
AbstractProductB <|-- ProductB2ConcreteFactory1 --> ProductA1: creates
ConcreteFactory1 --> ProductB1: creates
ConcreteFactory2 --> ProductA2: creates
ConcreteFactory2 --> ProductB2: creates
ProductB1 --> AbstractProductA: uses
ProductB2 --> AbstractProductA: uses
@enduml

代码示例

// 抽象产品A
interface AbstractProductA {void operationA();
}// 具体产品A1
class ProductA1 implements AbstractProductA {@Overridepublic void operationA() {System.out.println("ProductA1的操作");}
}// 具体产品A2
class ProductA2 implements AbstractProductA {@Overridepublic void operationA() {System.out.println("ProductA2的操作");}
}// 抽象产品B
interface AbstractProductB {void operationB();void anotherOperationB(AbstractProductA productA);
}// 具体产品B1
class ProductB1 implements AbstractProductB {@Overridepublic void operationB() {System.out.println("ProductB1的操作");}@Overridepublic void anotherOperationB(AbstractProductA productA) {System.out.println("ProductB1与" + productA.getClass().getSimpleName() + "交互");}
}// 具体产品B2
class ProductB2 implements AbstractProductB {@Overridepublic void operationB() {System.out.println("ProductB2的操作");}@Overridepublic void anotherOperationB(AbstractProductA productA) {System.out.println("ProductB2与" + productA.getClass().getSimpleName() + "交互");}
}// 抽象工厂
interface AbstractFactory {AbstractProductA createProductA();AbstractProductB createProductB();
}// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {@Overridepublic AbstractProductA createProductA() {return new ProductA1();}@Overridepublic AbstractProductB createProductB() {return new ProductB1();}
}// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {@Overridepublic AbstractProductA createProductA() {return new ProductA2();}@Overridepublic AbstractProductB createProductB() {return new ProductB2();}
}// 客户端代码
public class AbstractFactoryDemo {public static void main(String[] args) {// 使用工厂1创建产品族1AbstractFactory factory1 = new ConcreteFactory1();AbstractProductA productA1 = factory1.createProductA();AbstractProductB productB1 = factory1.createProductB();productA1.operationA();productB1.operationB();productB1.anotherOperationB(productA1);// 使用工厂2创建产品族2AbstractFactory factory2 = new ConcreteFactory2();AbstractProductA productA2 = factory2.createProductA();AbstractProductB productB2 = factory2.createProductB();productA2.operationA();productB2.operationB();productB2.anotherOperationB(productA2);}
}

package mainimport "fmt"// 抽象产品A
type AbstractProductA interface {OperationA()
}// 具体产品A1
type ProductA1 struct{}func (p *ProductA1) OperationA() {fmt.Println("ProductA1的操作")
}// 具体产品A2
type ProductA2 struct{}func (p *ProductA2) OperationA() {fmt.Println("ProductA2的操作")
}// 抽象产品B
type AbstractProductB interface {OperationB()AnotherOperationB(AbstractProductA)
}// 具体产品B1
type ProductB1 struct{}func (p *ProductB1) OperationB() {fmt.Println("ProductB1的操作")
}func (p *ProductB1) AnotherOperationB(productA AbstractProductA) {fmt.Printf("ProductB1与%T交互\n", productA)
}// 具体产品B2
type ProductB2 struct{}func (p *ProductB2) OperationB() {fmt.Println("ProductB2的操作")
}func (p *ProductB2) AnotherOperationB(productA AbstractProductA) {fmt.Printf("ProductB2与%T交互\n", productA)
}// 抽象工厂
type AbstractFactory interface {CreateProductA() AbstractProductACreateProductB() AbstractProductB
}// 具体工厂1
type ConcreteFactory1 struct{}func (f *ConcreteFactory1) CreateProductA() AbstractProductA {return &ProductA1{}
}func (f *ConcreteFactory1) CreateProductB() AbstractProductB {return &ProductB1{}
}// 具体工厂2
type ConcreteFactory2 struct{}func (f *ConcreteFactory2) CreateProductA() AbstractProductA {return &ProductA2{}
}func (f *ConcreteFactory2) CreateProductB() AbstractProductB {return &ProductB2{}
}// 客户端代码
func main() {// 使用工厂1创建产品族1var factory1 AbstractFactory = &ConcreteFactory1{}productA1 := factory1.CreateProductA()productB1 := factory1.CreateProductB()productA1.OperationA()productB1.OperationB()productB1.AnotherOperationB(productA1)// 使用工厂2创建产品族2var factory2 AbstractFactory = &ConcreteFactory2{}productA2 := factory2.CreateProductA()productB2 := factory2.CreateProductB()productA2.OperationA()productB2.OperationB()productB2.AnotherOperationB(productA2)
}

1.4 原型模式

@startuml
interface Prototype {+ clone(): Prototype
}class ConcretePrototypeA implements Prototype {- fieldA: String+ clone(): Prototype+ setFieldA(String): void+ getFieldA(): String
}class ConcretePrototypeB implements Prototype {- fieldB: int+ clone(): Prototype+ setFieldB(int): void+ getFieldB(): int
}class Client {+ operation(): void
}Client --> Prototype: uses
@enduml

代码示例

// 原型接口
interface Prototype {Prototype clone();
}// 具体原型A
class ConcretePrototypeA implements Prototype {private String fieldA;public ConcretePrototypeA(String fieldA) {this.fieldA = fieldA;}// 实现克隆方法@Overridepublic Prototype clone() {return new ConcretePrototypeA(this.fieldA);}public String getFieldA() {return fieldA;}public void setFieldA(String fieldA) {this.fieldA = fieldA;}
}// 具体原型B
class ConcretePrototypeB implements Prototype {private int fieldB;public ConcretePrototypeB(int fieldB) {this.fieldB = fieldB;}// 实现克隆方法@Overridepublic Prototype clone() {return new ConcretePrototypeB(this.fieldB);}public int getFieldB() {return fieldB;}public void setFieldB(int fieldB) {this.fieldB = fieldB;}
}// 客户端代码
public class PrototypeDemo {public static void main(String[] args) {// 创建原型实例Prototype prototypeA = new ConcretePrototypeA("初始值A");Prototype prototypeB = new ConcretePrototypeB(100);// 克隆对象Prototype cloneA = prototypeA.clone();Prototype cloneB = prototypeB.clone();// 修改克隆对象的属性（不会影响原型）((ConcretePrototypeA) cloneA).setFieldA("修改后的值A");((ConcretePrototypeB) cloneB).setFieldB(200);// 打印结果System.out.println("原型A: " + ((ConcretePrototypeA) prototypeA).getFieldA());System.out.println("克隆A: " + ((ConcretePrototypeA) cloneA).getFieldA());System.out.println("原型B: " + ((ConcretePrototypeB) prototypeB).getFieldB());System.out.println("克隆B: " + ((ConcretePrototypeB) cloneB).getFieldB());}
}


package mainimport "fmt"// 原型接口
type Prototype interface {Clone() Prototype
}// 具体原型A
type ConcretePrototypeA struct {FieldA string
}func (c *ConcretePrototypeA) Clone() Prototype {return &ConcretePrototypeA{FieldA: c.FieldA}
}// 具体原型B
type ConcretePrototypeB struct {FieldB int
}func (c *ConcretePrototypeB) Clone() Prototype {return &ConcretePrototypeB{FieldB: c.FieldB}
}// 客户端代码
func main() {// 创建原型实例prototypeA := &ConcretePrototypeA{FieldA: "初始值A"}prototypeB := &ConcretePrototypeB{FieldB: 100}// 克隆对象cloneA := prototypeA.Clone().(*ConcretePrototypeA)cloneB := prototypeB.Clone().(*ConcretePrototypeB)// 修改克隆对象的属性（不会影响原型）cloneA.FieldA = "修改后的值A"cloneB.FieldB = 200// 打印结果fmt.Printf("原型A: %s\n", prototypeA.FieldA)fmt.Printf("克隆A: %s\n", cloneA.FieldA)fmt.Printf("原型B: %d\n", prototypeB.FieldB)fmt.Printf("克隆B: %d\n", cloneB.FieldB)
}

1.5 建造者模式

@startuml
class Product {- parts: List<String>+ addPart(String): void+ show(): void
}interface Builder {+ buildPartA(): void+ buildPartB(): void+ getResult(): Product
}class ConcreteBuilder1 implements Builder {- product: Product+ buildPartA(): void+ buildPartB(): void+ getResult(): Product
}class ConcreteBuilder2 implements Builder {- product: Product+ buildPartA(): void+ buildPartB(): void+ getResult(): Product
}class Director {- builder: Builder+ setBuilder(Builder): void+ construct(): void
}Director --> Builder: uses
Builder --> Product: creates
@enduml

代码示例

import java.util.ArrayList;
import java.util.List;// 产品类
class Product {private List<String> parts = new ArrayList<>();public void addPart(String part) {parts.add(part);}public void show() {System.out.println("产品组成:");for (String part : parts) {System.out.println("- " + part);}}
}// 建造者接口
interface Builder {void buildPartA();void buildPartB();Product getResult();
}// 具体建造者1
class ConcreteBuilder1 implements Builder {private Product product = new Product();@Overridepublic void buildPartA() {product.addPart("部件A1");}@Overridepublic void buildPartB() {product.addPart("部件B1");}@Overridepublic Product getResult() {return product;}
}// 具体建造者2
class ConcreteBuilder2 implements Builder {private Product product = new Product();@Overridepublic void buildPartA() {product.addPart("部件A2");}@Overridepublic void buildPartB() {product.addPart("部件B2");}@Overridepublic Product getResult() {return product;}
}// 指挥者
class Director {private Builder builder;public void setBuilder(Builder builder) {this.builder = builder;}public void construct() {builder.buildPartA();builder.buildPartB();}
}// 客户端代码
public class BuilderDemo {public static void main(String[] args) {Director director = new Director();// 使用建造者1构建产品Builder builder1 = new ConcreteBuilder1();director.setBuilder(builder1);director.construct();Product product1 = builder1.getResult();product1.show();// 使用建造者2构建产品Builder builder2 = new ConcreteBuilder2();director.setBuilder(builder2);director.construct();Product product2 = builder2.getResult();product2.show();}
}


package mainimport "fmt"// 产品类
type Product struct {parts []string
}func (p *Product) AddPart(part string) {p.parts = append(p.parts, part)
}func (p *Product) Show() {fmt.Println("产品组成:")for _, part := range p.parts {fmt.Printf("- %s\n", part)}
}// 建造者接口
type Builder interface {BuildPartA()BuildPartB()GetResult() *Product
}// 具体建造者1
type ConcreteBuilder1 struct {product *Product
}func NewConcreteBuilder1() *ConcreteBuilder1 {return &ConcreteBuilder1{product: &Product{},}
}func (b *ConcreteBuilder1) BuildPartA() {b.product.AddPart("部件A1")
}func (b *ConcreteBuilder1) BuildPartB() {b.product.AddPart("部件B1")
}func (b *ConcreteBuilder1) GetResult() *Product {return b.product
}// 具体建造者2
type ConcreteBuilder2 struct {product *Product
}func NewConcreteBuilder2() *ConcreteBuilder2 {return &ConcreteBuilder2{product: &Product{},}
}func (b *ConcreteBuilder2) BuildPartA() {b.product.AddPart("部件A2")
}func (b *ConcreteBuilder2) BuildPartB() {b.product.AddPart("部件B2")
}func (b *ConcreteBuilder2) GetResult() *Product {return b.product
}// 指挥者
type Director struct {builder Builder
}func (d *Director) SetBuilder(builder Builder) {d.builder = builder
}func (d *Director) Construct() {d.builder.BuildPartA()d.builder.BuildPartB()
}// 客户端代码
func main() {director := &Director{}// 使用建造者1构建产品builder1 := NewConcreteBuilder1()director.SetBuilder(builder1)director.Construct()product1 := builder1.GetResult()product1.Show()// 使用建造者2构建产品builder2 := NewConcreteBuilder2()director.SetBuilder(builder2)director.Construct()product2 := builder2.GetResult()product2.Show()
}

2.行为类型

3.结构类型

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

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

相关文章

前端查漏补缺

前端查漏补缺

插槽默认、具名&#xff08;多个插槽&#xff09;、作用域&#xff08;接收子组件数据&#xff09;//具名 <div class"container"><header><slot name"header"></slot></header><main><slot></slot></…
阅读更多...
网络协议UDP、TCP

网络协议UDP、TCP

一、网络协议 UDPUDP用户数据报协议&#xff1a;传输层网络编程模型B/S模型&#xff1a;browser/server&#xff08;浏览器/服务器&#xff09;客户端是通用的客户端&#xff08;浏览器&#xff09;一般只做服务器开发客户端要加载的数据均来自服务器C/S模型&#xff1a;client…
阅读更多...
STM32 TIM_SelectInputTrigger()函数

STM32 TIM_SelectInputTrigger()函数

一、函数功能与定位​TIM_SelectInputTrigger()是STM32定时器外设的关键配置函数&#xff0c;用于设置从模式定时器的触发源&#xff08;Trigger Source&#xff09;​。其核心作用是将定时器的内部事件或外部信号映射为触发信号&#xff08;TRGI&#xff09;&#xff0c;进而控…
阅读更多...
Lecture 6 Kernels, Triton 课程笔记

Lecture 6 Kernels, Triton 课程笔记

本讲座&#xff1a;基准测试/分析 编写内核 总结 编程模型&#xff08;PyTorch、Triton、PTX&#xff09;与硬件之间的差距 > 性能奥秘 理解扩展的基准测试 用于理解 PyTorch 函数内部结构的分析&#xff08;用内核触底&#xff09; 看 PTX 汇编&#xff0c;了解 CUDA 内核…
阅读更多...
Spring Boot 整合网易163邮箱发送邮件实现找回密码功能

Spring Boot 整合网易163邮箱发送邮件实现找回密码功能

在开发用户系统时&#xff0c;发送邮件是一项常见需求&#xff0c;例如用户忘记密码时&#xff0c;通过邮箱发送验证码来验证身份并重置密码。本文将结合 Spring Boot 和 163 邮箱&#xff0c;演示如何实现邮件发送功能。 一、前提条件 普通用户的 163 邮箱可以在 Spring Boot…
阅读更多...
如何在mac玩windows游戏？3个工具推荐，不用换电脑！

如何在mac玩windows游戏？3个工具推荐，不用换电脑！

Mac电脑虽然很流畅&#xff0c;但它也存在局限性&#xff0c;其中一点游戏玩家应该深有体会&#xff0c;那就是无法直接玩Windows专属游戏&#xff0c;只能对着琳琅满目的游戏望眼欲穿。别急&#xff0c;我有办法让你在mac玩windows游戏&#xff0c;下面就来分享我的经验。一、…
阅读更多...
自回归（Auto-Regressive, AR），自回归图像生成过程

自回归（Auto-Regressive, AR），自回归图像生成过程

根据论文中“**T2I Generation via Next-Token Prediction**”一节&#xff0c;自回归&#xff08;Auto-Regressive, AR&#xff09;文本到图像&#xff08;T2I&#xff09;模型的图像生成过程可分为三个主要步骤&#xff0c;其原理和损失函数如下&#xff1a;---### &#x1f…
阅读更多...
在mysql中,modify ,change ,rename to的作用是什么

在mysql中,modify ,change ,rename to的作用是什么

在 MySQL 中&#xff0c;MODIFY、CHANGE 和 RENAME TO 都是 ALTER TABLE 语句的一部分&#xff0c;用于修改表的结构&#xff0c;但它们的作用和使用场景有所不同。1. MODIFY作用&#xff1a;用于修改表中现有列的定义&#xff0c;但不能修改列名。你可以使用 MODIFY 来更改列的…
阅读更多...
【JVM】JVM的内存结构是怎样的？

【JVM】JVM的内存结构是怎样的？

JVM的内存结构是Java程序运行时内存管理的核心&#xff0c;不同区域有明确的职责。 一、整体划分 包括两大部分&#xff0c;分为线程私有区域(随线程创建/销毁&#xff0c;无需垃圾回收)和线程共享区域(所有线程共用&#xff0c;需要垃圾回收管理)。 线程私有区域&#xff1a;程…
阅读更多...
青少年软件编程（python五级）等级考试试卷-客观题（2023年12月）

青少年软件编程（python五级）等级考试试卷-客观题（2023年12月）

更多内容和历年真题请查看网站&#xff1a;【试卷中心 -----> 电子学会 ----> 机器人技术 ----> 五级】 网站链接 青少年软件编程历年真题模拟题实时更新 青少年软件编程&#xff08;python五级&#xff09;等级考试试卷-客观题&#xff08;2023年12月&#xff0…
阅读更多...
网络编程-创建TCP协议服务器

网络编程-创建TCP协议服务器

int socket(int domain, int type, int protocol);头文件&#xff1a; #include <sys/socket.h>#include <netinet/in.h> #include <netinet/ip.h>int skt_tcpfd;int domain;skt_tcpfdsocket(AF_INET,SOCK_STREAM,0);int bind(int sockfd, const struct soc…
阅读更多...
ruoyi框架角色分配用户

ruoyi框架角色分配用户

分配用户&#xff0c;不要将当前正在登录的用户绑定。否则&#xff0c;在加入当前用户之后&#xff0c;取消或者添加其他用户时会被注销当前登录。
阅读更多...
Java Stream常见函数与应用案例

Java Stream常见函数与应用案例

1. Java Stream核心概念与基础函数 1.1 Stream API的设计哲学与核心特性 Java Stream API的设计哲学源于函数式编程范式&#xff0c;其核心特性体现在数据处理模式的转变上。与传统集合操作相比&#xff0c;Stream API采用声明式编程风格&#xff0c;支持链式调用&#xff0c;显…
阅读更多...
【Canvas与徽章】中国制造金色玻璃光徽章

【Canvas与徽章】中国制造金色玻璃光徽章

【成图】【代码】<!DOCTYPE html> <html lang"utf-8"> <meta http-equiv"Content-Type" content"text/html; charsetutf-8"/> <head><title>中国制造金色玻璃光徽章 Draft1</title><style type"tex…
阅读更多...
终结系统裸奔：Debian老旧版本安全加固终极指南

终结系统裸奔：Debian老旧版本安全加固终极指南

核心警示：Debian 8与10已结束官方支持，暴露于0day漏洞风险中。本文提供的加固方案仅为迁移前的临时防护措施，非长久之计。 一、老旧Debian系统的致命隐患 支持状态： Debian 8（Jessie）：2018年终止安全更新 Debian 10（Buster）：2024年7月结束主流支持 风险清单： 无补…
阅读更多...
Ape.Volo项目源码学习（1：源码下载及运行）

Ape.Volo项目源码学习（1：源码下载及运行）

Ape.Volo项目是基于 .Net 8 、SqlSugar、Vue2.x、RBAC、前后端分离开箱则用的中后台快速开发框架&#xff0c;其使用Async/Await异步编程&#xff0c;支持CodeFirst模式、RabbitMQ/RedisMQ消息队列、CORS 跨域配置、数据库操作&#xff08;读写分离、多库、分表&#xff09;、支…
阅读更多...
2-4.Python 编码基础 - 流程控制（判断语句、循环语句、break 语句与 continue 语句）

2-4.Python 编码基础 - 流程控制（判断语句、循环语句、break 语句与 continue 语句）

一、判断语句 1、if 语句 &#xff08;1&#xff09;基本格式 if 【判断条件】:【满足条件时执行的代码块】&#xff08;2&#xff09;演示 number 10if number > 0:print("这个数是正数")# 输出结果这个数是正数2、if - else 语句 &#xff08;1&#xff09;基本…
阅读更多...
大模型自我进化框架SE-Agent：开启软件工程自动化新时代

大模型自我进化框架SE-Agent：开启软件工程自动化新时代

一、引言&#xff1a;当大模型学会“自我进化” 在软件开发领域&#xff0c;传统模式下人类工程师面对复杂任务时&#xff0c;往往需要经历反复调试、多轮迭代才能产出高质量代码。而随着大语言模型&#xff08;LLM&#xff09;的兴起&#xff0c;一种名为**SE-Agent&#xff…
阅读更多...
UE官方文档学习 C++ TAarry 查询（四）多种查询方式

UE官方文档学习 C++ TAarry 查询（四）多种查询方式

一.IndexofByKey 返回索引通过值&#xff0c;返回来查找键。二IndexOfByPredicate通过定义二元谓词&#xff0c;来判定是否有符合谓词判定的元素。符合条件True的&#xff0c;才返回Index。这里所谓Lamda,函数就是 把函数当作参数输入&#xff0c;里面的参数值传递前加个[]。这…
阅读更多...
根据Wireshark捕获数据包时间和长度绘制电脑发射信号波形

根据Wireshark捕获数据包时间和长度绘制电脑发射信号波形

下一期&#xff1a; 根据Wireshark捕获数据包时间和长度绘制路由器发送给电脑数据的信号波形-CSDN博客 一、Wireshark采集数据 数据格式&#xff1a; 在我的另一篇博客中详细介绍了怎么导出数据&#xff1a; Wireshark导出数据包时间和长度-CSDN博客 通过MATLAB加载数据&a…
阅读更多...
最新文章

Copyright @ 2022~2023