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）
概念
- 是继承的逆向关系，子类是父类的泛化。
- 男人和女人也可以抽象出人类，此时男人和女人是人类的泛化。
类图示例
男人是人的泛化，不但继承了人的还拥有胡子文章来源：https://www.toymoban.com/news/detail-633789.html
代码示例
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:长胡子}
文章来源地址https://www.toymoban.com/news/detail-633789.html
到了这里，关于类图的6种关系和golang应用的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
