1. 依赖和关联

1.1 依赖（Dependency）

概念

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

类图示例

代码示例

package mainimport "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 mainimport "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 mainimport "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 mainimport ("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 mainimport "fmt"
//定义一个类——人
type Person struct {Head stringBody string
}
//定义人的方法，用来设置人的属性
func (p *Person) SetPerson(head string, body string) {p.Head = headp.Body = body
}
//定义一个男人类，它是人的泛化（即它继承了人）
type Man struct {PersonBear 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:长胡子}