结构体嵌套
golang中没有类，他通过结构体来实现其他编程语言中类的相关功能。
具名结构体
基本语法
基本语法
golang的结构体嵌套特别简单。
type 结构体类型1 struct{字段 类型1字段 类型2
}//这样就实现了结构体的嵌套
type 结构体类型2 struct{字段 类型1字段 类型2字段 结构体类型1
}
举例
package struct_knowledgeimport "fmt"type Worker struct{salary intprofession string
}
//具名嵌套结构体
type Human struct{Name stringAge int Work Worker
}func (w Worker) GetSalary(){fmt.Printf("工资为%d\n",w.salary)
}//访问具名结构体
func VisitNestingStruct(){var human Human//访问字段/*报错:human.salary undefined(type Human has no filed or method GetSalary)*///human.salary = 25//通过字段连锁访问human.Work.salary = 20fmt.Printf("结构体的实例为%v\n",human)//通过字面量访问human = Human{Age: 20,Name: "张三",Work: Worker{salary: 1000,profession: "no work",},}fmt.Printf("结构体的实例为%v\n",human)//通过位置赋值human = Human{"lisa",45,Worker{salary: 10000,profession: "waiter",},}fmt.Printf("结构体的实例为%v\n",human)// 调用方法/*报错:human.GetSalary undefined(type Human has no filed or method GetSalary)*/// human.GetSalary()human.Work.GetSalary()
}
结果
结构体的实例为struct_knowledge.Human{Name:"", Age:0, Work:struct_knowledge.Worker{salary:20, profession:""}}
结构体的实例为struct_knowledge.Human{Name:"张三", Age:20, Work:struct_knowledge.Worker{salary:1000, profession:"no work"}}
结构体的实例为struct_knowledge.Human{Name:"lisa", Age:45, Work:struct_knowledge.Worker{salary:10000, profession:"waiter"}}
工资为10000
访问规则
具名嵌套结构体的访问只能通过
嵌套结构体字段名.字段
嵌套结构体字段名.方法()
不能通过最外层结构体直接访问。
举例
type Worker struct{salary intprofession string
}
//具名嵌套结构体
type Human struct{Name stringAge int Work Worker
}
Human实例不能直接访问Worker实例的字段或方法，需要通过
Human实例.Work.字段
Human实例.Work.方法
匿名结构体
基本语法
就是不写用字段接收嵌套结构体而是直接写类型名，例如
type 结构体类型A struct{字段1 类型1字段2 类型2...
}type 结构体类型B struct{字段1 类型1结构体类型A
}
举例
package struct_knowledgeimport "fmt"type StructA struct{name stringage int
}type StructB struct{price int StructA
}func VisitStructB(){var st StructBfmt.Printf("嵌套结构体的值为%#v\n",st)
}
结果
嵌套结构体的值为struct_knowledge.StructB{price:0, StructA:struct_knowledge.StructA{name:"", age:0}}
访问规则
名称访问
匿名结构体如果我们将他按照匿名字段理解，那么他就可以解析成如下形式:
type 结构体类型A struct{字段1 类型1字段2 类型2...
}type 结构体类型B struct{字段1 类型1结构体类型A
}
//按照匿名字段理解
type 结构体类型B struct{字段1 类型1结构体A 结构体类型A
}
所以我们仍然可以通过如下形式修改和访问:
结构体B实例.结构体A.字段
结构体B实例.结构体A.方法()
举例
package struct_knowledgeimport "fmt"type StructA struct{name stringage int
}type StructB struct{price int StructA
}/*我们可以按照访问具名结构体的方法访问匿名结构体的名字就是 类型同名
*/
func VisitStructByName(){var st StructB//连锁访问st.StructA.age = 25fmt.Printf("结构体的实例为%#v\n",st)//字面量访问st = StructB{price: 1000,StructA: StructA{age:25,name:"lisi",},}fmt.Printf("结构体的实例为%#v\n",st)//位置访问st = StructB{1000,StructA{age:30,name:"sam",},}fmt.Printf("结构体的实例为%#v\n",st)
}
结果
结构体的实例为struct_knowledge.StructB{price:0, StructA:struct_knowledge.StructA{name:"", age:25}}
结构体的实例为struct_knowledge.StructB{price:1000, StructA:struct_knowledge.StructA{name:"lisi", age:25}}
结构体的实例为struct_knowledge.StructB{price:1000, StructA:struct_knowledge.StructA{name:"sam", age:30}}
直接访问
匿名结构体与具名结构体最大的不同就是：
我们可以直接通过外层结构体访问匿名结构体的字段或方法(前提没有产生同名冲突)。
举例
package struct_knowledgeimport "fmt"type StructA struct{name stringage int
}type StructB struct{price int StructA
}func (c StructA) GetAge(){fmt.Printf("StructA的年龄为%v\n",c.age)
}func VisitStructByNoName(){var st StructB//在不出现名字冲突的情况下，外层结构体可以直接访问匿名结构体的字段和方法st.age = 25st.GetAge()fmt.Printf("结构体的实例为%#v\n",st)//但仅限于这种成员访问，字面量和位置就不适用/*报错:unknow field age in struct literal of type StructBunknow field name in struct literal of type StructB*/// st = StructB{// price: 1000,// age:30,// name:"lisa",// }
}
结果
StructA的年龄为25
结构体的实例为struct_knowledge.StructB{price:0, StructA:struct_knowledge.StructA{name:"", age:25}}
字段冲突
这种情况主要出现在匿名结构体中，因为同一结构体中字段唯一，所以结构体中不能出现同名字段。
但是匿名结构体嵌套后，由于他可以匿名访问，所以就产生了字段和方法冲突。
这也是匿名结构体允许具名访问的原因。
解决方案
当出现字段冲突时，访问匿名结构体的同名字段或方法需要采用具名访问。
举例
package struct_knowledgeimport "fmt"type StructOne struct{name string age intprice int
}type StructTwo struct{name string age int
}type StructThree struct{name stringStructOneStructTwo
}func VisitStructThree(){var st StructThreefmt.Printf("结构体的实例为%#v\n",st)//访问不同名字段，可以直接匿名访问st.price = 20/*但是访问同名字段或方法，就需要指明结构体如果最外层结构体有就访问的是最外层*/st.name = "lisa"/*如果访问同名字段或方法，但最外层结构体也没有就会报错ambiguous selector st.age*/// st.age = 25
}
结果
结构体的实例为struct_knowledge.StructThree{name:"", StructOne:struct_knowledge.StructOne{name:"", age:0, price:0}, StructTwo:struct_knowledge.StructTwo{name:"", age:0}}
结构体的实例为struct_knowledge.StructThree{name:"lisa", StructOne:struct_knowledge.StructOne{name:"", age:0, price:20}, StructTwo:struct_knowledge.StructTwo{name:"", age:0}}
冲突字段访问规则
1.如果要访问的同名字段或者方法顶层有，直接访问则采用顶层的字段或方法。
2.如果要访问的同名字段或者方法顶层没有，直接访问就会报错。
# ambiguous的中文含义:模糊不清的，模棱两可的
ambiguous selector st.xxx
解决字段冲突问题
要访问嵌套结构体的同名字段或者方法，可以采用具名访问法，例如
外层结构体实例.匿名结构体类型.字段
外层结构体实例.匿名结构体类型.方法()
