Golang之interface

转载 2013年12月03日 12:12:10
一、什么是interface
        简单地说,interface是一组method的组合,可以通过interface来定义对象的一组行为。
        
interface类型
        interface类型定义了一组方法,如果某个对象实现了某个接口的所有方法,则此对象就实现了此接口。详细语法参考如下例子:
        type Human struct {
            name string
            age int
            phone string
        }
        type Student struct {
            Human        //匿名字段Human
            school string
            loan float32
        }
        type Employee struct {
            Human        //匿名字段Human
            company string
            money float32
        }
        //Human对象实现Sayhi方法
        func (h *Human) SayHi() {
            fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
        }
        //Human对象实现Sing方法
        func (h *Human) Sing(lyrics string) {
            fmt.Println("La la, la la la, la la la la...", lyrics)
        }
        //Human对象实现Guzzle方法
        func (h *Human) Guzzle(beerStein string) {
            fmt.Println("Guzzle Guzzle Guzzle...", beerStein)
        }
        //Employee重载Human的Sayhi方法
        func (e *Employee) SayHi() {
            fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name, e.company, e.phone)
        }
        //Student实现BorrowMoney方法
        func (s *Student) BorrowMoney(amount float32) {
            s.loan += amount
        }
        //Employee实现SpendSalary方法
        func (e *Employee) SpendSalary(amount float32) {
            e.money -= amount
        }
        //定义interface
        type Men interface {
            SayHi()
            Sing(lyrics string)
            Guzzle(beerStein string)
        }
        type YoungChap interface {
            SayHi()
            Sing(song string)
            BorrowMoney(amount float32)
        }
        type ElderlyGent interface {
            SayHi()
            Sing(song string)
            SpendSalary(amount float32)
        }
        从上面代码可知,interface可以被任意的对象实现,比如:Men interface被Human、Student和Employee实现。同理,一个对象可以实现任意多个interface,比如:Student实现了Men和YonggChap两个interface。
        任意类型都实现了空interface(我们这样定义:interface{}),即包含0个method的interface。

三、interface值
        如果我们定义了一个interface的变量,那么这个变量可以存储实现了这个interface的任意类型的对象。比如:上例中定了一个Men interface类型的变量m,那么m里面可以存储Human、Student或者Employee值。下面举例说明如何使用:因为m能够持有这三种类型的对象,所以可以定义一个包含Men类型元素的slice,这个slice可以被赋予实现了Men接口的任意结构的对象:
        package main
        import "fmt"
        type Human struct {
            name string
            age int
            phone string
        }
        type Student struct {
            Human        //匿名字段
            school string
            loan float32
        }
        type Employee struct {
            Human        //匿名字段
            company string
            money float32
        }
        //Human实现Sayhi方法
        func (h Human) SayHi() {
            fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
        }
        //Human实现Sing方法
        func (h Human) Sing(lyrics string) {
            fmt.Println("La la la la...", lyrics)
        }
        //Employee重载Human的SayHi方法
        func (e Employee) SayHi() {
            fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name.e.company, e.phone)
        }
        //Interface Men被Human、Student和Employee实现
        //因为这三个类型都实现了这了两个方法
        type Men interface {
            SayHi()
            Sing(lyrics string)
        } 
        func main() {
            mike := Student{Human{"Mike", 25, "222-222-xxx"}, "MIT", 0.00}
            paul := Student{Human{"Paul", 26, "111-222-xxx"}, "Harvard", 100}
            sam := Employee{Human{"Sam", 36, "444-222-xxx"}, "Golang Inc.", 1000}
            Tom := Employee{Human{"Sam", 36, "444-222-xxx"}, "Things Ltd.", 5000}
            //定义Men类型的变量i
            var i Men
            //i能存储Student
            i = mike
            fmt.Println("This is Mike, a Student:")
            i.SayHi()
            i.Sing("November rain")
            //i也能存储Employee
            i = Tom
            fmt.Println("This is Tom, an Employee:")
            i.SayHi()
            i.Sing("Born to be wild")
            //定义了slice Men
            fmt.Println("Let's use a slice of Men and see what happens")
            x := make{[]Men, 3}
            //T这三个都是不同类型的元素,但是他们实现了interface同一接口
            x[0], x[1], x[2] = paul, sam, mike
            for _, value := range x{
                value.SayHi()
            }
        }
        通过上面代码,可以看出interface就是一组抽象方法的集合,必须由其它非interface类型实现,而不能自我实现,Go语言通过interface实现了duck-typing,即“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子,那么这只鸟就可以被称为鸭子。”

四、空interface
        空interface即interface{}不包含任何的method,因此,所有类型都实现了空interface。空interface对于描述起不到任何作用,因为不包含任何的method,但是空interface在我们需要存储任意类型的数值时相当有用,因为它可以存储任意类型的数值,有点类似于C语言的void *类型。
        //定义a为空接口
        var a interface{}
        var i int = 5
        s := "hello world"
        //a可以存储任意类型的数据
        a = i
        a = s
        一个函数把interface{}作为参数,那么它可以接受任意类型的值作为参数,如果一个函数返回interface{},就可以返回任意类型的值。

五、interface函数参数
        interface的变量可以持有任意实现该interface类型的对象,这样我们可以通过定义interface参数让函数接受各种类型的参数。
        举例说明:fmt.Println可以接受任意类型的数据,打开fmt的源码能看到定义如下:
        type Stringer interface {
            String() string
        }
        也就是说,任何实现了String方法的类型都能作为参数被fmt.Println调用:
        package main
        import (
            "fmt"
            "strconv"
        )
        type Human struct {
            name string
            age int
            phone string
        }
        //通过这个方法Human实现了fmt.Stringer
        func (h Human) String() string {
            return " "+h.name+" - "+strconv.Itoa(h.age)+" years - "+h.phone+" "
        }
        func main() {
            Bob := Human{"Bob", 39, "000-7777-xxx"}
            fmt.Println("This Human is : ", Bob)
        }
        如果需要某个类型能被fmt包以特殊的格式输出,就必须实现Stringer这个接口。如果没有实现这个接口,fmt将以默认的方式输出。
        需要注意的是:实现了error接口的对象(即实现了Error() string的对象),使用fmt输出时,会调用Error()方法,因此不必再定义了String()方法了。

六、interface变量存储的类型
        通过前文我们知道interface变量能存储任意类型的数值,只要该类型实现了interface。如果想反向知道该变量里实际存储的类型时什么该当如何?目前常用的有两种方法:
1、Comma-ok断言
        在Go语言里,可以通过如下语法来判断interface里存储的数值类型:
        value, ok = element.(T)
        这里value就是变量的值,ok是一个bool类型,element是interface变量,T是断言的类型。如果element里面确实存储了T类型的值,则ok返回true,否则返回false。
        比如:value, ok := element.(int)
        这种方式的问题在于需要一长串的ifelse,断言的类型T越多则ifelse越多,因此,switch来了。
2、switch测试
        语法同C语言中的switch,具体如下:
        switch value := element.(type) {
            case int:
            ...
            case string:
            ...
            default:
            ...
        }   
        需要注意的是:element.(type)语法不能在switch外的任何逻辑里面使用,如果要在switch外面判断一个类型就使用comma-ok。

七、嵌入interface     
        Go语言里面真正吸引人的是其内置的逻辑语法,就像struct中匿名字段一样,实际上,相同的逻辑在interface中也成立。如果一个interface1作为interface2的一个嵌入字段,则interface2隐式的包含了interface1里面的method。从interface源码中可以看到如下定义:
        type Interface interface {
            sort.Interface    //嵌入字段sort.Interface
            Push(x interface{})    //a Push method to push elements into the heap
            Pop() interface{}    //a Pop elements that pops elements from the heap
        }
        sort.Interface其实就是嵌入字段,把sort.Interface的所有method隐式包含进来了,也就是下面三个方法:
        type Interface interface {
            //Len is the number of elements in the collection.
            Len() int
            //Less returns whether the element with index i should sort before the element with index j.
            Less(i, j int) bool
            //Swap swaps the elements with indexes i and j.
            Swap(i, j int)
        }
        另一个例子就是io包下面的io.ReadWriter,它包含了io包下面的Reader和Writer两个interface。
        //io.ReadWriter
        type ReadWriter interface {
            Reader
            Writer
        }
        
八、反射  
        Go语言实现了反射,所谓反射就是动态运行时的状态。我们一般用到的包是reflect包,官方的这篇文章详细地讲解了reflect包的实现原理——《Laws of reflection》。使用reflect一般分成三步:要去反射是一个类型的值(这些值都实现了空interface),首先需要把它转换成reflect对象(reflect.Type或者reflect.Value,根据不同情况调用不同函数)。这两种获取方式如下:
        t := reflect.TypeOf(i)    //得到类型的元数据,通过t我们能获取类型定义里面的所有元素
        v := reflect.ValueOf(i)    //得到实际的值,通过v我们获取存储在里面的值,还可以去改变值
        转化为reflect对象之后就可以进行一些操作了,即将reflect对象转化成相应的值:
        tag := t.Elem().Field(0).Tag        //获取定义在struct里面的标签
        name := v.Elem().Field(0).String()    //获取存储在第一个字段里面的值
        获取反射值能返回相应的类型和数值。
        var x float64 = 3.4
        v := reflect.ValueOf(x)
        fmt.Println("type:", v.Type())
        fmt.Println("kind is float64:", v.kind() == reflect.Float64)
        fmt.Println("value:", v.Float())
        最后,反射的字段必须是可读写的,类似于传值和传引用。按照下面的方式会产生错误:
        var x float64 = 3.4
        v := reflect.ValueOf(x)
        v.SetFloat(7.1)
        如果要修改相应的值,必须如下才行:
        var x float64 = 3.4
        p := reflect.ValueOf(&x)
        v := p.Elem()
        v.SetFloat(7.1)

golang学习之Interface类型断言

Interface作为go语言中一个重要的组成部分,它的使用简单方便。它的通常和struct一起使用,有点类似C++中的类。今天,我们主要来讨论一下它在类型断言中的用法。...

golang语法总结(二十二):接口interface

类型关键字为interface 不需要显式声明实现某个接口,只要实现相关方法就实现了接口     基本示例: type Person interface { Name() string}...

从 Golang中 method has pointer receiverd 异常去理解interface机制

从 Golang中 method has pointer receiverd 异常去理解interface机制

golang 接口interface{}、断言、switch type

interface{} 可以接受任何类型的对象值 获取interface{}队形的数据类型,可以使用断言,或者 switch type 来实现// Assertion project main.go...

golang中interface判断nil问题

interface数据的表示 参阅http://research.swtch.com/interfaces 在示例中,我们定义一个interface名为Stringer,同时定义一个符合其定义...

Golang中的interface

Golang中的接口,提供了类似于C++中多态的功能,比如接口提供了一个功能为 “跑步”,人类可以跑步,机器人也可以跑步。只要你定义的class,实现和接口中一样的函数名(参数必须是一样的),在具体实...

Golang-interface(三 接口类型)

Go Data Structures: Interfaces Posted on Tuesday, December 1, 2009. Go's interfaces—...

golang技术随笔(一)深入理解interface

Go语言的主要设计者之一罗布·派克( Rob Pike)曾经说过,如果只能选择一个Go语言的特 性移植到其他语言中,他会选择接口。可见接口在golang中的地位,及其对gloang这门语言所带来的活力...

Golang-interface(四 反射)

一 反射的规则 反射是程序运行时检查其所拥有的结构,尤其是类型的一种能力;这是元编程的一种形式。它同时也是造成混淆的重要来源。 每个语言的反射模型都不同(同时许多语言根本不支持反射)。本节...
  • txj236
  • txj236
  • 2016年11月01日 14:57
  • 130

golang interface实现中遇到的问题

package main import ( "fmt" ) type Human struct { name string age int ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Golang之interface
举报原因:
原因补充:

(最多只允许输入30个字)