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\n", 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\n", p.Name)
}
//还得实现DiDi()
func (p *BMW) DiDi() {
fmt.Printf("%s is didi\n", 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\n", p.Name)
}
//还得实现DiDi()
func (p *BMW) DiDi() {
fmt.Printf("%s is didi\n", p.Name)
}
func (p *BMW) Hello() {
fmt.Printf("hello,i'm %s \n", p.Name)
}
//比亚迪
type BYD struct {
Name string
}
func (p *BYD) GetName() string {
return p.Name
}
func (p *BYD) Run() {
fmt.Printf("%s is running\n", p.Name)
}
func (p *BYD) DiDi() {
fmt.Printf("%s is didi\n", 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()
}