go - method方法

method

1. 值与引用
  varName2 = varName1
  varName2.funcName()
  如果 varName2 有变化，varName1 无变化，则为值类型(传递)
  如果 varName2 有变化，varName1 有变化，则为引用类型(传递)

2. Method
  格式：

  func (r [*]ReceiverType) funcName(param) (result) {...}

  注：
  a. r 为struct对象的接收者，接收者不同，方法也不同
  b. r 可以为值传递也可以为引用传递
  c. param 和 result 可有可无，与普通函数一样
  d. 调用方法，用 "." 连接，即 r.funcName()
  e. func (r *ReceiverType) funcName()和 func (r ReceiverType) funcName 不能同时存在(此处funcName相同)
  f. method 可以用于所有的类型
  例：

type Circle struct {  radius float64}func main() {  var c1 Circle  c1.radius = 10.00  fmt.Println("Area of Circle(c1) = ", c1.getArea())}//该 method 属于 Circle 类型对象中的方法func (c Circle) getArea() float64 {  //c.radius 即为 Circle 类型对象中的属性  return 3.14 * c.radius * c.radius}

  用面向对象的方式表示，struct == class，struct 中声明的元素为成员属性，Circle 作为接收者的函数为成员方法
  即 Circle 类名，radius 与 getArea() 分别是 Circle 类对象 c1 的成员属性和成员方法
  例1 (值传递):

type Circle struct {  radius float64}func main() {  var c1 Circle  c1.radius = 10.00  fmt.Println("main(): radius = ", c1.radius)  fmt.Println("Area of Circle(c1) = ", c1.getArea())}func (c Circle) getArea() float64 {  fmt.Println("getArea(): radius = ", c.radius)  return 3.14 * c.radius * c.radius}func (c Circle) setRadius(r float64) {  c.radius = r  fmt.Println("setRadius(): radius = ", c.radius)}

  结果：
setRadius(): radius = 10
main(): radius = 0
getArea(): radius = 0
Area of Circle(c1) = 0
  例2 (引用传递)

type Circle struct {  radius float64}func main() {  var c2 Circle  c2.setRadius(10.00)  fmt.Println("main(): radius = ", c2.radius)  fmt.Printf("Radius of Circle(c2) = %.2f, area = %.2f", c2.radius, c2.getArea())}func (c *Circle) setRadius(r float64) {  c.radius = r  fmt.Println("setRadius(): radius = ", c.radius)}func (c *Circle) getArea() float64 {  fmt.Println("getArea(): radius = ", c.radius)  return 3.14 * c.radius * c.radius}

  结果：
setRadius(): radius = 10
main(): radius = 10
getArea(): radius = 10
Radius of Circle(c2) = 10.00, area = 314.00
  补：
  method可用于所有类型
  定义格式：
  type 自定义类型 类型
  如: type Integer int，类似于给 int 定义一个别名，但是此时的 Integer 与 struct 定义的类型使用方法一样，把它当作一个类，可以为其添加方法
  例：

type Integer intfunc main() {  var i Integer  fmt.Println(i.getType())  fmt.Println(Integer.getType(i))  Integer.Print(i, "I am Int")}func (i Integer) getType() string {  return "Integer == int"}func (i Integer) Print(s string) {  fmt.Println(s)}

  结果：
  Integer == int
  Integer == int
  I am Int
  注：
  a. 接收者为 typeName，而不是 *typeName 时，调用方法 varName.funcName(param) 与 typeName.funcName(varName, param) 一样，如果是 *typeName 则不能后者访问
  b. 如果者为 *typeName 时，通过 varName.funcName() 访问时，等于 (&varName).funcName()，即可以不用在 varName 前面加上 "&" 取地址

3. Method继承与重载
  匿名字段就类似于面向对象编程中的继承成员属性，也可以重载成员属性，method 同样可以继承和重载
  3.1 继承示例：
  类似于调用父类中有而子类中没有的方法
  没有面向对象中的private protected public关键字(通过方法名首字母大小写来判断)

type Person struct {  name string  age int}type Employee struct {  Person  salary int}func main() {  // var em1 Employee = Employee{Person{"rain", 23}, 5000}  em1 := Employee{Person{"Rain", 23}, 5000}  em1.printMsg()}func (p Person) printMsg() {  fmt.Println("I am ", p.name, " , and my age is ", p.age)}

  结果：
  I am Rain , and my age is 23
  3.2 重载示例
  重载方法，通过 varName.funcName() 访问时，也采用最外层优先访问的原则，也类似于面向对象中调用本类中的方法
  通过 varName.匿名字段.funcName() 访问指定匿名字段中的方法，类似于面向对象中调用父类中的方法

type Person struct {  name string  age int}type Employee struct {  Person  salary int}func main() {  // var em1 Employee = Employee{Person{"rain", 23}, 5000}  em1 := Employee{Person{"Rain", 23}, 5000}  em1.printMsg()       //调用最外层(本类)的方法  em1.Person.printMsg()//调用指定匿名字段(父类)的方法}func (p Person) printMsg() {  fmt.Println("I am ", p.name, " , and my age is ", p.age)}func (e Employee) printMsg() {  fmt.Printf("I am %s, my age is %d, and my salary is %d. \n", e.name, e.age, e.salary)}

  结果：
  {{rain 23} 5000}
  I am rain, my age is 23, and my salary is 5000.
  I am rain , and my age is 23