在这里插入图片描述

🌷🍁 博主猫头虎带您 Go to Golang Language.✨✨🍁
🦄 博客首页——猫头虎的博客🎐
🐳《面试题大全专栏》文章图文并茂🦕生动形象🦖简单易学！欢迎大家来踩踩~🌺
🌊 《IDEA开发秘籍专栏》学会IDEA常用操作，工作效率翻倍~💐
🌊 《100天精通Golang(基础入门篇）》学会Golang语言，畅玩云原生，走遍大小厂~💐

🪁🍁 希望本文能够给您带来一定的帮助🌸文章粗浅，敬请批评指正！🍁🐥

100天精通Golang（基础入门篇）

方法
- - 摘要 📝
  - 引言 🎙️
  - 导语 🗺️
- 1.1 什么是方法
- 1.2 方法的语法
- 1.3 方法和函数
- 1.4 变量作用域
- 1.5 method继承
- 1.6 method重写
- 1.7 接口与方法
- 1.8 方法的签名
- 1.9 方法值和方法表达式
- - 方法值
  - 方法表达式
- 1.10 方法的可见性
- - 总结🌟
  - 参考资料
结语

方法

深入剖析Go语言：第19天专注方法（Method）的妙用与实践

摘要 📝

掌握Go语言的方法（Method）🛠️不仅能让你的代码更加有序✅，也能实现更多功能🚀和更高的可维护性🔧。本篇博客是我们"100天精通Golang"系列📚的第19篇，将深入解释Go中方法的语法📖、用法🤔、作用范围🌐以及与函数的区别🔄等。

引言 🎙️

你好，亲爱的读者👋，我是猫头虎博主😺🐅！Go语言因其简洁🗂️、高效⚡而日益受到开发者的喜爱💖。然而，要想充分利用Go语言的强大功能💪，理解其方法（Method）的概念🧠是非常必要的。在本篇博客中，我们将一同探讨Go语言中的方法概念🕵️‍♀️，看看它是如何使我们的编程生活变得更美好😊。

导语 🗺️

本篇博文将覆盖以下几个方面📋：

1️⃣ 方法的基本语法和定义方式📐
2️⃣ 值接收者和指针接收者的区别🔍
3️⃣ 方法与函数的对比📊
4️⃣ 局部变量和全局变量在方法中的应用📍
5️⃣ 方法的继承与重写🔄

无论你是Go语言的新手👶还是有经验的开发者👨‍💻，我相信这篇文章都能给你带来一些新的见解🌟。

这样的格式更加吸引人，并且能在视觉上快速传达重要信息。希望这能帮助你！😊

1.1 什么是方法

Go 语言中同时有函数和方法。一个方法就是一个包含了接受者的函数，接受者可以是命名类型或者结构体类型的一个值或者是一个指针。所有给定类型的方法属于该类型的方法集

方法只是一个函数，它带有一个特殊的接收器类型，它是在func关键字和方法名之间编写的。接收器可以是struct类型或非struct类型。接收方可以在方法内部访问。

方法能给用户自定义的类型添加新的行为。它和函数的区别在于方法有一个接收者，给一个函数添加一个接收者，那么它就变成了方法。接收者可以是值接收者，也可以是指针接收者。

在调用方法的时候，值类型既可以调用值接收者的方法，也可以调用指针接收者的方法；指针类型既可以调用指针接收者的方法，也可以调用值接收者的方法。

也就是说，不管方法的接收者是什么类型，该类型的值和指针都可以调用，不必严格符合接收者的类型。

1.2 方法的语法

定义方法的语法

func (t Type) methodName(parameter list)(return list) {
  
}
func funcName(parameter list)(return list){
    
}

实例代码：

package main

import (  
    "fmt"
)

type Employee struct {  
    name     string
    salary   int
    currency string
}

/*
 displaySalary() method has Employee as the receiver type
*/
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() //Calling displaySalary() method of Employee type
}

可以定义相同的方法名

示例代码：

package main

import (
	"fmt"
	"math"
)

type Rectangle struct {
	width, height float64
}
type Circle struct {
	radius float64
}


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())
}

运行结果

Area of r1 is:  24
Area of r2 is:  36
Area of c1 is:  314.1592653589793
Area of c2 is:  1963.4954084936207

虽然method的名字一模一样，但是如果接收者不一样，那么method就不一样
method里面可以访问接收者的字段
调用method通过.访问，就像struct里面访问字段一样

1.3 方法和函数

既然我们已经有了函数，为什么还要使用方法？

示例代码：

package main

import (  
    "fmt"
)

type Employee struct {  
    name     string
    salary   int
    currency string
}

/*
 displaySalary() method converted to function with Employee as parameter
*/
func displaySalary(e Employee) {  
    fmt.Printf("Salary of %s is %s%d", e.name, e.currency, e.salary)
}

func main() {  
    emp1 := Employee{
        name:     "Sam Adolf",
        salary:   5000,
        currency: "$",
    }
    displaySalary(emp1)
}

在上面的程序中，displaySalary方法被转换为一个函数，而Employee struct作为参数传递给它。这个程序也产生了相同的输出：Salary of Sam Adolf is $5000.。

为什么我们可以用函数来写相同的程序呢?有以下几个原因

Go不是一种纯粹面向对象的编程语言，它不支持类。因此，类型的方法是一种实现类似于类的行为的方法。
相同名称的方法可以在不同的类型上定义，而具有相同名称的函数是不允许的。假设我们有一个正方形和圆形的结构。可以在正方形和圆形上定义一个名为Area的方法。这是在下面的程序中完成的。

1.4 变量作用域

作用域为已声明标识符所表示的常量、类型、变量、函数或包在源代码中的作用范围。

Go 语言中变量可以在三个地方声明：

函数内定义的变量称为局部变量
函数外定义的变量称为全局变量
函数定义中的变量称为形式参数

局部变量

在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，参数和返回值变量也是局部变量。

全局变量

在函数体外声明的变量称之为全局变量，首字母大写全局变量可以在整个包甚至外部包（被导出后）使用。

package main

import "fmt"

/* 声明全局变量 */
var g int

func main() {

   /* 声明局部变量 */
   var a, b int

   /* 初始化参数 */
   a = 10
   b = 20
   g = a + b

   fmt.Printf("结果： a = %d, b = %d and g = %d\n", a, b, g)
}

结果

结果： a = 10, b = 20 and g = 30

形式参数

形式参数会作为函数的局部变量来使用

指针作为接收者

若不是以指针作为接收者，实际只是获取了一个copy，而不能真正改变接收者的中的数据

func (b *Box) SetColor(c Color) {
	b.color = c
}

示例代码

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.setVal()
	fmt.Println(p.height, s.height)
}

结果

20 2

如果没有那个*，则值就是2 2

1.5 method继承

method是可以继承的，如果匿名字段实现了一个method，那么包含这个匿名字段的struct也能调用该method

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
}

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()
}

运行结果：

Hi, I am Mark you can call me on 222-222-YYYY
Hi, I am Sam you can call me on 111-888-XXXX

1.6 method重写

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

方法是可以继承和重写的
存在继承关系时，按照就近原则，进行调用

1.7 接口与方法

在 Go 语言中，接口定义了一组方法，但这些方法不包含实现代码。它们没有被绑定到特定的类型。接口的方法可以通过任何类型来实现，这样该类型就满足了接口。

type Sayer interface {
    Say() string
}

type Dog struct {
}

func (d Dog) Say() string {
    return "Woof!"
}

type Cat struct {
}

func (c Cat) Say() string {
    return "Meow!"
}

func AnimalTalk(s Sayer) {
    fmt.Println(s.Say())
}

func main() {
    var d Sayer = Dog{}
    var c Sayer = Cat{}

    AnimalTalk(d)
    AnimalTalk(c)
}

在这个例子里，Sayer 接口包含了一个 Say 方法。我们定义了两个结构体类型 Dog 和 Cat，然后使它们都满足 Sayer 接口。最后，在 AnimalTalk 函数中使用接口作为参数，实现了多态。

1.8 方法的签名

每个方法都有一个方法签名，这告诉我们方法接受哪种类型的接收者。这非常重要，因为这决定了哪些方法属于接口类型，或者更通用地说，它决定了一组方法（以及它们的签名）如何形成一个接口。

type Geometry interface {
    Area() float64
    Perimeter() float64
}

type Square struct {
    side float64
}

func (s Square) Area() float64 {
    return s.side * s.side
}

func (s Square) Perimeter() float64 {
    return 4 * s.side
}

在这里，Geometry 接口包含 Area 和 Perimeter 方法，这两个方法都没有参数并返回一个浮点数。因此，任何具有这两个方法的类型都满足 Geometry 接口。

1.9 方法值和方法表达式

在 Go 中，方法不仅可以作为接收者类型的一部分来调用，还可以作为独立的值和表达式。

方法值

当你保存方法作为值时，接收者也会被保存。

type Greeter struct {
    Name string
}

func (g Greeter) Greet() {
    fmt.Println("Hello", g.Name)
}

func main() {
    greet := Greeter{Name: "John"}.Greet
    greet()
}

方法表达式

方法表达式返回一个函数，该函数接受一个接收者和原方法的其他参数。

type Adder struct {
    Base int
}

func (a Adder) Add(x int) int {
    return a.Base + x
}

func main() {
    add := Adder{Base: 2}.Add
    fmt.Println(add(3)) // Output: 5
}

1.10 方法的可见性

和字段或函数一样，如果方法的第一个字母是大写的，那么这个方法可以被这个包以外的代码访问。这是 Go 的导出规则。

package geometry

type Rectangle struct {
    Length, Width float64
}

func (r Rectangle) Area() float64 {
    return r.Length * r.Width
}

func (r Rectangle) perimeter() float64 {
    return 2 * (r.Length + r.Width)
}