go学习总结（七）

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()
}