10.md

• author

第10节 原型模式

⬆️上一节🔗⬇️下一节🔗

❤️💕💕Java和Golang的设计模式，设计模式介绍、创建者模式、结构型模式、行为型模式。Myblog:http://nsddd.top

---

[TOC]

way

当我们需要创建一个新对象时，可以使用原型模式。在该模式中，创建新对象的过程是通过克隆现有对象而不是通过实例化构造函数来完成的。这种方式可以提高对象创建的效率和灵活性，避免了每次都进行重复的初始化过程。

使用场景：

1. 当创建新对象的过程非常复杂、耗时或者需要大量资源时，可以使用原型模式来提高效率。
2. 当需要创建多个类型相同但属性值有所不同的对象时，可以使用原型模式来避免重复的初始化过程。
3. 当希望代码更加灵活、可扩展时，可以使用原型模式来动态生成新对象。

需要注意的是，当使用原型模式时，必须确保原始对象与副本对象之间是相互独立的，即修改一个对象的属性值不应该影响到其他对象。

在 Golang 中，原型模式的实现需要满足以下要素：

1. 抽象原型角色：定义用于复制现有对象的Clone()方法。
2. 具体原型角色：实现抽象原型角色中的Clone()方法，并定义自己的属性和方法。
3. 客户端角色：使用具体原型角色中的Clone()方法来复制对象，并进行相关操作。

实现方法

在Go语言中，原型模式可以通过实现一个 Clone() 方法来完成。该方法会返回当前对象的一个副本，其属性值与原始对象相同。具体实现方式如下：

type Prototype interface {
    Clone() Prototype
}

type ConcretePrototype struct {
    // 属性定义
}

func (p *ConcretePrototype) Clone() Prototype {
    return &ConcretePrototype{
        // 属性赋值
    }
}

在上面的代码中，我们定义了一个Prototype接口，其中包含一个Clone()方法。然后我们定义了一个具体的实现类ConcretePrototype，它包含了一些属性。在Clone()方法中，我们创建了一个新的ConcretePrototype对象，并将其属性值设置为与原始对象相同。

当需要创建新对象时，我们可以直接调用原始对象的Clone()方法，以获得一个与原始对象相同的副本。

var original = &ConcretePrototype{
    // 初始属性值
}

var copy1 = original.Clone().(*ConcretePrototype)
var copy2 = original.Clone().(*ConcretePrototype)

在上面的代码中，我们首先创建了一个原始对象original。然后我们使用原始对象的Clone()方法来创建两个副本copy1和copy2，它们的属性值与原始对象相同。

完整代码

package main

import "fmt"

// 抽象原型角色：声明用于复制自己的方法
type Prototype interface {
    Clone() Prototype
}

// 具体原型角色：实现Clone()方法并定义自己的属性和方法
type ConcretePrototype struct {
    name string
    age  int
}

func (cp *ConcretePrototype) Clone() Prototype {
    return &ConcretePrototype{
        name: cp.name,
        age:  cp.age,
    }
}

func (p *ConcretePrototype) GetName() string {
    return p.name
}

func (p *ConcretePrototype) SetName(name string) {
    p.name = name
}

func (p *ConcretePrototype) GetAge() int {
    return p.age
}

func (p *ConcretePrototype) SetAge(age int) {
    p.age = age
}

// 客户端角色：调用具体原型角色的Clone()方法来复制对象，并进行相关操作
func main() {
    // 我们只需要调用一次构造方法，后面都是复制的
    original := &ConcretePrototype{name: "Original", age: 18}
    copy1 := original.Clone().(*ConcretePrototype)
    copy2 := original.Clone().(*ConcretePrototype)

    fmt.Printf("Original name: %s, age: %d\n", original.GetName(), original.GetAge())
    fmt.Printf("Copy 1 name: %s, age: %d\n", copy1.GetName(), copy1.GetAge())
    fmt.Printf("Copy 2 name: %s, age: %d\n", copy2.GetName(), copy2.GetAge())

    copy1.SetName("Copy 1")
    copy2.SetName("Copy 2")
    copy1.SetAge(20)
    copy2.SetAge(22)

    fmt.Printf("Original name: %s, age: %d\n", original.GetName(), original.GetAge())
    fmt.Printf("Copy 1 name: %s, age: %d\n", copy1.GetName(), copy1.GetAge())
    fmt.Printf("Copy 2 name: %s, age: %d\n", copy2.GetName(), copy2.GetAge())
}

🚀 编译结果如下：

 ./main
Original name: Original, age: 18
Copy 1 name: Original, age: 18
Copy 2 name: Original, age: 18
Original name: Original, age: 18
Copy 1 name: Copy 1, age: 20
Copy 2 name: Copy 2, age: 22

优点

1. 提高对象创建的效率：使用原型模式可以避免每次都进行重复的初始化过程，从而提高对象创建的效率。
2. 提高代码灵活性和可扩展性：通过动态生成新对象，原型模式可以使代码更加灵活和可扩展。
3. 简化对象创建的过程：使用原型模式可以将对象创建的过程简化为复制现有对象，省去了繁琐的构造函数实现。
4. 避免对原始对象的修改：在使用原型模式时，每个副本对象都是相互独立的，修改一个对象的属性值不会影响到其他对象。
5. 方便动态获取新对象的方式：使用原型模式可以方便地根据需要动态生成新对象，无需预先定义。

END 链接

• ⬆️上一节🔗⬇️下一节🔗

• Ⓜ️回到目录🏠

• 🫵参与贡献💞❤️‍🔥💖)

• ✴️版权声明 © :本书所有内容遵循CC-BY-SA 3.0协议（署名-相同方式共享）©