Go语言：函数方法和接口

Posted 2021-09-13 鸿渐之翼

>Languages that try to disallow idiocy become themselves idiotic ——Go语言之父Rob Pike
一般静态编程语言都会对程序进行严格的审查，这迫使程序员们把青春投入到和编译器的斗争中去。Go语言想让程序员能在安全和灵活编程中取得一个平衡点。

Go语言程序编译原理

我的理解：
程序首先执行main函数，然后遇见其他import package就去调用其他package，每一个package中都能使用init()函数，最后返回到main函数执行。

函数

在Go语言中，函数是第一类对象*函数对应操作序列，是程序基本组成的元素。go语言函数有可见和不可见{也被称为匿名函数）：可见函数通常是包package级函数
不可见函数引用了外部作用域中的变量，闭包函数通常是函数编程的核心。

//可见函数
func Add（a,b int) int{
return a+b
}
//不可见函数
void Add = func(a,b int )int{
return a+b
}

go语言中的函数可以有多个参数和多个返回值，参数和返回值传参方式如下：

//多个参数与多个返回值
func Swap(a,b int)(int,int){
return b,a、
//可变数量参数
func Sum(a int, more  ...int) int{
for _, v := range more{
a += v
}
return a
}

defer关键字
defer可以延迟执行一个匿名函数。

func Inc() (v int){
 defer func(){v++}()
 return 42
}

这种函数被称为闭包函数
闭包函数只有通过引用的方式访问，而不是传值访问。
如何理解闭包函数呢？
1、定义和用法：当一个函数的返回值是另外一个函数，而返回的那个函数如果调用了其父函数内部的其它变量，如果返回的这个函数在外部被执行，就产生了闭包。【百度百科】
一、函数嵌套函数
二、函数内部可以引用外部的参数和变量
三、参数和变量不会被垃圾回收机制回收
两种使用defer的不同迭代方法

func main(){
    for i :=0;i<3;i++{
    i := i //循环中内的i
    defer func(){Prinln(i)}()
    }
}
func main(){
     for  i : =0; i<3;i++{
     //通过函数传入i
     //defer语句会马上调用参数求值
     defer func(i int) {Println(i)}(i)
}

第一种方式是在循环体内定义局部变量，然后defer收到的参数是不同的值。第二种方式是将迭代变量通过闭包参数传参。

方法

方法是面向对象编程语言中的概念（OOP)
在C++中方法对应一个类对象的成员函数。其实从c与语言的角度来看就是调用函数执行任务。
go程序的方法与c语言的·函数执行任务类似

//Close file
func (f *File) CloseFile() error{
}
func (f *File) ReadFile(int64 offset,data []byte)int{
}

CoseFIle与ReadFile就是File类的方法。它们是“独立”的，不会占用包级空间中的名字资源。简称：Close和Read

//关闭文件
func (f *File) Close() error {
}
//读文件
func (f *File) Read(int64 offset, data []byte) int {
}

Go语言不支持传统面向对象语言的特性。
它通过使用结构体内置匿名成员来实现继承：

import package 
type Point struct{X,Y float64}
type ColoredPoint struct{
Point 
Color  color.RGBA
}
var cp CorloredPoint
cp.X = 1
fmt.Prinln(cp.Point.X)
cp.Point.Y =2
fmt.Prinln(cp.Y)

接口

Go的接口类型是对其它类型行为的抽象和概括；因为接口类型不会和特定的实现细节绑定在一起，通过这种抽象的方式我们可以让对象更加灵活和更具有适应能力。
fmt.Printf的设计完全基于接口。它的真正功能由fmt.Fprintf函数完成。fmt.Fprintf可以输出到网络压缩文件。
Go语言中，我们无法将int类型的值直接赋值给int64类型的变量。go语言对于基础类型转换一致性要求非常严格。
但是对于接口类型使得转换则灵活。
对象和接口之间的转换、接口和接口之间的转换都可能是隐式的转换。

var (
a io.ReadCloser = (*os.File)(f) // 隐式转换, os.File 满足 io.ReadCloser 接口 
b io.Reader = a // 隐式转换, io.ReadCloser 满足 io.Reader 接 口 
c io.Closer = a // 隐式转换, io.ReadCloser 满足 io.Closer 接 口 
d io.Reader = c.(io.Reader) // 显式转换, io.Closer 不满足 io.Reader 接口 
)