做网站可以赚钱吗知乎,群晖ds218 做网站,长春网站改版,邯郸有学做搭建网站的吗简单地说 Interface是一组Method的组合#xff0c;可以通过Interface来定义对象的一组行为。如果某个对象实现了某个接口的所有方法#xff0c;就表示它实现了该借口#xff0c;无需显式地在该类型上添加接口说明。 Interface是一个方法的集合#xff0c;它里面没有其他类型…简单地说 Interface是一组Method的组合可以通过Interface来定义对象的一组行为。如果某个对象实现了某个接口的所有方法就表示它实现了该借口无需显式地在该类型上添加接口说明。 Interface是一个方法的集合它里面没有其他类型变量而且Method只用定义原型 不用实现 ①接口定义 1.命名时习惯以er结尾如Printer Reader Writer 2.一个Interface的Method不宜过多一般0~3个 3.一个Interface可以被任意的对象事项相应地一个对象也可以实现多个Interface 示例 type People struct{Name string
}
type Student struct{PeopleSchool string
}
type Teacher struct{PeopleDepartment string
}
func (p People) SayHi(){}
func (s Student) SayHi(){}
func (t Teacher) SayHi(){}
func (s Student) Study(){}//根据struct的方法提取接口 从而使struct自动实现了该接口
type Speaker interface{SayHi()
}
type Learner interface{SayHi()Study()
} 上面的例子中Speaker接口被对象PeopleTeacherStudent实现而Student同时实现了接口Speaker和Learner。 接口组合 type SpeakLearner interface {SpeakerLearner
}//组合后使得SpeakLearner具有Speaker和Learner的功能 空接口 任何类型都实现了空接口,相当于Java中的Object类 func test(a interface{}){}//该方法可以接受任意类型int rune float32 struct...的参数 ②接口执行机制和接口赋值 首先介绍一种Go语言带接收者(Receiver)的函数机制下面的两种情况执行结果一样涉及到struct成员值改变时仍然一样 情况1 package mainimport (fmt
)type People struct {Name string
}func (p People) SayHi(){ //此处的Receiver是strcutfmt.Println(hello, this is, p.Name)
}
func (p *People) Study(){//此处的Receiver是****structfmt.Printf(%s is studying\n, p.Name)
}
type SpeakLearner interface {SayHi()Study()
}
func main() {people : People{zhangsan}//这里的people为People类型people.SayHi()people.Study()
} 情况2 func main() {people : People{zhangsan}//这里的people为**People类型即指针people.SayHi()people.Study()
} 通过上面的例子可以看出Receiver为People和*People的函数均可被People或者*People两种类型调用接下来借可能有在调用过程中People与*People之间的转换问题 看下面的例子 package mainimport (fmt
)
type Example struct{Integer1 intInteger2 int
}
func (e Example) Assign(num1 int, num2 int) {e.Integer1, e.Integer2 num1, num2
}
func (e *Example) Add(num1 int, num2 int) {e.Integer1 num1e.Integer2 num2
}
func main(){var e1 Example Example{3,4}e1.Assign(1,1)fmt.Println(e1)e1.Add(1,1)fmt.Println(e1)var e2 *Example Example{3,4}e2.Assign(1,1)fmt.Println(e2)e2.Add(1,1)fmt.Println(e2)
} 以上程序的执行结果为 {3,4}
{4,5}
{3,4}
{4,5} 可以看出实际执行的过程按函数定义前的Receiver类型执行。 对于接口的执行机制 1.T仅拥有属于T类型的方法集而*T则同时拥有T*T方法集2.基于T实现方法表示同时实现了interface和interface*T接口3.基于*T实现方法那就只能是对interface*T实现接口 type Integer intfunc (a Integer) Less(b Integer) bool {return a b
}
func (a *Integer) Add(b Integer) {*a b
}
相应地我们定义接口LessAdder如下
type LessAdder interface {Less(b Integer) boolAdd(b Integer)
}现在有个问题假设我们定义一个Integer类型的对象实例怎么将其赋值给LessAdder接口呢
应该用下面的语句(1)还是语句(2)呢
var a Integer 1
var b LessAdder a ... (1)
var b LessAdder a ... (2)
答案是应该用语句(1)。原因在于Go语言可以根据下面的函数
func (a Integer) Less(b Integer) bool
即自动生成一个新的Less()方法
func (a *Integer) Less(b Integer) bool {return (*a).Less(b)
}
这样类型*Integer就既存在Less()方法也存在Add()方法满足LessAdder接口。而从另一方面来说根据
func (a *Integer) Add(b Integer)
这个函数无法自动生成以下这个成员方法
func (a Integer) Add(b Integer) {(a).Add(b)
}
因为(a).Add()改变的只是函数参数a对外部实际要操作的对象并无影响这不符合用
户的预期。所以Go语言不会自动为其生成该函数。
因此类型Integer只存在Less()方法缺少Add()方法不满足LessAdder接口故此上面的语句(2)不能赋值。 接口赋值举例 package main
import(fmt
)
//定义对象People、Teacher和Student
type People struct {Name string
}
type Teacher struct{PeopleDepartment string
}
type Student struct{PeopleSchool string
}
//对象方法实现
func (p People) SayHi() {fmt.Printf(Hi, Im %s. Nice to meet you!\n,p.Name)
}
func (t Teacher) SayHi(){fmt.Printf(Hi, my name is %s. Im working in %s .\n, t.Name, t.Department)
}
func (s Student) SayHi() {fmt.Printf(Hi, my name is %s. Im studying in %s.\n, s.Name, s.School)
}
func (s Student) Study() {fmt.Printf(Im learning Golang in %s.\n, s.School)
}
//定义接口Speaker和Learner
type Speaker interface{SayHi()
}
type Learner interface{SayHi()Study()
}
func main() {people : People{张三}teacher : Teacher{People{郑智}, Computer Science}student : Student{People{李明}, Yale University}var is Speaker //定义Speaker接口类型的变量is people //is能存储Peopleis.SayHi()is teacher //is能存储Teacheris.SayHi()is studentis.SayHi() //is能存储Studentvar il Learneril student //Learner类型接口的变量能存储Studentil.Study()
} 执行结果为 Hi, Im 张三. Nice to meet you!
Hi, my name is 郑智. Im working in Computer Science .
Hi, my name is 李明. Im studying in Yale University.
Im learning Golang in Yale University. 通过这个例子可以 看到如同Java等语言接口机制在多态和创建可扩展可重用的代码时的重要作用 ③匿名字段和接口转换 若果接口类型S内部嵌入了接口类型T匿名则接口匿名字段方法集规则如下 1.如果S嵌入匿名类型T则S方法集包含T方法集。2.如果S嵌入匿名类型*T则S方法集包含*T方法集(包括Riceiver为T和*T的方法)。3.如果S嵌入匿名类型T或*T则*S方法集包含*T方法集包括Riceiver为T和*T的方法。重要 例如 package main
import(fmt
)type People struct {Name string
}
type S1 struct{People //S1类型嵌入匿名PeopleDepartment string
}
type S2 struct{*People //S2类型嵌入匿名*PeopleDepartment string
}
func (p People) Say1() {fmt.Printf(Hi, Im %s. Say1111\n,p.Name)
}
func (p *People) Say2() {fmt.Printf(Hi, Im %s. Say2222\n,p.Name)
}
type Speaker interface{Say1()Say2()
}func main() {people : People{张三}s1 : S1{People{郑智}, Computer Science}s2 : S2{People{李明}, Math}var is Speaker is people //*People实现了Speaker接口is.Say1()is.Say2()//is s1 //S1类型嵌入匿名People 不存在Say2()方法 因而未实现Speaker接口//错误提示 cannot use s1 (type S1) as type Speaker in assignment://S1 does not implement Speaker (Say2 method has pointer receiver)is s2 //S2类型嵌入匿名*People 因而(p People) Say1()和(p *People) Say2()方法都有 实现了Speaker接口is.Say1()is.Say2()is s1 //S1类型嵌入匿名People *S1 实现了Speaker接口is.Say1()is.Say2()is s2 //S2类型嵌入匿名*People *S2 实现了Speaker接口is.Say1()is.Say2()} 执行结果为 Hi, Im 张三. Say1111
Hi, Im 张三. Say2222
Hi, Im 李明. Say1111
Hi, Im 李明. Say2222
Hi, Im 郑智. Say1111
Hi, Im 郑智. Say2222
Hi, Im 李明. Say1111
Hi, Im 李明. Say2222 从而证明了匿名字段方法集的3条规则。 接口转换类似于说是接口继承规则 可认为是实现复杂接口方法多向简单接口方法少转换其中简单接口中的方法在复杂接口中均有声明 。例如 package main
import(fmt
)
type People struct {Name string
}
type Student struct{PeopleSchool string
}
func (p People) GetPeopleInfo() {fmt.Println(p)
}
func (s Student) GetStudentInfo() {fmt.Println(s)
}
type PeopleInfo interface{GetPeopleInfo()
}
type StudentInfo interface{GetPeopleInfo()GetStudentInfo()
}
func main() {var is StudentInfo Student{People{李明}, Yele University}is.GetStudentInfo()is.GetPeopleInfo()var ip PeopleInfo isip.GetPeopleInfo()///ip.GetStudentInfo() note:ip.GetStudentInfo undefined
} ④接口类型推断Comma-ok断言和Switch测试 利用接口类型推断可以 反向知道接口类型变量里面实际保存的是哪一种类型的对象。 Go语言中常用两种方法可以进行接口类型推断即Comma-ok断言和Switch测试 Comma-ok断言使用格式如下 value,ok element.(T) 用法示例 //利用Comma-ok断言进行接口类型推断
package main
import(fmt
)type People struct{Name stringAge int
}//定义空接口用于存储任意类型数据类型
type Object interface{}func main() {people : People{张三, 20}objs : make([]Object, 4)objs[0], objs[1], objs[2], objs[3] 1, true, Hello, peoplefor index, element : range objs{if value, ok : element.(int); ok{fmt.Printf(objs[%d]类型是int,value%d\n, index, value)}else if value, ok : element.(bool); ok{fmt.Printf(objs[%d]类型是bool,value%v\n, index, value)}else if value, ok : element.(string); ok{fmt.Printf(objs[%d]类型是string,value%s\n, index, value)}else if value, ok : element.(People); ok{fmt.Printf(objs[%d]类型是Peole,value%v\n, index, value)}else{fmt.Printf(objs[%d]类型未知\n, index)}}
} 结果是这样的 objs[0]类型是int,value1
objs[1]类型是bool,valuetrue
objs[2]类型是string,valueHello
objs[3]类型是Peole,value{张三 20} 使用Switch测试判断接口类型程序结构更加简洁示例如下只修改了示例中的main函数 func main() {people : People{张三, 20}objs : make([]Object, 4)objs[0], objs[1], objs[2], objs[3] 1, true, Hello, peoplefor index, element : range objs{switch value : element.(type){case int:fmt.Printf(objs[%d]类型是int,value%d\n, index, value)case bool:fmt.Printf(objs[%d]类型是bool,value%v\n, index, value)case string:fmt.Printf(objs[%d]类型是string,value%s\n, index, value)case People:fmt.Printf(objs[%d]类型是Peole,value%v\n, index, value)default:fmt.Printf(objs[%d]类型未知\n, index)}}
} 执行结果Comma-ok方法相同但是程序简洁了许多。转载于:https://www.cnblogs.com/Mike-zh/p/3787679.html
