- 利用方法来模拟面向对象
type student struct{
name string
age int8
}
func (s *student) getName() string {
return s.name
}
func TestClass(t *testing.T){
stu := student{"fangle",20}
t.Log(stu.getName())
}
//result : fangle
方法实际上也是函数，只是在声明时在关键字fun和方法之间增加一个参数，这个参数也称之为接收者。
- 值接收者与指针接收者
type student struct{
name string
age int8
}
func (s student) setAge(age int8) {
s.age = age
}
func TestClass(t *testing.T){
stu := student{}
stu.setAge(21)
t.Log(stu)
}
//result : {0 }
值接收者得到了结构体的一份拷贝，方法内的操作不会影响调用者
type student struct{
name string
age int8
}
func (s *student) setAge(age int8) {
s.age = age
}
func TestClass(t *testing.T){
stu := student{}
stu.setAge(21)
t.Log(stu)
}
//result : { 21}
指针接收者得到了结构体指针的一份拷贝，方法内操作会影响调用者
使用值接收者还是指针接收者，不应该由该方法是否修改了接收到到值来决定。这个决策应该基于该类型到本质
- 方法的接收者可以是任意自定义类型
type text string
func (t *text) len() int{
return len(*t)
}
func TestClass(t *testing.T){
var msg text = "mysql gone away"
t.Log(msg.len())
}
//result : 15
- String魔术方法
组合
- 允许结构体内嵌
type user struct {
name string
age int8
}
type vip struct {
user
level int8
}
func TestClass(t *testing.T){
one := vip{
user {
name: "fangle",
age: 20,
},1,
}
t.Log(one,one.name,one.user.name)
}
//result : {{fangle 20} 1} fangle fangle
- 利用结构体内嵌来实现组合
type header struct {
meta string
script string
}
type body struct {
div string
table string
script string
}
type html struct {
header
body
script string
}
func TestClass(t *testing.T){
doc := html{
header{"<meta>", "<script0>"},
body{"<div>","<table>","<script1>"},
"<script2>",
}
t.Log(doc,doc.script)
t.Log(doc.header.script,doc.body.script)
}
//result :{{<meta> <script0>} {<div> <table> <script1>} <script2>}
//<script2> <script0> <script1>
如果两个内嵌结构体之间有同名变量，不允许外层结构体直接访问变量，必须显示指定要访问的是那个内嵌结构体的变量
