Factory method patternメモ

こういう感じのFactory method patternはよく使いそうなのでメモ

package main

import (
    "fmt"
    "errors"
)

const (
    PersonTypeSales     = 1
    PersonTypeOperator  = 2
)

type (

    PersonInterface interface {
        Greet() string
        GetType() int
    }

    Person struct {
        Type int
    }

    Salesperson struct {
        Person
    }

    Operator struct {
        Person
    }

    PersonFactory struct {}

)

// 共通メソッド
func (p Person) GetType() int {
    return p.Type
}

// 共通メソッド
func (p Person) Greet() string {
    return "I'm a person."
}

// 埋め込みStructのメソッドを上書き可能
func (p Salesperson) Greet() string {
    return "I'm a sales-person."
}

func (p Operator) Greet() string {
    return "I'm an operator."
}

// Factory method
func (p *PersonFactory) Get(personType int) (PersonInterface, error) {
    var person PersonInterface

    switch personType {
    case PersonTypeSales:
        person = Salesperson{Person{Type: personType}}
    case PersonTypeOperator:
        person = Operator{Person{Type: personType}}
    default:
        return nil, errors.New("Not found target type of person.")
    }

    return person, nil
}

func main() {
    factory := PersonFactory{}

    salesperson, _ := factory.Get(PersonTypeSales)
    operator, _ := factory.Get(PersonTypeOperator)

    fmt.Println(salesperson.Greet(), salesperson.GetType())
    fmt.Println(operator.Greet(), operator.GetType())
}