接口定义

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()
}