接口

接口

接口是一种类型，是一种特殊的类型，它规定了变量有哪些方法

接口的定义

type 接口名 interface {
    方法名1(参数1，参数2),(返回值1，返回值2...)
    方法名2(参数1，参数2),(返回值1，返回值2...)
}

用来给变量、参数、返回值等设置类型

接口的实现

一个变量如果实现了接口中规定的所有方法，那么这个变量就是现实了这个接口，可以称为这个接口类型的变量

type animal interface {
    move()
    eat(string)
}

type cat struct {
    name string
    feet int8
}
func eat(c cat) move(){
    fmt.Println("猫走路")
}

func eat(c cat) eat(string){
    fmt.Println("猫吃鱼",string)
}

接口保存的分为两部分：值的类型和值本身，这样就实现了接口变量能够存储不同的值

使用值接收者实现接口和使用指针接收者实现接口的区别？

使用值接收者实现接口，结构体类型和结构体指针类型的变量都能存
指针接收者实现接口只能存结构体指针类型的变量

接口和类型的关系

多个类型可以实现同一个接口
一个类型可以实现多个接口

type mover interface {
    move()
}

type eater interface{
    eat(string)
}

type cat struct {
    name string
    feet int8
}

// cat实现mover接口
func (c *cat) move(){
     fmt.Println("猫走路")
}

// cat实现了eater接口
func (c *cat) eat(food string){
    fmt.Printf("猫吃%s\n",food)
}

接口可以嵌套

type animal interface {
    mover
    eater
}

type mover interface {
    move()
}

type eater interface{
    eat(string)
}

type cat struct {
    name string
    feet int8
}

// cat实现mover接口
func (c *cat) move(){
     fmt.Println("猫走路")
}

空接口

没有必要起名字，通常定义成下面的格式

interface{} 

所有类型都实现了空接口，也就是任意类型的变量都能保存在空接口中

// 类型断言1
func assign(a interface{}){
    fmt.Printf("%T\n",a)
    str, ok := a.(string)
    if !ok {
        fmt.Println("错了")
    }else{
        fmt.Println("传进来的是一个字符串",str)
    }
}

// 类型断言2
func assign2(a interface{}){
    fmt.Printf("%T\n",a)
    switch t:= a.(type)
    case string:
        fmt.Println("是一个字符串：",t)
    case int:
         fmt.Println("是一个int：",t)
    case int64:
        fmt.Println("是一个int64：",t)
    case bool :
     fmt.Println("是一个bool：",t)
}

包

• 包的路径从GOPATH/src后面的路径开始写起，路径分割符用/
• 想被别人的包调用的标识符都要首字母大写
• 单行导入和多行导入
• 导入包的时候可以指定别名
• 导入包不想使用包内部的标识符，需要使用匿名导入
• 每个包导入的时候回自动执行一个init()

文件操作

func main(){
    fileObj, err := os.Open("./main.go")
    if err != nil {
        return
    }
    // 延迟关闭文件
    defer fileObj.Close()
    // 一次读入128字节
    var tmp [128]byte
    for {
        n, err := fileObj.Read(tmp[:])
        if err == io.EOF{// 读完了
            return
        }
        if err != nil {
            return
        }
        fmt.Println(string(tmp[:n]))
        if n < 128 {
            return
        }
    }
}
func readFromByBuffio(){
    fileObj, err := od.open("./main.go")
    if err != nil {
        return
    }
    defer fileObj.Close()
    reader := bufio.NewReader(fileObj)
    for {
        line, err := reader.ReadString('\n')
        if err == io.EOF{// 读完了
            return
        }
        if err != nil {
            return
        }
        fmt.Print(line)
    }
}

func readFromByIoutil(){
    ret, err := ioutil.ReadFile("./main.go")
    if err != nil {
  2      return
    }
    fmt.Println(string(ret))
}