家里蹲的狐狸其实提出这个问题我觉得你们跟我这个初学者一样，刚接触编程，或者对编程思想啊什么面向对象啊，继承多态啊，这些乱七八糟的真的是理不清，反正我想了好几天
我开始是这么想的
package main
import "fmt"
//定义一个人类的结构体，他有名字，从此以后Human就是一个类型了，我们就可以以Human这个类型来创建很多很多个人
type Human struct {
Name string
}
//定义了一个Male男性的接口，相当于规定了一套男性的说话方式和思维方式，从此以后Male就是一个类型了，动物也有性别之分
//Male接口可以用Human来实现一个男人的对象，他有男人的一套说法和思维
type Male interface {
speak(s string)
mind()
}
//定义了一个Female女性的接口，相当于规定了一套女性的说话方式和思维方式，从此以后Female就是一个类型了，动物也有性别之分
//Male接口可以去接收一个Human来实现一个男人的对象，他有男人的一套说法和思维
type Female interface {
speak(s string)
mind()
}
func (h *Human) speak(s string) {
fmt.Println(h.Name, "说了一句", s)
}
func (h *Human) mind() {
fmt.Println(h.Name, "在脑子里想了些东西")
}
func main() {
}
//这样两个接口有相同的方法，这怎么办？不应该这么去想，按下面来想，其实是继承和多态
package main
import "fmt"
//定义一个人类的结构体，他有名字，从此以后Human就是一个类型了，我们就可以以Human这个类型来创建很多很多个人
type Human struct {
Name string
}
type Male struct { //定义男人结构体继承人类
Human
}
type Female struct { //定义女人结构体继承人类
Human
}
type Live interface { //定义Live生存的接口，他定义了speak和mind方法
speak(s string)
mind(s string)
}
func (m *Male) speak(s string) {
fmt.Println(s, "是男人，说话了")
}
func (m *Male) mind(s string) {
fmt.Println(s, "是男人，想了想")
}
func (f *Female) speak(s string) {
fmt.Println(s, "是女人，说话了")
}
func (f *Female) mind(s string) {
fmt.Println(s, "是女人，想了想")
}
func main() {
male := Male{Human{"张三"}}
female := Female{Human{"佳佳"}}
male.speak(male.Name)
male.mind(male.Name)
female.speak(female.Name)
female.mind(female.Name)
}
#结果
张三 是男人，说话了
张三 是男人，想了想
佳佳 是女人，说话了
佳佳 是女人，想了想我在百度的时候看到他们是这样提问的，跟我刚开始差不多
我的程序如下：
type People struct {
Name string
}
// 函数实现了原来应有功能
func (p People) Say() {
fmt.Printf("Hi, I'm %s. \n",p.Name)
}
其他程序员的接口定义：
type Speaker interface{
Say()
}
怎么办？舍弃我原来函数的功能？更改我原来的函数名称？现在仔细想想其实可以这么想
其他程序员再去定义一个新的Speaker1的接口再去实现Say1()就好了
可以这么理解把接口理解成一个技能，原来是Say是说普通话，那Say1就去实现英语啊，再定义一个接口Say2去实现方言
因为刚开始的想法错误导致我们命名错误，所以就错误的去实现，应该这么去定义接口
type Sayenglish interface{
Sayenglish()
}
#就像我说的这样再去实现Sayenglish接口完全跟上面的不冲突的
func (p People) Say() {
fmt.Printf("Hi, I'm %s. \n",p.Name)
}想通了再回来看
type Speaker interface{
Say()
}Speaker这么命名就是想错了，Speaker这样命名更适合结构体而不是接口
还有我还看到有人用type SpeakerFunc func()来解释
package main
// 定义的接口
type Speaker interface {
Speak()
}
// 这个类型将实现Speaker，一般由定义 Speaker 的人提供，没提供就自己写
type SpeakerFunc func()
// 实现的Speak方法，直接调用包装的函数
func (s SpeakerFunc) Speak() {
s()
}
type People struct{ }
func(p *People) Speak() {
println("speak")
}
// 知道上面的Speak不符合接口，另外实现一个方法
func(p *People) Speak2() {
println("speak2")
}
func main() {
// 参数为 Speaker 的函数
call := func(speaker Speaker) {
speaker.Speak()
}
// People 对象
people := new(People)
// 想让 call 调用 Speak2，就包装成SpeakerFunc对象
// people.Speak2 可以作为参数传递，这个特性很重要
call(SpeakerFunc(people.Speak2))
// 你还能让它做两次......
call(SpeakerFunc(func() {
people.Speak2()
people.Speak2()
}))
}我不太理解type SpeakerFunc func()的作用和意义
它和https://www.foxzc.com/archives/2020/08/16/366这里的type HandlerFunc func(ResponseWriter, *Request)类似，好像是一个很重要的概念，但是我不太理解，我能明白他是怎么实现的，但是作用和意义不懂
长篇大论了这么多都是我这只菜鸡的理解，有错误请大佬勿喷，欢迎不吝赐教，谢谢！
