方法，接口学习笔记

之前在开发中编得过就行，没有好好地去思考一些细节问题，比如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 n",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中所有方法，这个实现是指实现了相同名称、参数列表 (不包括参数名) 以及返回值的方法。

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!