Go语言方法接收者设计哲学：接口类型限制解析

type GameImplementation interface {
    InitializeGame()
    MakePlay(player int)
    EndOfGame() bool
    PrintWinner()
}

// PlayOneGame 是一个独立的函数，接受 GameImplementation 接口作为参数
// 它封装了单局游戏的通用逻辑，与具体的游戏实现解耦
func PlayOneGame(game GameImplementation, playersCount int) {
    game.InitializeGame()
    for j := 0; !game.EndOfGame(); j = (j + 1) % playersCount {
        game.MakePlay(j)
    }
    game.PrintWinner()
}

package main

import "fmt"

// GameImplementation 接口定义了游戏核心操作的契约
type GameImplementation interface {
    InitializeGame()
    MakePlay(player int)
    EndOfGame() bool
    PrintWinner()
}

// PlayOneGame 是一个独立的函数，接受 GameImplementation 接口作为参数
// 它封装了单局游戏的通用逻辑，与具体的游戏实现解耦
func PlayOneGame(game GameImplementation, playersCount int) {
    game.InitializeGame()
    for j := 0; !game.EndOfGame(); j = (j + 1) % playersCount {
        game.MakePlay(j)
    }
    game.PrintWinner()
}

// MonopolyGame 是 GameImplementation 接口的一个具体实现
type MonopolyGame struct {
    turns int
    winner int
    players int
}

func (m *MonopolyGame) InitializeGame() {
    fmt.Println("Monopoly game initialized.")
    m.turns = 0
    m.winner = -1
}

func (m *MonopolyGame) MakePlay(player int) {
    fmt.Printf("Player %d makes a move in Monopoly. Turn: %d\n", player, m.turns+1)
    m.turns++
    // 模拟游戏结束条件
    if m.turns >= 5 { // 玩5回合就结束
        m.winner = player // 假设最后一个玩家获胜
    }
}

func (m *MonopolyGame) EndOfGame() bool {
    return m.winner != -1
}

func (m *MonopolyGame) PrintWinner() {
    if m.winner != -1 {
        fmt.Printf("Monopoly game ended. Winner is Player %d!\n", m.winner)
    } else {
        fmt.Println("Monopoly game ended without a clear winner.")
    }
}

// NewMonopolyGame 构造函数
func NewMonopolyGame() *MonopolyGame {
    return &MonopolyGame{}
}

// ChessGame 是 GameImplementation 接口的另一个具体实现
type ChessGame struct {
    isOver bool
    moves int
}

func (c *ChessGame) InitializeGame() {
    fmt.Println("Chess game initialized.")
    c.isOver = false
    c.moves = 0
}

func (c *ChessGame) MakePlay(player int) {
    fmt.Printf("Player %d makes a move in Chess. Move: %d\n", player, c.moves+1)
    c.moves++
    if c.moves >= 3 { // 模拟3步后结束
        c.isOver = true
    }
}

func (c *ChessGame) EndOfGame() bool {
    return c.isOver
}

func (c *ChessGame) PrintWinner() {
    if c.isOver {
        fmt.Println("Chess game ended. Player 0 wins (simulated).")
    } else {
        fmt.Println("Chess game still ongoing.")
    }
}

func NewChessGame() *ChessGame {
    return &ChessGame{}
}

func main() {
    // 玩一局大富翁游戏
    var monopolyGame GameImplementation = NewMonopolyGame()
    fmt.Println("--- Playing one Monopoly game ---")
    PlayOneGame(monopolyGame, 2) // 调用独立的 PlayOneGame 函数
    fmt.Println("--- Monopoly game finished ---\n")

    // 玩一局象棋游戏
    var chessGame GameImplementation = NewChessGame()
    fmt.Println("--- Playing one Chess game ---")
    PlayOneGame(chessGame, 2) // 同样调用 PlayOneGame 函数
    fmt.Println("--- Chess game finished ---\n")

    // 如果想实现 PlayBestOfThreeGames 这样的新行为，同样可以定义一个独立的函数
    func PlayBestOfThreeGames(gameFactory func() GameImplementation, playersCount int) {
        fmt.Println("Starting a best-of-three series...")
        for i := 1; i <= 3; i++ {
            fmt.Printf("\n--- Game %d of 3 ---\n", i)
            game := gameFactory() // 每次创建一个新的游戏实例
            PlayOneGame(game, playersCount)
        }
        fmt.Println("\n--- Best-of-three series finished ---")
    }

    fmt.Println("--- Playing best-of-three Monopoly ---")
    PlayBestOfThreeGames(func() GameImplementation { return NewMonopolyGame() }, 2)
}