设计模式详解

Pure_Eyes2025-08-24 10:54

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

代码示例

java 复制代码 
// 产品接口
interface Shape {
    void draw();
}

// 具体产品：圆形
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}

// 具体产品：矩形
class Rectangle implements Shape {
    @Override
    public 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;
    }
}
Go 复制代码 
package main

import "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

代码示例

java 复制代码 
// 产品接口
interface Product {
    void operation();
}

// 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void operation() {
        System.out.println("执行ConcreteProductA的操作");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    @Override
    public void operation() {
        System.out.println("执行ConcreteProductB的操作");
    }
}

// 工厂接口
interface Factory {
    Product createProduct();
}

// 具体工厂A，负责创建ProductA
class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂B，负责创建ProductB
class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端代码
public class FactoryMethodDemo {
    public static void main(String[] args) {
        // 使用工厂A创建产品A
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.operation();
        
        // 使用工厂B创建产品B
        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.operation();
    }
}
Go 复制代码 
package main

import "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创建产品A
	var factoryA Factory = &ConcreteFactoryA{}
	productA := factoryA.CreateProduct()
	productA.Operation()
	
	// 使用工厂B创建产品B
	var factoryB Factory = &ConcreteFactoryB{}
	productB := factoryB.CreateProduct()
	productB.Operation()
}

1.3 抽象工厂

java 复制代码 
@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 <|-- ProductB2

ConcreteFactory1 --> ProductA1: creates
ConcreteFactory1 --> ProductB1: creates
ConcreteFactory2 --> ProductA2: creates
ConcreteFactory2 --> ProductB2: creates
ProductB1 --> AbstractProductA: uses
ProductB2 --> AbstractProductA: uses
@enduml

代码示例

java 复制代码 
// 抽象产品A
interface AbstractProductA {
    void operationA();
}

// 具体产品A1
class ProductA1 implements AbstractProductA {
    @Override
    public void operationA() {
        System.out.println("ProductA1的操作");
    }
}

// 具体产品A2
class ProductA2 implements AbstractProductA {
    @Override
    public void operationA() {
        System.out.println("ProductA2的操作");
    }
}

// 抽象产品B
interface AbstractProductB {
    void operationB();
    void anotherOperationB(AbstractProductA productA);
}

// 具体产品B1
class ProductB1 implements AbstractProductB {
    @Override
    public void operationB() {
        System.out.println("ProductB1的操作");
    }
    
    @Override
    public void anotherOperationB(AbstractProductA productA) {
        System.out.println("ProductB1与" + productA.getClass().getSimpleName() + "交互");
    }
}

// 具体产品B2
class ProductB2 implements AbstractProductB {
    @Override
    public void operationB() {
        System.out.println("ProductB2的操作");
    }
    
    @Override
    public void anotherOperationB(AbstractProductA productA) {
        System.out.println("ProductB2与" + productA.getClass().getSimpleName() + "交互");
    }
}

// 抽象工厂
interface AbstractFactory {
    AbstractProductA createProductA();
    AbstractProductB createProductB();
}

// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }
    
    @Override
    public AbstractProductB createProductB() {
        return new ProductB1();
    }
}

// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ProductA2();
    }
    
    @Override
    public AbstractProductB createProductB() {
        return new ProductB2();
    }
}

// 客户端代码
public class AbstractFactoryDemo {
    public static void main(String[] args) {
        // 使用工厂1创建产品族1
        AbstractFactory factory1 = new ConcreteFactory1();
        AbstractProductA productA1 = factory1.createProductA();
        AbstractProductB productB1 = factory1.createProductB();
        
        productA1.operationA();
        productB1.operationB();
        productB1.anotherOperationB(productA1);
        
        // 使用工厂2创建产品族2
        AbstractFactory factory2 = new ConcreteFactory2();
        AbstractProductA productA2 = factory2.createProductA();
        AbstractProductB productB2 = factory2.createProductB();
        
        productA2.operationA();
        productB2.operationB();
        productB2.anotherOperationB(productA2);
    }
}
Go 复制代码 
package main

import "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() AbstractProductA
	CreateProductB() 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创建产品族1
	var factory1 AbstractFactory = &ConcreteFactory1{}
	productA1 := factory1.CreateProductA()
	productB1 := factory1.CreateProductB()
	
	productA1.OperationA()
	productB1.OperationB()
	productB1.AnotherOperationB(productA1)
	
	// 使用工厂2创建产品族2
	var 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

代码示例

java 复制代码 
// 原型接口
interface Prototype {
    Prototype clone();
}

// 具体原型A
class ConcretePrototypeA implements Prototype {
    private String fieldA;
    
    public ConcretePrototypeA(String fieldA) {
        this.fieldA = fieldA;
    }
    
    // 实现克隆方法
    @Override
    public 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;
    }
    
    // 实现克隆方法
    @Override
    public 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());
    }
}
Go 复制代码 
package main

import "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

代码示例

java 复制代码 
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();
    
    @Override
    public void buildPartA() {
        product.addPart("部件A1");
    }
    
    @Override
    public void buildPartB() {
        product.addPart("部件B1");
    }
    
    @Override
    public Product getResult() {
        return product;
    }
}

// 具体建造者2
class ConcreteBuilder2 implements Builder {
    private Product product = new Product();
    
    @Override
    public void buildPartA() {
        product.addPart("部件A2");
    }
    
    @Override
    public void buildPartB() {
        product.addPart("部件B2");
    }
    
    @Override
    public 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();
    }
}
Go 复制代码 
package main

import "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.结构类型

相关推荐
pengzhuofan27 分钟前
Java设计模式-享元模式
java·设计模式·享元模式
希望_睿智39 分钟前
实战设计模式之解释器模式
c++·设计模式·架构
楚禾Noah5 小时前
【设计模式实战】原型模式 + 工厂模式：AI Agent 配置中心
人工智能·设计模式·原型模式
hai_qin6 小时前
三，设计模式-抽象工厂模式
c++·设计模式·抽象工厂模式
小白要加油努力17 小时前
C++设计模式--策略模式与观察者模式
开发语言·c++·设计模式
OEC小胖胖21 小时前
【React 设计模式】受控与非受控：解构 React 组件设计的核心模式
前端·react.js·设计模式·前端框架·web
pengzhuofan1 天前
Java设计模式-外观模式
java·设计模式·外观模式
long3161 天前
适配器模式 java demo
java·javascript·后端·程序人生·设计模式·适配器模式
##学无止境##1 天前
从青铜到王者：Java设计模式——代理模式
java·设计模式·代理模式
热门推荐
01UV安装并设置国内源02KGG转MP3工具|非KGM文件|解密音频03【踩坑笔记】50系显卡适配的 PyTorch 安装04蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接05Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code06Claude Code VSCode集成开发指南：AI编程助手完整配置07【2025.08.06最新版】Android Studio下载、安装及配置记录（自动下载sdk）0820个国内外主流AI绘画工具大汇总（最新免费可用~）092025最新国内服务器可用docker源仓库地址大全（2025年8月更新）10jdk21下载、安装（Windows、Linux、macOS）