2023 跟我一起学设计模式：模板方法模式

// 抽象类定义了一个模板方法，其中通常会包含某个由抽象原语操作调用组成的算
// 法框架。具体子类会实现这些操作，但是不会对模板方法做出修改。
class GameAI is
    // 模板方法定义了某个算法的框架。
    method turn() is
        collectResources()
        buildStructures()
        buildUnits()
        attack()

    // 某些步骤可在基类中直接实现。
    method collectResources() is
        foreach (s in this.builtStructures) do
            s.collect()

    // 某些可定义为抽象类型。
    abstract method buildStructures()
    abstract method buildUnits()

    // 一个类可包含多个模板方法。
    method attack() is
        enemy = closestEnemy()
        if (enemy == null)
            sendScouts(map.center)
        else
            sendWarriors(enemy.position)

    abstract method sendScouts(position)
    abstract method sendWarriors(position)

// 具体类必须实现基类中的所有抽象操作，但是它们不能重写模板方法自身。
class OrcsAI extends GameAI is
    method buildStructures() is
        if (there are some resources) then
            // 建造农场，接着是谷仓，然后是要塞。

    method buildUnits() is
        if (there are plenty of resources) then
            if (there are no scouts)
                // 建造苦工，将其加入侦查编组。
            else
                // 建造兽族步兵，将其加入战士编组。

    // ……

    method sendScouts(position) is
        if (scouts.length > 0) then
            // 将侦查编组送到指定位置。

    method sendWarriors(position) is
        if (warriors.length > 5) then
            // 将战斗编组送到指定位置。

// 子类可以重写部分默认的操作。
class MonstersAI extends GameAI is
    method collectResources() is
        // 怪物不会采集资源。

    method buildStructures() is
        // 怪物不会建造建筑。

    method buildUnits() is
        // 怪物不会建造单位。

package main
 
 type IOtp interface {
   genRandomOPT(int) string
   saveOPTCache(string)
   getMessage(string) string
   sendNotification(string) error
 }
 
 type Otp struct {
   iOtp IOtp
 }
 
 func (o *Otp) genAndSendOPT(optLength int) error {
   opt := o.iOtp.genRandomOPT(optLength)
   o.iOtp.saveOPTCache(opt)
   message := o.iOtp.getMessage(opt)
   if err := o.iOtp.sendNotification(message); err != nil {
     return err
   }
   return nil
 }

package main
 
 import (
   "fmt"
 )
 
 type Sms struct {
   Otp
 }
 
 func (s *Sms) genRandomOPT(len int) string {
   randomOTP := "1234"
   fmt.Printf("SMS: generating random otp %s \n", randomOTP)
   return randomOTP
 }
 
 func (s *Sms) saveOPTCache(otp string) {
   fmt.Printf("SMS: saving otp %s", otp)
 }
 
 func (s *Sms) getMessage(otp string) string {
   return "SMS OTP for login is " + otp
 }
 
 func (s *Sms) sendNotification(message string) error {
   fmt.Printf("SMS: sending sms: %s\n", message)
   return nil
 }

package main
 
 import (
   "fmt"
 )
 
 type Email struct {
   Otp
 }
 
 func (s *Email) genRandomOPT(len int) string {
   randomOTP := "2345"
   fmt.Printf("Email: generating random otp %s \n", randomOTP)
   return randomOTP
 }
 
 func (s *Email) saveOPTCache(otp string) {
   fmt.Printf("Email: saving otp %s to cache", otp)
 }
 
 func (s *Email) getMessage(otp string) string {
   return "Email otp for login is " + otp
 }
 
 func (s *Email) sendNotification(message string) error {
   fmt.Printf("Email: sending email %s \n", message)
   return nil
 }

package main
 
 import "fmt"
 
 func main() {
   smsOTP := &Sms{}
   o := Otp{
     iOtp: smsOTP,
   }
   o.genAndSendOPT(4)
 
   fmt.Println("")
   emailOtp := &Email{}
   o = Otp{
     iOtp: emailOtp,
   }
   o.genAndSendOPT(4)
 }

SMS: generating random otp 1234 
 SMS: saving otp 1234SMS: sending sms: SMS OTP for login is 1234
 
 Email: generating random otp 2345 
 Email: saving otp 2345 to cacheEmail: sending email Email otp for login is 2345