当前位置： 首页 > web >正文

设计模式详解

web 2025/8/24 12:00:43

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.xdnf.cn/news/18706.html

相关文章：

  • TypeScript变量声明讲解
  • 个人思考与发展
  • 快速了解命令行界面(CLI)的行编辑模式
  • docker：compose
  • 【PSINS工具箱】MATLAB例程，平面上的组合导航，观测量为位置、速度、航向角，共5维。状态量为经典的15维
  • ModbusTCP与EtherNet/IP协议转换：工控机驱动步进电机完整教程
  • 智慧矿山误报率↓83%！陌讯多模态融合算法在矿用设备监控的落地优化
  • 安装即是已注册，永久可用！
  • Sql server的行转列
  • 数据结构：顺序表
  • C# 项目“交互式展厅管理客户端“针对的是“.NETFramework,Version=v4.8”，但此计算机上没有安装它。
  • 玳瑁的嵌入式日记D24-0823（数据结构）
  • 【基础-判断】使用http模块发起网络请求时，必须要使用on(‘headersReceive’）订阅请求头，请求才会成功。
  • 游戏广告投放数据分析项目：拆解投放的“流量密码”
  • 图像边缘检测
  • qwen2.5vl(2):lora 微调训练及代码讲解
  • Android Studio下载gradle文件很慢的捷径之路
  • 个人禁食伴侣FastTrack
  • 数据库类型与应用场景全解析：从传统关系型到新兴向量数据库
  • MySQL深分页的处理方案
  • React学习（十一）
  • 深入理解 React useEffect
  • 三、Bpmnjs 核心组件与架构介绍
  • 【c++进阶系列】：万字详解多态
  • 分库分表系列-基础内容
  • piecewise jerk算法介绍
  • 密码实现安全基础篇 . KAT（已知答案测试）技术解析与实践
  • SpringBoot自动配置原理解析
  • Reactor 反应堆模式
  • 游游的数组询问