Golang编程中的混合类型mixins

混合类型可以减少多重继承,用更少的代码量,更优雅的完成多类型的任务。

Mixins 鼓励代码重用,可用于避免多重继承可能导致的继承歧义(“菱形问题”),或解决语言中缺乏对多重继承的支持。一个 mixin 也可以被看作是一个实现了方法的接口。这种模式是实施依赖倒置原则的一个例子。

package main

import "fmt"

// 厨艺Interface
type Cooker interface {
  Cook() string
}

// 绘画Interface
type Painter interface {
  Paint() string
}

// 工作 Interface
type Worker interface {
  Work() string
}

// 家庭煮夫?实体结构
type HomeCooker struct{}

func (c *HomeCooker) Cook() string {
  return "做简单的菜"
}

// 周日画家 实体结构
type SundayPainter struct{}

func (p *SundayPainter) Paint() string {
  return "周日会画画"
}

// 办公室雇员 实体结构
type OfficeWorker struct{}

func (w *OfficeWorker) Work() string {
  return "工作日上班"
}

/*
*  爸爸的 结构体
*    Cooker
*    Painter
*    Worker
 */
type Father struct {
  Name string
  Cooker
  Painter
  Worker
}

// 初始化一个 普通爸爸
func NewGenericFather() *Father {
  return &Father{
    "王大锤",
    &HomeCooker{},
    &SundayPainter{},
    &OfficeWorker{},
  }
}

// 家庭煮男 结构体
type CookingPapa struct {
  Name string
  Painter
}

func NewCookingPapa() *CookingPapa {
  return &CookingPapa{
    "卢小鱼",
    &SundayPainter{},
  }
}

func (cp *CookingPapa) Cook() string {
  return "天天在家做饭"
}

/*
 * 注意做事,调用的参数,是interface 接口,而不是具体的struct
 */
func MakeDinner(c Cooker) string {
  return c.Cook()
}

func RepairRoof(p Painter) string {
  return p.Paint()
}

func GetMoney(w Worker) string {
  return w.Work()
}

func main() {
  gf := NewGenericFather()
  fmt.Println(gf.Name)
  fmt.Println("- ", MakeDinner(gf))
  fmt.Println("- ", RepairRoof(gf))
  fmt.Println("- ", GetMoney(gf))

  cp := NewCookingPapa()
  fmt.Println(cp.Name)
  fmt.Println("- ", MakeDinner(cp))
  fmt.Println("- ", RepairRoof(cp))
}

执行结果

王大锤

- 做简单的菜

- 周日会画画

- 工作日上班

卢小鱼

- 天天在家做饭

- 周日会画画

我们可以看到。虽然我们是不同的爸爸,但是在调用同样的函数方法MakeDinner, RepairRoof 的时候,我们可以获得不一样的结果。

根据身份的不同,我们执行的结果也不同。

分类: 默认 标签: 发布于: 2022-06-22 10:36:05, 更新于: 2022-06-22 10:36:05