GPT省流

简单工厂模式 🏭

1.1 原理 🧠

• 隐藏了对象创建的具体实现，对客户端暴露一个接口来创建对象。
• 通过一个工厂类提供对象实例化的方法，不直接暴露创建逻辑。

1.2 使用场景 🎭

• 适用于需要创建不同类型对象的场景，例如在游戏中创建不同类型的角色（战士、法师等）。

1.3 示例代码 💻

• 使用Go语言实现了一个CharacterFactory类来创建不同类型的角色对象（战士、法师）。

工厂模式 🏗️

2.1 原理 🧠

• 将对象创建的任务推迟到子类中。
• 提供一个创建对象的接口，让子类决定具体创建哪个类的实例。

2.2 使用场景 🎭

• 适用于需要根据不同条件创建不同对象的场景，例如为不同难度级别创建不同怪物。

2.3 示例代码 💻

• 使用Go语言实现了MonsterFactory接口及其具体实现类（EasyMonsterFactory和HardMonsterFactory），根据难度创建不同的怪物对象。

抽象工厂模式 🏙️

3.1 原理 🧠

• 提供一个创建一系列相关对象的接口，而不需要明确指定具体类。
• 确保创建的对象可以相互配合使用。

3.2 使用场景 🎭

• 适用于需要创建一整套相关对象的场景，例如根据游戏主题（中世纪、未来）创建相关的角色、武器和环境。

3.3 示例代码 💻

• 使用Go语言实现了GameElementFactory接口及其具体实现（MedievalFactory和FutureFactory），分别创建中世纪和未来主题的角色、武器和环境。

1. 简单工厂模式

简单工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式。

1.1 原理

• 在简单工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑
• 是通过使用一个共同的接口来指向新创建的对象

1.2 使用场景

假设我们正在开发一个游戏，需要创建不同类型的角色（如战士、法师、弓箭手）。我们可以使用简单工厂模式来管理角色的创建。

1.3 示例代码

package main

import "fmt"

// Character 接口
type Character interface {
    Attack()
}

// Warrior 结构体
type Warrior struct{}

func (w *Warrior) Attack() {
    fmt.Println("战士使用剑攻击")
}

// Mage 结构体
type Mage struct{}

func (m *Mage) Attack() {
    fmt.Println("法师使用魔法攻击")
}

// CharacterFactory 简单工厂
type CharacterFactory struct{}

func (cf *CharacterFactory) CreateCharacter(characterType string) Character {
    switch characterType {
    case "warrior":
        return &Warrior{}
    case "mage":
        return &Mage{}
    default:
        return nil
    }
}

func main() {
    factory := &CharacterFactory{}

    warrior := factory.CreateCharacter("warrior")
    warrior.Attack()

    mage := factory.CreateCharacter("mage")
    mage.Attack()
}

2. 工厂模式

工厂模式是简单工厂模式的进阶版本，它定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。

2.1 原理

• 工厂方法模式将对象的实例化推迟到子类
• 为创建对象定义一个接口，让子类决定实例化哪一个工厂类

2.2 使用场景

继续我们的游戏开发例子，假设我们现在需要为不同的游戏难度级别创建不同的怪物。我们可以使用工厂模式来管理怪物的创建。

2.3 示例代码

package main

import "fmt"

// Monster 接口
type Monster interface {
    Attack()
}

// EasyMonster 结构体
type EasyMonster struct{}

func (e *EasyMonster) Attack() {
    fmt.Println("简单怪物发动弱攻击")
}

// HardMonster 结构体
type HardMonster struct{}

func (h *HardMonster) Attack() {
    fmt.Println("困难怪物发动强攻击")
}

// MonsterFactory 接口
type MonsterFactory interface {
    CreateMonster() Monster
}

// EasyMonsterFactory 结构体
type EasyMonsterFactory struct{}

func (e *EasyMonsterFactory) CreateMonster() Monster {
    return &EasyMonster{}
}

// HardMonsterFactory 结构体
type HardMonsterFactory struct{}

func (h *HardMonsterFactory) CreateMonster() Monster {
    return &HardMonster{}
}

func main() {
    easyFactory := &EasyMonsterFactory{}
    hardFactory := &HardMonsterFactory{}

    easyMonster := easyFactory.CreateMonster()
    easyMonster.Attack()

    hardMonster := hardFactory.CreateMonster()
    hardMonster.Attack()
}

3. 抽象工厂模式

抽象工厂模式是工厂模式的升级版本，它提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

3.1 原理

• 抽象工厂模式提供一个接口来创建相关对象的家族，而不需要明确指定具体类
• 它能够确保一系列相关的产品对象能够相互搭配使用

3.2 使用场景

在我们的游戏开发中，假设我们现在需要为不同的游戏主题（如中世纪和未来）创建一整套相关的游戏元素（如角色、武器、环境）。我们可以使用抽象工厂模式来管理这些元素的创建。

3.3 示例代码

package main

import "fmt"

// Character 接口
type Character interface {
    Introduce()
}

// Weapon 接口
type Weapon interface {
    Use()
}

// Environment 接口
type Environment interface {
    Describe()
}

// GameElementFactory 接口
type GameElementFactory interface {
    CreateCharacter() Character
    CreateWeapon() Weapon
    CreateEnvironment() Environment
}

// 中世纪主题的具体实现
type MedievalKnight struct{}

func (m *MedievalKnight) Introduce() {
    fmt.Println("我是一名中世纪骑士")
}

type MedievalSword struct{}

func (m *MedievalSword) Use() {
    fmt.Println("使用中世纪长剑")
}

type MedievalCastle struct{}

func (m *MedievalCastle) Describe() {
    fmt.Println("这是一座宏伟的中世纪城堡")
}

type MedievalFactory struct{}

func (m *MedievalFactory) CreateCharacter() Character {
    return &MedievalKnight{}
}

func (m *MedievalFactory) CreateWeapon() Weapon {
    return &MedievalSword{}
}

func (m *MedievalFactory) CreateEnvironment() Environment {
    return &MedievalCastle{}
}

// 未来主题的具体实现
type FutureSoldier struct{}

func (f *FutureSoldier) Introduce() {
    fmt.Println("我是一名未来战士")
}

type FutureLaser struct{}

func (f *FutureLaser) Use() {
    fmt.Println("使用未来激光武器")
}

type FutureCity struct{}

func (f *FutureCity) Describe() {
    fmt.Println("这是一座高科技未来城市")
}

type FutureFactory struct{}

func (f *FutureFactory) CreateCharacter() Character {
    return &FutureSoldier{}
}

func (f *FutureFactory) CreateWeapon() Weapon {
    return &FutureLaser{}
}

func (f *FutureFactory) CreateEnvironment() Environment {
    return &FutureCity{}
}

func main() {
    medievalFactory := &MedievalFactory{}
    futureFactory := &FutureFactory{}

    medievalChar := medievalFactory.CreateCharacter()
    medievalWeapon := medievalFactory.CreateWeapon()
    medievalEnv := medievalFactory.CreateEnvironment()

    futureChar := futureFactory.CreateCharacter()
    futureWeapon := futureFactory.CreateWeapon()
    futureEnv := futureFactory.CreateEnvironment()

    medievalChar.Introduce()
    medievalWeapon.Use()
    medievalEnv.Describe()

    futureChar.Introduce()
    futureWeapon.Use()
    futureEnv.Describe()
}

实操：[[抽象工厂上手实操]]