Go语言中同时有函数和方法！
函数： go程序必须要包含一个main函数。main函数不能有任何参数和返回值！
1. 定义方法示例：
func max(num1, num2 int) int { // 形参类型相同时，可以只写一个类型
// 后面的int代表返回值类型
/* 定义局部变量 */
var result int
if (num1 > num2) {
result = num1
} else {
result = num2
}
return result
}
------------------------------------------
func sssss(x int, y string) (string, int) {
return y, x
}
------------------------------------------
func SumAndProduct(A, B int) (Add int, Multiplied int) {
Add = A+B
Multiplied = A*B
return
}
--------------------------------------------------------------
×××××× import(
"fmt"
"math"
)
/* 声明函数变量 */
getSquareRoot := func(x float64) float64 {return math.Sqrt(x)}
/* 使用函数 */
fmt.Println(getSquareRoot(9))
2. 当函数有多个返回值时，也可以使用空白标识符 _ 来丢弃某个/些值。
3. 可变参——接受变参的函数是有着形参数量不确定的函数。。。
定义方法：
func func_name(arg ...int) {} // 这里arg ...int标志此函数可以接收不定数量的int类型的实参
// 在函数体中，arg是一个int类型的切片(arg也可以换成args)
4. 参数传递——值传递和引用传递
值传递——就是普通的值传递啊。。
引用传递——使用指针——实质也是值传递。。。
var x int = 2 则若实参为地址 &x, 则形参为 *int 型。 传内存地址比较轻量级(8bytes)，我们可以用指针传递体积大的结构体。 如果用参数值传递的话, 在每次copy上面就会花费相对较多的系统开销(内存和时间)。 所以当你要传递大的结构体的时候，用指针是一个明智的选择。
5 闭包： Go语言支持匿名函数，闭包的表现形式一般是匿名函数，通过函数返回一个函数。 闭包会使函数中的变量都被保存在内存中！消耗内存。
×××只要闭包还在使用，那么被闭包引用的变量就会一直存在！！！
func getSequence() func() int {
i := 0
return func() int {
i += 1
return i
}
}
func main() {
/* nextNumber 为一个函数 */
// var nextNumber = getSequence() 或者
nextNumber := getSequence()
/* 调用 nextNumber 函数，i 变量自增 1 并返回 */
fmt.Println(nextNumber())
fmt.Println(nextNumber())
fmt.Println(nextNumber())
/* 创建新的函数 nextNumber1，并查看结果 */
nextNumber1 := getSequence()
fmt.Println(nextNumber1())
fmt.Println(nextNumber1())
}
打印结果：
1
2
3
1
2
6. 可以声明一个函数类型；然后函数就可以作为值传递了！ type testInt func(int) bool // 声明了一个函数类型testInt, 接收一个int型参数，返回值为bool类型
7. panic和recover: Go语言没有像Java那样的异常机制，不能抛出异常，而是使用panic和recover机制。 panic(...)——当函数F调用panic，函数F的执行被中断，但是F中的延迟函数会正常执行，然后F返回到调用它的地方。在调用的地方，F的行为就像调用了panic。这一过程继续向上，直到发生panic的goroutine中所有调用的函数返回，此时程序退出。
recover()让进入恐慌的goroutine恢复过来。recover仅在延迟函数中有效。在正常的执行过程中，调用recover会返回nil，并且没有其它任何效果。
方法：
1. 定义方法: func (t Type) method(parameter list) { //其中t是一个接收器，可以接收结构体或者非结构体类型 ... }
示例代码:
package main
import "fmt"
type Employee struct {
name string
salary int
currency string
}
/*
displaySalary()的方法接收器为Employee结构体类型
*/
func (e Employee) displaySalary() {
fmt.Printf("Salary of %s is %s%d", e.name, e.currency, e.salary)
}
func main() {
emp1 := Employee {
name: "Sam Adolf",
salary: 5000,
currency: "$",
}
emp1.displaySalary() // 调用displaySalary() 方法
}
可以定义相同的方法名：相同名称的方法可以在不同的类型上定义，而具有相同名称的函数是不允许的!
package main
import (
"fmt"
"math"
)
type Rectangle struct {
width, height float64
}
type Circle struct {
radius float64
}
// 该 method 属于 Rectangle 类型对象中的方法
func (r Rectangle) area() float64 {
return r.width * r.height
}
// 该 method 属于 Circle 类型对象中的方法
func (c Circle) area() float64 {
return c.radius * c.radius * math.Pi
}
func main() {
r1 := Rectangle{12, 2}
r2 := Rectangle{9, 4}
c1 := Circle{10}
c2 := Circle{25}
fmt.Println("Area of r1 is: ", r1.area())
fmt.Println("Area of r2 is: ", r2.area())
fmt.Println("Area of c1 is: ", c1.area())
fmt.Println("Area of c2 is: ", c2.area())
}
2. 变量作用域：
函数内定义的变量称为局部变量，它们的作用域只在函数体内（参数和返回值变量也是局部变量）
函数外定义的变量称为全局变量，首字母大写全局变量可以在整个包甚至外部包（被导出后）使用。
3. 用指针可以改变值！！
package main
import (
"fmt"
)
type Rectangle struct {
width, height int
}
func (r *Rectangle) setVal() {
r.height = 20
}
func main() {
p := Rectangle{1, 2}
s := p // 此时只是将p的数据拷贝给s了一份，即二者并不是指向同一数据的关系
// p是p，s是s，改变p不会影响s
p.setVal()
mt.Println(p.height, s.height)
}
4. 继承: 如果匿名字段实现了一个method，那么包含这个匿名字段的struct也能调用该method.
type Human struct {
name string
age int
phone string
}
type Student struct {
Human // 匿名字段
school string
}
type Employee struct {
Human //匿名字段
company string
}
func (h *Human) SayHi() {
fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
}
func main() {
mark := Student{Human{"Mark", 25, "222-222-YYYY"}, "MIT"}
sam := Employee{Human{"Sam", 45, "111-888-XXXX"}, "Golang Inc"}
mark.SayHi()
sam.SayHi()
}
5. 重写: (就近原则)
package main
import "fmt"
type Human struct {
name string
age int
phone string
}
type Student struct {
Human //匿名字段
school string
}
type Employee struct {
Human //匿名字段
company string
}
//Human定义method
func (h *Human) SayHi() {
fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
}
//Employee的method重写Human的method
func (e *Employee) SayHi() {
fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
e.company, e.phone) // Yes you can split into 2 lines here.
}
func main() {
mark := Student{Human{"Mark", 25, "222-222-YYYY"}, "MIT"}
sam := Employee{Human{"Sam", 45, "111-888-XXXX"}, "Golang Inc"}
mark.SayHi()
sam.SayHi()
}
结果：
Hi, I am Mark you can call me on 222-222-YYYY
Hi, I am Sam, I work at Golang Inc. Call me on 111-888-XXXX