go语言第七天｜青训营笔记这是我参与「第五届青训营」伴学笔记创作活动的第 7 天今天主要学习了有关go语言接口

这是我参与「第五届青训营」伴学笔记创作活动的第 7 天

今天主要学习了有关go语言接口类型的知识定义一个接口类型

type Pet interface{
eat（）
sleep（）
}

这是定义了一个接口类型名为pet 该接口包含两个方法分别是eat和sleep

然后我们来定义两个结构体，两个可以实现eat和sleep的结构体

type Dog struct{}
type Cat struct{}

然后我们来实现两种方法分别是eat和sleep

func(d Dog)eat(){
fmt.Println("dog eat...")
}
func(c Cat)eat(){
fmt.Println("cat eat")
}
func(d Dog)sleep(){
fmt.Println("dog sleep")
}
func(c Cat)sleep(){
fmt.Println("cat sleep")
}

当我们实现所有方法时称这个接口被实现

c:=Cat{}
d:=Dog{}
c.eat()
c.sleep()
d.eat()
d.sleep()

当然接口也可以进行嵌套

type fly interface{fly()}
type swim interface{swim()}
type flyfish interface{
    fly
    swim
 }

这里定义了三个接口其中第三个接口中嵌套了前两个接口

然后我们来实现功能

type fish struct{
name string
}
func (f fish)fly(){fmt.Println(f.name,"can fly")}

func (f fish)swim(){fmt.Println(f.name,"can fly")}

func (f fish)f1(i flyfish){
    i.fly()
    i.swim()

}
//调用时：
f := fish{
		name: "xiaoxaio",
	}
	d := fish{
		name: "dada",
	}
	b := fish{
		name: "duoduo",
	}
	f.f1(f)
	f.f1(d)
	f.f1(b)

还有接口的ocp设计原则

package main

import "fmt"

type Pet interface {
	eat()
	sleep()
}
type Dog struct {
}
type Cat struct {
}
type person struct {
}

func (d Dog) eat() {
	fmt.Println("dog eat ...")
}
func (d Dog) sleep() {
	fmt.Println("dog sleep")
}
func (c Cat) sleep() {
	fmt.Println("cat sleep ...")
}
func (c Cat) eat() {
	fmt.Println("cat eat")
}
func (p person) carry(m Pet) {
	m.eat()
	m.sleep()
}
func main() {
	p := person{}
	d := Dog{}
	c := Cat{}
	
	p.carry(d)
	p.carry(c)
}

依赖于接口而不是实现，优先使用组合而不是继承，这是程序抽象的基本原则。Golang 中的 interface 让编码更灵活、易扩展，使得 Go 拥有了面向对象多态的特性。在此我们记住三点就够了：

方法声明的集合任何类型的对象实现了在接口中声明的全部方法，则表明该类型实现了对应接口。可以作为一种数据类型，实现了该接口的任何对象都可以给对应的接口类型变量赋值。 go语言的接口实际上很简单只要定义并且将其中方法都实现那么该接口就成功实现

go语言第七天 ｜ 青训营笔记

go语言第七天｜青训营笔记