之前在开发中编得过就行,没有好好地去思考一些细节问题,比如interface到底有什么用,现在好好总结下
1.方法
package main
import "fmt"
import "reflect"
type S struct {
a int
}
func (s S) Set1(v int) {
s.a = v
}
func (s *S) Set2(v int) {
s.a = v
}
func (s *S) Get() int {
return s.a
}
func main() {
var s1 S
var s2 *S
s1.Set1(100)//receiver类型为T的实例,Set1修改的只是s1的副本
fmt.Println(s1.Get())
s1.Set2(100)//receiver类型为*T的实例,Set2修改的是s1的引用
fmt.Println(s1.Get())
fmt.Println("....s1 Method Set....")//receiver类型为T只包含T的方法集,receiver类型为*T包含T和*T的方法集
DumpMethodSet(s1)
fmt.Println("....s2 Method Set....")
DumpMethodSet(s2)
}
func DumpMethodSet(i interface{}) {
MethodSet := reflect.TypeOf(i)
for i := 0; i < MethodSet.NumMethod(); i++ {
fmt.Println(MethodSet.Method(i).Name)
}
}
注意,用receiver类型为T的实例去调用方法其实可以调用到所有T和*T的方法,不受方法集约束,编辑器会自动找到对应方法并转换 receiver 实参
下面这个例子可以看出,T和*T作为receiver方法集的不同会导致什么错误
package main
type I interface {
Set1(int)
Set2(int)
}
type S struct {
a int
}
func (s S) Set1(v int) {
s.a = v
}
func (s *S) Set2(v int) {
s.a = v
}
func main() {
var s1 S
var s2 *S
var a1 I = s1//ERROR: cannot use s1 (type S) as type I in assignment:
//S does not implement I (Get method has pointer receiver)
var a2 I = s2
_ = a1
_ = a2
}
2.接口
package main
import "fmt"
type PCer interface { //1.接口命名习惯以er结尾
GetBrand() string
Memoryer //2.接口可以嵌入接口
Cpuer //3.接口只是方法集,不含数据字段
PrintInfo()
}
//内存条
type Memoryer interface {
GetMemory() int
}
//CPU
type Cpuer interface {
GetCpu() int
}
type HighEndPC struct {
Brand string
MemoryCap int
CpuKernlCnt int
GpuMemoryCap int
}
type LowhEndPC struct {
Brand string
MemoryCap int
CpuKernlCnt int
}
func (self *HighEndPC) GetBrand() string {
return self.Brand
}
func (self *HighEndPC) GetMemory() int {
return self.MemoryCap
}
func (self *HighEndPC) GetCpu() int {
return self.CpuKernlCnt
}
func (self *HighEndPC) GetGpu() int {
return self.GpuMemoryCap
}
func (self *HighEndPC) PrintInfo() {
fmt.Printf("高端电脑 品牌:%s,内存大小%d,处理器核心数%d,显存大小%d \n", self.Brand, self.MemoryCap, self.CpuKernlCnt, self.GpuMemoryCap)
}
func (self *LowhEndPC) GetBrand() string {
return self.Brand
}
func (self *LowhEndPC) GetMemory() int {
return self.MemoryCap
}
func (self *LowhEndPC) GetCpu() int {
return self.CpuKernlCnt
}
func (self *LowhEndPC) PrintInfo() {
fmt.Printf("低端电脑 品牌:%s,内存大小%d,处理器核心数%d \n", self.Brand, self.MemoryCap, self.CpuKernlCnt)
}
func main() {
companyPC := LowhEndPC{"dell", 8, 2}
homePC := HighEndPC{"diy", 16, 4, 11}
myPC := []PCer{&companyPC, &homePC} //4.PCer是companyPC和homePC的抽象,只要实现了接口中的方法,就可以塞进去
for _, pc := range myPC {
pc.PrintInfo()
}
}
运行结果:
低端电脑 品牌:dell,内存大小8,处理器核心数2
高端电脑 品牌:diy,内存大小16,处理器核心数4,显存大小11
这个例子展现了interface的一些特性和应用场景,类似于C++的多态的思想,但是不需要显式地去让struct去“继承”interface的方法集,只要这个struct实现了interface中所有方法,这个实现是指实现了相同名称、参数列表 (不包括参数名) 以及返回值的方法。