本文视频地址
1. 办法汇合
func ShowMethod(i interface{}) {v := reflect.TypeOf(i)
elemTyp := v.Elem()
n := elemTyp.NumMethod()
if n == 0 {fmt.Printf("%s's 办法为空!\n", elemTyp)
return
}
fmt.Printf("%s's 办法:\n", elemTyp)
for j := 0; j < n; j++ {fmt.Println("-", elemTyp.Method(j).Name)
}
fmt.Printf("\n")
}
type Interface interface {X1()
X2()}
type T struct{}
func (t T) X1() {}
func (t *T) X2() {}
func main() {
var t T
var pt *T
ShowMethod(&t)
ShowMethod(&pt)
ShowMethod((*Interface)(nil))
}
输入如下
main.T’s 办法:
- X1
*main.T’s 办法:
- X1
- X2
main.Interface’s 办法:
- X1
- X2
能够看到
1 T 类型的办法集中只有 X1, 无奈成为与 Interface 类型的办法解的超集
2 T 类型的办法汇合是 X1,X2, T 没有间接实现 X1, 但 X1 依然是 T 类型的办法合集中。这合乎 Go 的标准:类型 T 的办法汇合蕴含所有接收者为 T 和 * T 类型的办法。因而,pt 能力赋值给 Interface 类型变量。
接收者抉择类型时须要思考的要点
1 是否反对将 T 类型实例赋值给某个接口类型变量。
2 如果须要反对,就要实现接收者为 T 类型的接口类型办法汇合中的所有办法。
2. 类型嵌入与办法汇合
1) 接口类型中嵌入接口类型
// $GOROOT/src/io/io.go
type Reader interface {Read(p []byte) (n int, err error)
}
type Writer interface {Write(p []byte) (n int, err error)
}
type Closer interface {Close() error
}
以上为三个根本接口类型
上面的接口类型通过嵌入下面根本接口类型而造成
type ReadWriter interface {
Reader
Writer
}
type ReadCloser interface {
Reader
Closer
}
type WriteCloser interface {
Writer
Closer
}
type ReadWriteCloser interface {
Reader
Writer
Closer
}
func main() {ShowMethod((*io.Writer)(nil))
ShowMethod((*io.Reader)(nil))
ShowMethod((*io.Closer)(nil))
ShowMethod((*io.ReadWriter)(nil))
ShowMethod((*io.ReadWriteCloser)(nil))
}
io.Writer’s 办法:
- Write
io.Reader’s 办法:
- Read
io.Closer’s 办法:
- Close
io.ReadWriter’s 办法:
- Read
- Write
io.ReadWriteCloser’s 办法:
- Close
- Read
- Write
通过嵌入其余接口而生成的新接口类型 ReadWriteCloser 的办法汇合蕴含了被嵌套接口类型 io.Reader 的办法汇合。
注:当被嵌入接口有名字反复的时候,新的接口会报错。
2) 构造体类型中嵌入接口类型
在构造体类型中嵌入接口类型后,该构造体类型的办法汇合中将蕴含被嵌入的接口类型的办法汇合。
func main() {ShowMethod((*Interface)(nil))
var t T
var pt *T
ShowMethod(&t)
ShowMethod(&pt)
}
main.Interface's 办法:
- X1
- X2
main.T's 办法:
- X1
- X3
*main.T's 办法:
- X1
- X2
- X3
a@adeiMac panic_demo % clear
a@adeiMac panic_demo % go run main.go
main.Interface's 办法:
- X1
- X2
main.T's 办法:
- X1
- X3
*main.T's 办法:
- X1
- X2
- X3
这个后果和咱们预期统一。当多个接口类型且这些接口类型的办法汇合存在交加的时候,嵌入了其余接口类型的解构体类型的实例在调用办法时,Go 抉择办法秩序:
1 优先选择构造体本身实现的办法;
2 如果构造体本身并未实现,将查找构造体中的嵌入解构类型的办法集中是否有该办法,如果有,则晋升为构造体的办法。
当多个接口蕴含雷同办法的时候,当调用的时候会报错,
说不明确的调用。
3. 类型别名的办法汇合
type T struct{}
func (T) X1() {}
func (*T) X2() {}
type Interface interface {X1()
X2()}
type T1 T
type Interface1 Interface
func main() {
var t T
var pt *T
var t1 T1
var pt1 *T1
ShowMethod(&t)
ShowMethod(&t1)
ShowMethod(&pt)
ShowMethod(&pt1)
ShowMethod((*Interface)(nil))
ShowMethod((*Interface1)(nil))
}
输入如下:main.T's 办法:
- X1
main.T1's 办法为空!
*main.T's 办法:
- X1
- X2
*main.T1's 办法为空!
main.Interface's 办法:
- X1
- X2
main.Interface1's 办法:
- X1
- X2
从下面后果看:
1 解构类型的别名类型与原来接口类型的办法汇合是统一的,如下面 Interface 和 Interface1
2 自定义类型的别名类型则没有“继承”原类型的办法汇合,别名类型的办法汇合是空的。