GO开发：接口
接口
接口定义
Interface类型可以定义一组方法，但是这些不需要实现。并且interface不能包含任何变量。
type example interface{
Method1(参数列表) 返回值列表
Method2(参数列表) 返回值列表
…
var a example
a.Method1()
}
interface类型默认是一个指针
接口实现：
a. Golang中的接口，不需要显示的实现。只要一个变量，含有接口类型中的所有方法，那么这个变量就实现这个接口。因此，golang中没有implement类似的关键字
b. 如果一个变量含有了多个interface类型的方法，那么这个变量就实现了多个接口。
c.如果一个变量只含有了1个interface的方部分方法，那么这个变量没有实现这个接口。
接口嵌套
一个接口可以嵌套在另外的接口，如下所示
type ReadWrite interface {
Read(b Buffer) bool
Write(b Buffer) bool
}
type Lock interface {
Lock()
Unlock()
}
type File interface {
ReadWrite
Lock
Close()
}
实例：
package main
import "fmt"
type Reader interface {
Read()
}
type Writer interface {
Write()
}
type ReadWriter interface {
Reader
Writer
}
type File struct {
}
func (f *File) Read() {
fmt.Println("read data")
}
func (f *File) Write() {
fmt.Println("write data")
}
func Test(rw ReadWriter) {
rw.Read()
rw.Write()
}
func main() {
var f *File
Test(f)
var b interface{}
b = f
v, ok := b.(ReadWriter)
fmt.Println(v, ok)
}
类型断言
由于接口是一般类型，不知道具体类型，如果要转成具体类型，可以采用以下方法进行转换：
/*
var t int
var x interface{}
x = t
y = x.(int) //转成int
var t int
var x interface{}
x = t
y, ok = x.(int) //转成int，带检查
*/
package main
import "fmt"
type Student struct {
Name string
Sex string
}
func Test(a interface{}) {
b, ok := a.(Student)
if ok == false {
fmt.Println("convert failed")
return
}
//b += 3
fmt.Println(b)
}
func main() {
var a interface{}
var b int
a = b
c := a.(int)
fmt.Printf("%d %T\n",a,a)
fmt.Printf("%d %T\n",b,b)
fmt.Printf("%d %T\n",c,c)
var st Student = Student{
Name: "stu01",
Sex: "female",
}
Test(st)
fmt.Printf("%T\n",st)
}
类型断言，采用type switch方式
空接口Interface{}
nterface{}，接口中一个方法也没有，所以任何类型都实现了空接口，也就是任何变量都可以赋值给空接口。
var a int
var b interface{}
b = a
判断一个变量是否实现了指定接口
type Stringer interface {
String() string
}
var v MyStruct
if sv, ok := v.(Stringer); ok {
fmt.Printf(“v implements String(): %s\n”, sv.String());
}
实现一个通用的链表类
package main
import "fmt"
type LinkNode struct {
data interface{}
next *LinkNode
}
type Link struct {
head *LinkNode
tail *LinkNode
}
func (p *Link) InsertHead(data interface{}) {
node := &LinkNode{
data: data,
next: nil,
}
if p.tail == nil && p.head == nil {
p.tail = node
p.head = node
return
}
node.next = p.head
p.head = node
}
func (p *Link) InsertTail(data interface{}) {
node := &LinkNode{
data: data,
next: nil,
}
if p.tail == nil && p.head == nil {
p.tail = node
p.head = node
return
}
p.tail.next = node
p.tail = node
}
func (p *Link) Trans() {
q := p.head
for q != nil {
fmt.Println(q.data)
q = q.next
}
}
func main() {
var link Link
for i := 0; i < 10; i++ {
//intLink.InsertHead(i)
link.InsertTail(fmt.Sprintf("str %d", i))
}
link.Trans()https://www.cnblogs.com/gregoryli/p/8467385.html