Golang之接口（interface）

Golang最重要的接口，，，，

package main

import (
    "fmt"
)

//interface类型默认是指针
/*
接口的实现
Golang中的接口，不需要显示的实现。只需要一个变量，含有接口类型中的所有方法，那么这个变量就实现这个接口
因为Golang中没有implement类似的关键字
如果一个变量含有了多个interface类型的方法，那么这个变量就实现了多个接口
如果一个变量只含有了1个interface的部分方法，那么这个变量没有实现这个接口..

一种事物的多种形态，都可以按照统一的接口进行操作

*/

//接口嵌套
type ReadWrite interface {
    Read(b Buffer) bool
    Write(b Buffer) bool
}
type Lock interface {
    Lock()
    Unlock()
}
//嵌套，继承了前面四个方法，File就有6个方法
type File interface {
    ReadWrite
    Lock
    Close()
}
//类型断言，由于接口是一般类型，不知道具体类型，如果要转成具体类型可以采用以下方法进行转换
var t int
var x interface{}
x=t
y,ok=x.(int)



//定义People结构体
type People struct {
    name string
    age  int
}

//定义Test接口
type Test interface {
    //接口有2个方法
    Print()
    Sleep()
}

//定义struct
type Student struct {
    name  string
    age   int
    score int
}

//定义Print（）方法
func (p Student) Print() {
    fmt.Println("name:", p.name)
    fmt.Println("age:", p.age)
    fmt.Println("score", p.score)
}

//Sleep方法
func (p Student) Sleep() {
    fmt.Println("student sleep")
}
func (people People) Print() {
    fmt.Println("name:", people.name)
    fmt.Println("age:", people.age)
}
func (p People) Sleep() {
    fmt.Println("People Sleep")
}

func main() {
    var t Test
    //接口是个地址
    fmt.Println(t)

    var stu Student = Student{
        name:  "stu1",
        age:   20,
        score: 200,
    }
    t = stu
    t.Print()
    t.Sleep()
    fmt.Println("t:", t)

}

 //接口，空接口

package main

import "fmt"

type Carer interface {
    GetName() string
    Run()

    }

func main() {
    var a interface{} //空接口
    var b int         //具体类型
    //空接口可以保持任何类型的变量
    a = b                           // b给a赋值，空接口可以容纳任何类型    b=a //这是错的
    fmt.Printf("type of a:%T
", a) // %T打印类型
}

 //接口的实现（车，宝马车）

package main

import "fmt"

type Carer interface {
    GetName() string
    Run()
    DiDi()
}
type BMW struct {
    Name string
}

//得实现接口所有的方法，才算实现了该接口
func (p *BMW) GetName() string {
    return p.Name
}

//因此还得实现RUN()
//指针类型*BMW,也可以写值类型 (p BMW)
func (p *BMW) Run() {
    fmt.Printf("%s is running
", p.Name)
}

//还得实现DiDi()
func (p *BMW) DiDi() {
    fmt.Printf("%s is didi
", p.Name)
}
func main() {
    var car Carer
    fmt.Println(car)
    //var bmw BMW
    //bmw.Name = "BMW"
    //写法2
    bmw := &BMW{
        Name: "BMW",
    }
    car = bmw
    car.Run()
}

 //Golang中的接口，不需要显示的实现。只要一个变量，含有接口类型中的所有方法，那么这个变量就实现了这个接口。

//因此Golang中没有implement类似的关键字

//如果一个变量含有了多个interface类型的方法，那么这个变量就实现了多个接口

package main

import "fmt"

type Carer interface {
    GetName() string
    Run()
    DiDi()
}
type Test interface {
    Hello()
}

//宝马车
type BMW struct {
    Name string
}

//因此还得实现RUN()
//得实现接口所有的方法，才算实现了该接口
func (p *BMW) GetName() string {
    return p.Name
}

//实现接口的Run()
func (p *BMW) Run() {
    fmt.Printf("%s is running
", p.Name)
}

//还得实现DiDi()
func (p *BMW) DiDi() {
    fmt.Printf("%s is didi
", p.Name)
}

func (p *BMW) Hello() {
    fmt.Printf("hello,i'm %s 
", p.Name)
}

//比亚迪
type BYD struct {
    Name string
}

func (p *BYD) GetName() string {
    return p.Name
}

func (p *BYD) Run() {
    fmt.Printf("%s is running
", p.Name)
}
func (p *BYD) DiDi() {
    fmt.Printf("%s is didi
", p.Name)
}

func main() {
    var car Carer
    var test Test
    fmt.Println(car)
    //var bmw BMW
    //bmw.Name = "BMW"
    //写法2
    bmw := &BMW{
        Name: "BMW",
    }
    car = bmw
    car.Run()

    test = bmw
    test.Hello()

    byd := &BYD{
        Name: "BYD",
    }
    car = byd
    car.Run()
}