Go 语言中同时有函数和方法。一个方法就是一个包含了接受者的函数,接受者可以是命名类型或者结构体类型的一个值或者是一个指针。 所有给定类型的方法属于该类型的方法集。语法格式如下:
func (variable_name variable_data_type) function_name() [return_type]{
/* 函数体*/
}
package main
import "fmt"
type Circle struct {
radius float64
}
func main(){
var c1 Circle
c1.radius =10.00
fmt.Println(c1.getArea())
}
func (c Circle) getArea() float64{
return 3.14 * c.radius
}
输出的结果是31.4
- 函数赋值的方式
//定义一个person结构,类似于在PHP定义了一个person的class
type Person struct {
name string //默认零值为空字符串
age int //默认零值为0
}
func main() {
a := Person{}
//对Person进行属性操作,类似于javascript的操作
a.name = "GO"
a.age = 8
fmt.Println(a)
}
func main() {
//也可以通过字面值进行初始化,这是常用的做法,写法类似于JSON的写法
a := Person{
name: "GO",
age: 8} //注意,如果没有逗号,则}不能另起新行,否则会报错
或者
nb := Person{
name: "GO",
age: 8,
} //有逗号才能另起一行
fmt.Println(a)
}
/结构也是值类型,传值的时候也是值拷贝,并不改变原有结构体
package main
import (
"fmt"
)
//定义一个person结构,类似于在PHP定义了一个person的class
type person struct {
name string //默认零值为空字符串
age int //默认零值为0
}
func main() {
//也可以通过字面值进行初始化,这是常用的做法,写法类似于JSON的写法 ,注意属性名不能加分号
a := person{
name: "GO",
age: 8} //注意,如果没有逗号,则}不能另起新行,否则会报错
fmt.Println("我在A前面输出", a)
A(a) //A(&a)就是值传递,A函数应写成func A(per *person)
fmt.Println("我在A后面输出", a)//很显然,A里面的赋值并没有改变a的值,证明结构是值类型,传值是值拷贝
}
//结构也是值类型,传值的时候也是值拷贝
func A(per person) { //传递per参数,类型为person结构
per.name = "PHP"
fmt.Println("我在A里面输出", per)
}
输出:
我在A前面输出 {GO 8}
我在A里面输出 {PHP 8}
我在A后面输出 {GO 8}
- 匿名结构体
package main
import (
"fmt"
)
//匿名结构
func main() {
a := struct {
name string
age int
}{
name: "PHP",
age: 10,
}
fmt.Println(a) //很显然,A里面的赋值并没有改变a的值,证明结构是值类型,传值是值拷贝
}
输出结果:{PHP 10}
- 嵌套结构体
package main
import (
"fmt"
)
//结构嵌套
type person struct {
name string
age int
contact struct {
phone, city string
}
}
func main() {
a := person{name: "GO", age: 8}
a.contact.phone = "1112345678"
a.contact.city = "福州"
也可以直接赋值
// p1 := Product{Info:Info{"4","8","20"}, Id:"1001", Name:"VFW"}
fmt.Println(a)
}
{GO 8 {1112345678 福州}}
- 结构体除了匿名之外,还能匿名字段
package main
import (
"fmt"
)
//匿名字段
type person struct {
string
int
}
func main() {
a := person{"GO", 8} //注意这里的位置不能对调,应与声明的顺序一样
fmt.Println(a)
}
输出:{GO 8}
- 结构体之间不能用==比较
- 结构体复制
package main
import (
"fmt"
)
//匿名字段
type person struct {
string
int
}
func main() {
a := person{"GO", 8}
b := a
fmt.Println(a, b)
}
输出{GO 8} {GO 8}
- 继承
package main
import (
"fmt"
)
type human struct {
sex int
}
type teacher struct {
human
name string
age int
}
type student struct {
human
name string
age int
}
func main() {
a := teacher{name: "PHP", age: 15}
b := student{name: "GO", age: 8}
fmt.Println(a, b)
}
输出:
{{0} PHP 15} {{0} GO 8}
- 继承 ,修改属性值
package main
import (
"fmt"
)
type human struct {
sex int
}
type teacher struct {
human
name string
age int
}
type student struct {
human
name string
age int
}
func main() {
a := teacher{name: "PHP", age: 15, human: human{sex: 10}} //嵌入结构作为匿名字段时,默认字段名就是嵌入的结果名
b := student{name: "GO", age: 8, human: human{sex: 12}}
a.name = "PYTHON"
b.sex = 222 //如果是嵌入结构,则把原来的字段全部拷贝过来到现在的结构里了,操作字段时无需写成b.human.sex
fmt.Println(a, b)
}
输出:{{10} PYTHON 15} {{222} GO 8}