1.斐波拉契闭包
package main
import "fmt"
// 返回一个“返回int的函数”
func fibonacci() func() int {
x,y :=0,1 //预定义两个值
return func() int{
tmp:=x
x,y=y,x+y //核心代码
return tmp
}
}
func main() {
f := fibonacci()// 返回一个闭包函数
for i := 0; i < 10; i++ {// 生成10次
fmt.Println(f())
}
}
///
package main
import "fmt"
func main(){
x,y:=0,1
for i:=0;i<10;i++{
tmp:=x
x,y=y,x+y
fmt.Println(tmp)
}
}
2.指针函数
package main
import (
"fmt"
"math"
)
type Vertex struct {
X, Y float64
}
func Abs(v Vertex) float64 {
return math.Sqrt(v.X*v.X + v.Y*v.Y)
}
func Scale(v *Vertex, f float64) {//生成一个指向指针Vertex的数值v
fmt.Println(2,v)
v.X = v.X * f
v.Y = v.Y * f
fmt.Println(3,v)
}
func main() {
v := Vertex{3, 4}
fmt.Println(1,v)
Scale(&v, 10)//生成一个指向v的指针&v
fmt.Println(4,&v)
fmt.Println(5,Abs(v))
}
3.接口
接口类型 是由一组方法签名定义的集合。
接口类型的变量可以保存任何实现了这些方法的值。
package main
import (
"fmt"
"math"
)
type Abser interface {
Abs() float64
}
func main() {
var a Abser//定义a为接口,继承Abs()
f := MyFloat(-math.Sqrt2)//调用MyFloat,返回sqrt(2)
v := Vertex{3, 4}//初始化定义,v=sqrt(3*3+4*4)=5
a = f // a MyFloat 实现了 Abser,a=sqrt(2)
fmt.Println(a.Abs())//调用Abs,返回sqrt(2)
a = &v // a *Vertex 实现了 Abser,a=&Vertex{3,4}
// 下面一行,v 是一个 Vertex(而不是 *Vertex)
// 所以没有实现 Abser。
//a = v
fmt.Println(a.Abs())//调用Abs,返回5
}
type MyFloat float64
func (f MyFloat) Abs() float64 {//f:=-math.Sqrt2
if f < 0 {
return float64(-f) //返回math.Sqrt2
}
return float64(f)
}
type Vertex struct {
X, Y float64
}
func (v *Vertex) Abs() float64 {
return math.Sqrt(v.X*v.X + v.Y*v.Y)
}
4.接口的隐式实现
类型通过实现一个接口的所有方法来实现该接口。既然无需专门显式声明,也就没有“implements”关键字。
隐式接口从接口的实现中解耦了定义,这样接口的实现可以出现在任何包中,无需提前准备。
因此,也就无需在每一个实现上增加新的接口名称,这样同时也鼓励了明确的接口定义。
package main
import "fmt"
type I interface {
M()
}
type T struct {
S string
}
// 此方法表示类型 T 实现了接口 I,但我们无需显式声明此事。
func (t T) M() {
fmt.Println(t.S)
}
func main() {
var i I = T{"hello world"}
i.M()
}