1. 依赖和关联

1.1 依赖（Dependency）

概念

• 体现为局部变量、方法的形参，或者对静态方法的调用。
  • 如：出行使用汽车，下雨打伞等
  • 是一种弱关联关系，也是一种临时关系

类图示例

代码示例

package main

import "fmt"
//定义人的类
type Person struct {
	Name string
}
//该类有旅行方法，需要车作为参数
func (p *Person) Travel(car Car) {
	fmt.Printf("%q 坐着 %q 去旅行", p.Name, car.Name)
}
//定义一个汽车类，它是人的依赖
type Car struct {
	Name string
}

func main() {
	//实例化一个人
	guanYu := &Person{
		Name: "关羽",
	}
	//实例化一辆车
	chiTu := &Car{
		Name: "赤兔",
	}
	//执行人的旅行方法，车的实例作为参数
	guanYu.Travel(*chiTu)
}

• 输出

"关羽"坐着"赤兔"取旅行

1.2 关联（Association）

概念

• 体现为类的属性，golang中可以表现为结构体的成员
  • 如：我的朋友（聚合），人和身体部位（组合），汽车和轮子（组合）
  • 是一种强关联关系，也是一种长期关系

类图示例

代码示例

参考下文 聚合、组合

2. 组合和聚合（特殊的关联关系）

2.1 聚合（Aggregation）

概念

• 是关联关系的一种，表示一种弱的“拥有”关系。
  • 如人之于人群，苹果之于苹果堆
  • 体现了群体和个体的关系

类图示例

主角的朋友们成员是由配角聚合而成的一群人，他们和主角不要求有相同的生命周期

因为聚合也是一种特殊的关联关系，因此可以画成：

代码示例

package main

import "fmt"

// 定义主角类
type Protagonist struct {
	Name    string
	//它的一个成员是配角的切片
	Friends []SupportingRole
}
//定义一个方法让配角加入主角的朋友（此处为了演示方便，和聚合关系无关）
func (p *Protagonist) AddFriend(supportingRoleList ...SupportingRole) {
	p.Friends = append(p.Friends, supportingRoleList...)
}
//定义一个方法查看主角（此处为了演示方便，和聚合关系无关）
func (p *Protagonist) Get() {
	fmt.Printf("%+v\n", p)
}
//定义配角类
type SupportingRole struct {
	Name string
}

func main() {
    //实例化一个主角——刘备
	liuBei := &Protagonist{
		Name: "刘备",
	}
	//实例化两个配角——关羽、张飞
	guanYu := SupportingRole{
		Name: "关羽",
	}
	zhangFei := SupportingRole{
		Name: "张飞",
	}
	//将关羽、张飞加入刘备的朋友
	liuBei.AddFriend(guanYu, zhangFei)
	//查看刘备的信息
	liuBei.Get()
}

• 输出

&{Name:刘备 Friends:[{Name:关羽} {Name:张飞}]}

2.2 组合（Composition）

概念

• 是关联关系的一种，表示一种强的“拥有”关系。
  • 如：人之于头、脚；汽车之于驾驶室、发动机
  • 体现了严格的部分和整体的关系
  • 部分和整体的生命周期一样

类图示例

人的组成部分包括头，它们的实例有相同的生命周期

因为他也是一种特殊的关联关系，因此可以画成

代码示例

package main

import "fmt"
//定义一个类——人
type Person struct {
	Name string
	//他有一个成员是头
	Head Head
}
//定义一个类——头
type Head struct {
	weight float64
}
//写一个函数，用来实例化一个具体的人，这样保证了人和头的生命周期一致。（实际操作中可以写一个工厂）
func CreatePerson(name string, headWeight float64) (person *Person) {
	person = &Person{
		Name: name,
		Head: Head{
			weight: headWeight,
		},
	}
	return person
}

func main() {
    //实例化一个人——颜良（八斤半的头留给关羽摘吧）
	yanLiang := CreatePerson("颜良", 8.5)
	fmt.Printf("%+v", yanLiang)
}

• 输出

&{Name:颜良 Head:{weight:8.5}}

3. 实现和泛化（代码的重用）

3.1 实现（Realization）

概念

• 体现为类对接口的实现
  • 比如接口人有工作方法，其泛化类男人、女人都可以实现该接口的工作方法

类图示例

如概念中所述，男人和女人都实现了接口人的工作方法

因为是一种弱关系，因此我们可以看到是虚线链接

代码示例

package main

import (
	"fmt"
)
//定义一个人的接口
type Person interface {
	Work()
}
//定义男人类是接口人的实现
type Man struct {
	Name string
}

func (m *Man) Work() {
	fmt.Println("男人", m.Name, "开心的工作中")
}
//定义女人类是接口人的实现
type Woman struct {
	Name string
}

func (w *Woman) Work() {
	fmt.Println("女人", w.Name, "开心的工作中")
}
//定义一个函数实例化具体的人（实际代码中我们可以写成一个工厂）
func CreatePerson(name string, sex string) Person {
	switch sex {
	case "man":
		return &Man{
			Name: name,
		}
	case "woman":
		return &Woman{
			Name: name,
		}
	default:
		return nil
	}
}

func main() {
	CreatePerson("周瑜", "man").Work()
	CreatePerson("小乔", "woman").Work()

}

• 输出

男人 周瑜 开心的工作中
女人 小乔 开心的工作中

3.2 泛化（Generalization）

概念

• 是继承的逆向关系，子类是父类的泛化。
  • 男人和女人也可以抽象出人类，此时男人和女人是人类的泛化。

类图示例

男人是人的泛化，不但继承了人的还拥有胡子

代码示例

package main

import "fmt"
//定义一个类——人
type Person struct {
	Head string
	Body string
}
//定义人的方法，用来设置人的属性
func (p *Person) SetPerson(head string, body string) {
	p.Head = head
	p.Body = body
}
//定义一个男人类，它是人的泛化（即它继承了人）
type Man struct {
	Person
	Bear string
}
//定义一个男人的方法，用来设置男人的属性
func (m *Man) SetMan(bear string) {
	m.Bear = bear
}

func main() {
    //实例化一个男人——关羽
	guanYu := &Man{}
	//设置关羽人的属性
	guanYu.SetPerson("大头，红脸", "身高九尺")
	//设置关羽男人的属性
	guanYu.SetMan("长胡子")
	//查看结果
	fmt.Printf("%+v", guanYu)
}

• 结果输出

&{Person:{Head:大头，红脸 Body:身高九尺} Bear:长胡子}