Go语言 6 结构体、方法和接口
文章由作者马志国在博客园的原创，若转载请于明显处标记出处：http://www.cnblogs.com/mazg/
Go学习群:415660935
结构体(struct)是由一系列具有相同类型或不同类型的数据构成的数据集合。这些数据称为结构体的成员。Go语言的结构体和其他语言的类有同等的地位，但Go语言放弃了包括继承在内的大量面向对象特性，只保留了组合这个最基础的特性。这也体现了Go语言的简洁性。这章内容主要实现了Go语言的面向对象编程。
6.1.1 结构体定义
定义一个结构体相当于定义了一个新的类型。定义结构体的一般形式：
|
type 类型名称 struct { 成员列表 } |
例如，定义一个类型Person
|
type Person struct { name string age int } |
另外需要注意的是，结构体成员的输入顺序也有重要的意义。如果成员的顺序不同，意味着定义了不同的结构体类型。一个命令为S的结构体类型将不能再包含S类型的成员，因为一个聚合的值不能包含它自身（该限制同样适应于数组）但是S类型的结构体可以包含*S指针类型的成员，这可以创建递归的数据结构，例如链表和树结构。如果结构体没有任何成员的话，就是空结构体，写作struct{}.它的大小为0，也不包含任何信息。
6.1.2结构体初始化
结构体变量的的初始化可以按顺序直接初始化，也可以按照字段:值的方式初始化，这种方式的初始化对于字段的初始化的顺序可以是任意的。另外，也可以先定义结构体变量，随后赋值。
|
p1 := Person{"张三", 20} // 1 按顺序初始化 fmt.Println(p1) p2 := Person{age: 18, name: "李四"} // 2采用字段:值的方式初始化，可以任意顺序 fmt.Println(p2) p3 := Person{}// 3 未显示初始化，其成员默认被初始化为零值 fmt.Println(p3) p3.name = "王五" //给每个成员赋值 p3.age = 19 fmt.Println(p3) |
6.1.3 匿名组合实现继承
1 匿名组合的实现
只声明一个成员对应的数据类型而不指明成员的名字,这类成员就叫匿名成员。通过匿名成员实现的匿名组合，可以完成继承的功能。下面定义一个Student类，继承Person类的功能。匿名组合类型相当于以其类型名称（去掉包名部分）作为成员变量的名字。
|
type Person struct { name string age int } type Student struct { Person major string }
func main() { s1 := Student{Person{"张三", 18}, "计算机应用"} fmt.Println(s1) fmt.Println(s1.Person) fmt.Println("姓名:", s1.Person.name, "年龄:", s1.Person.age, "专业：", s1.major) fmt.Println("姓名:", s1.name, "年龄:", s1.age, "专业：", s1.major) } //打印结果: {{张三 18} 计算机应用} {张三 18} 姓名: 张三 年龄: 18 专业： 计算机应用 姓名: 张三 年龄: 18 专业： 计算机应用
|
2匿名组合的重名问题
以下的示例中，Base1、Base2和Child名称相同。另外，匿名组合中Base2使用了指针类型。
|
type Base1 struct { name string } type Base2 struct { name string } type Child struct { Base1 *Base2 name string }
func main() { c := Child{Base1{"base1"}, &Base2{"base2"}, "child"} fmt.Println(c) fmt.Println(c.name) fmt.Println(c.Base1.name) fmt.Println(c.Base2.name) }
//打印结果: {{base1} 0xc0420082c0 child} child base1 base2 |
6.1.4 匿名结构
|
func main() { a := &struct { Name string Age int }{ Name: "zhangsan", Age: 18, } fmt.Println(a) b := struct{}{} fmt.Println(b) } //打印结果: &{zhangsan 18} {} |
6.1.5 结构体比较
如果结构体的全部成员都是可以比较的，那么结构体也是可以比较的。可比较的结构体类型和其它可比较的类型一样，可以用于map的key类型。
6.2 方法
方法就是与某个类型(也可以是内置类型)关联的函数。理所当然我们可以给一个具体的结构体类型添加方法，使得它更像面向对象中的类。
6.2.1 方法声明
在函数声明时，在其名字之前放上一个变量，即是一个方法。相当于为这种类型定义了一个独占的方法。方法可以被声明到任意类型，只要这个类型本身不是一个指针或接口。只有类型和指向它们的指针才可以是接收器。如果一个类型名本身是一个指针的话，是不允许出现在接收器中的。
方法声明的语法格式如下：
|
func (变量名 类型)方法名称( [形参列表] ) [返回值列表]{ 方法体 } 或 func (变量名 *类型)方法名称( [形参列表] ) [返回值列表]{ 方法体 } |
接下来定义了一个新类型Integer，它和int没有本质不同，只是增加了个新方法Less()。
|
type Integer int
func (a Integer) Less(b Integer) bool { return a < b }
func main() { var i Integer = 2 fmt.Println(i.Less(3)) //调用对象i的Less方法 } |
在上面的例子中我们把Integer看着面向对象编程中的类，i是Integer类型的对象，Less()是对象的方法。如果需要修改对象i的值，这就需要使用指针作为接收器。
|
type Integer int
func (a *Integer) Add(b Integer) { *a += b } func main() { var i Integer = 2 i.Add(3) fmt.Println(i) // 5 } |
不管你的方法的接收者是指针类型还是非指针类型，都可以通过指针/非指针类型进行调用，编译器会自动做类型转换。在实际的项目开发中，一般会约定如果某个类型有一个指针作为接收器的方法，那么所有该类型的所有方法都必须有一个指针接收器。
在声明一个方法的接收者该是指针还是非指针类型时，你需要考虑两方面：
1>对象本身是否特别大，如果声明为非指针变量时，调用会产生一次拷贝；
2>如果使用指针类型，需要注意这种指针类型指向的始终是一块内存地址，就算你对其进行了拷贝。
6.2.2 方法值和方法表达式
某个对象的方法称为方法值，某个类型的方法称为方法表达式。
|
type Integer int
func (a Integer) Add(b Integer) Integer { return a + b } func main() { var i Integer = 2 add := i.Add //方法值：将对象i的方法作为值赋值给add变量 fmt.Println(add(3)) add2 := Integer.Add //方法表达式：将类型Integer的方法赋值给add2变量，add2的第一个参数作为接收器 fmt.Println(add2(i, 3)) } |
方法表达式可以根据变量来决定调用同一类型的不同方法。
|
type Integer int
func (a Integer) Add(b Integer) Integer { return a + b } func (a Integer) Sub(b Integer) Integer { return a - b } func Operator(i, j Integer, sel bool) Integer { var op func(a, b Integer) Integer if sel { op = Integer.Add } else { op = Integer.Sub } return op(i, j) }
func main() { fmt.Println(Operator(10, 5, true)) //15 fmt.Println(Operator(10, 5, false)) //5 } |
6.2.3 可见性
Go语言只有一种控制可见性的手段：首字母大写可见，小写字母则不可见。Go语言中符号的可访问性是包一级的而不是类型一级的。
|
package main
import ( "fmt" )
type Person struct { Name string age int }
func (p Person) Show() { fmt.Println("Name:", p.Name, "age:", p.age) } func (p *Person) setAge(age int) { p.age = age } func main() { p := Person{"张三", 18} p.Show() //包外也可见 p.age = 19 //包内可见，包外不可见 p.setAge(20) //包内可见，包外不可见 p.Show() } |
6.3 接口
6.3.1接口类型
接口类型是对其它类型行为的抽象和概括；因为接口类型不会和特定的实现细节绑定在一起。很多面向对象的语言都有类似的接口概念，但是Go语言中接口类型的独特之处在于它是满足隐式实现的。另外，一个接口也可以嵌入其它接口，即接口组合。
6.3.2 实现接口的条件
一个类型如果拥有一个接口需要的所有方法，那么这个类型就实现了这个接口。
|
// 1 定义Phone接口 type Phone interface { Call() } // 定义DumbPhone类型，并实现了Phone接口 type DumbPhone struct { //非智能手机 Name string } func (dp DumbPhone) Call() { fmt.Println("使用" + dp.Name + "非智能机打电话！") }
// 2 定义Camera接口 type Camera interface { TakePicture() } // 定义DigitalCamera类型，并Camera接口 type DigitalCamera struct { //数码相机 Name string } func (d DigitalCamera) TakePicture() { fmt.Println("使用" + d.Name + "数码相机照相！") }
// 3 定义PhoneCamera接口，嵌入了Phone和Camera接口 type PhoneCamera interface { Phone Camera } type CameraPhone interface {//与PhoneCamera接口等价，虽然顺序不同 TakePicture() Call() } // 3 定义SmartPhone类型，并实现了PhoneCamera接口 type SmartPhone struct { // 智能手机 Name string }
func (sp SmartPhone) Call() { fmt.Println("使用" + sp.Name + "智能机手机打电话！") } func (sp SmartPhone) TakePicture() { fmt.Println("使用" + sp.Name + "智能手机照相！") } |
6.3.3 接口赋值
1 将一个对象赋值给一个接口
|
func main() { var p Phone p = &DumbPhone{Name: "诺基亚"} p.Call() p = &SmartPhone{Name: "华为"} p.Call()
var c Camera c = &DigitalCamera{Name: "佳能"} c.TakePicture() c = &SmartPhone{Name: "华为"} c.TakePicture()
var pc PhoneCamera pc = &SmartPhone{Name: "华为"} pc.Call() pc.TakePicture()
} |
2 将一个接口赋值给另一个接口
在Go语言中，只要两个接口拥有相同的方法列表（次序不同不要紧），那么这两个接口是等价的，可以相互赋值。 接口PhoneCamera与接口CameraPhone等价。
|
var pc PhoneCamera pc = &SmartPhone{Name: "华为"} pc.Call() pc.TakePicture() var cp CameraPhone cp = pc //将一个接口赋值给另一个等价接口 cp.Call() cp.TakePicture() |
接口赋值并不要求两个接口必须等价。如果接口A的方法列表是接口B的方法列表的子集，那么接口B可以赋值给接口A。 接口Phone是接口PhoneCamera的子集，接口Camera也是接口PhoneCamera的子集。所以可以有如下的赋值：
|
var pc PhoneCamera pc = &SmartPhone{Name: "华为"} var p Phone var c Camera p = pc //父集赋值给子集 p.Call() c = pc //父集赋值给子集 c.TakePicture() |
6.3.4 接口查询
接口查询语法类似x.(T)，x表示一个接口，T表示另一个接口类型。用来判断接口x操作的对象的是否实现了另一个接口类型。
|
var p Phone p = &SmartPhone{Name: "华为"} p.Call() if pc, ok := p.(PhoneCamera); ok { pc.TakePicture() }
|
6.3.5 空接口
由于Go语言中任何对象实例都满足空接口interface{}，所以interface{}看起来像是可
以指向任何对象的类型。一个函数把interface{}作为参数，那么他可以接受任意类型的值作为参数，如果一个函数返回interface{},那么也就可以返回任意类型的值。
6.3.6 类型查询
在Go语言中，还可以更加直截了当地询问接口指向的对象实例的类型。
|
//伪代码如下 var v1 interface{} = ... switch v := v1.(type) { case int: // 现在v的类型是int case string: // 现在v的类型是string ... ｝ |
