Golang之方法的学习

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}