现在我们再回顾一下前面的Box示例，你会发现Color结构也定义了一个method：String。其实这也是实现了fmt.Stringer这个interface，即如果需要某个类型能被fmt包以特殊的格式输出，你就必须实现Stringer这个接口。如果没有实现这个接口，fmt将以默认的方式输出。

//实现同样的功能
fmt.Println("The biggest one is", boxes.BiggestsColor().String())
fmt.Println("The biggest one is", boxes.BiggestsColor())

注: 实现了error接口的对象（即实现了Error() string的对象），使用fmt输出时，会调用Error()方法，因此不必再定义String()方法了。

interface变量存储的类型

我们知道interface的变量里面可以存储任意类型的数值(该类型实现了interface)。那么我们怎么反向知道这个变量里面实际保存了的是哪个类型的对象呢？

类型断言

类型断言的语法就是用一个接口类型变量采用接口变量.(具体类型)的方式进行转换

类型断言，由于接口是一般类型，不知道具体类型，如果要转成具体类型，就需要使用类型断言， 具体的如下:

package main

import "fmt"

func main() {

    var x interface{}

    var flo float32 = 6.66

    x = flo

    y := x.(float32)

    fmt.Printf("y的类型是 %T 值是 %v", y, y)

}
//输出结果如下
//y的类型是 float32 值是 6.66

在进行类型断言时，如果类型不匹配，就会报 panic, 因此进行类型断言时，要确保原来的空接口指向的就是断言的类型.
如何在进行断言时，带上检测机制，如果成功就 ok,否则也不要报 panic，代码如下

package main

import "fmt"

func main() {

    var x interface{}

    var flo float32 = 6.66

    x = flo

    if y, ok := x.(float64); ok {
        fmt.Println("convert success")
        fmt.Printf("y的类型是 %T 值是 %v", y, y)
    } else {
        fmt.Println("convert fail")
    }

    fmt.Println("继续执行...")
}

我们之前常用的typ-switch就是采用的类型断言

switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际存储的变量类型。

package main

import "fmt"

func main() {
   var x interface{}
     
   switch i := x.(type) {
      case nil:   
         fmt.Printf(" x 的类型 :%T",i)                
      case int:   
         fmt.Printf("x 是 int 型")                       
      case float64:
         fmt.Printf("x 是 float64 型")           
      case func(int) float64:
         fmt.Printf("x 是 func(int) 型")                      
      case bool, string:
         fmt.Printf("x 是 bool 或 string 型" )       
      default:
         fmt.Printf("未知型")     
   }   
}

嵌入interface

Go里面真正吸引人的是它内置的逻辑语法，就像我们在学习Struct时学习的匿名字段，多么的优雅啊，那么相同的逻辑引入到interface里面，那不是更加完美了。如果一个interface1作为interface2的一个嵌入字段，那么interface2隐式的包含了interface1里面的method。

我们可以看到源码包container/heap里面有这样的一个定义

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
}