方法是什么

func (recv receiver_type) methodName(parameter_list) (return_value_list) { … }

在 Go 语言中，结构体就像是类的一种简化形式，那么面向对象程序员可能会问：类的方法在哪里呢？

在 Go 中有一个概念，它和方法有着同样的名字，并且大体上意思相同：Go 方法是作用在接收者（receiver）上的一个函数，接收者是某种类型的变量。因此方法是一种特殊类型的函数。

接收者类型可以是（几乎）任何类型，不仅仅是结构体类型：任何类型都可以有方法，甚至可以是函数类型，可以是 int、bool、string 或数组的别名类型。但是接收者不能是一个接口类型，因为接口是一个抽象定义，但是方法却是具体实现；如果这样做会引发一个编译错误：invalid receiver type…。

最后接收者不能是一个指针类型，但是它可以是任何其他允许类型的指针。

一个类型加上它的方法等价于面向对象中的一个类。一个重要的区别是：在 Go 中，类型的代码和绑定在它上面的方法的代码可以不放置在一起，它们可以存在在不同的源文件，唯一的要求是：它们必须是同一个包的。

类型 T（或 *T）上的所有方法的集合叫做类型 T（或 *T）的方法集（method set）。

定义方法的一般格式如下：

func (recv receiver_type) methodName(parameter_list) (return_value_list) {
     ... }

在方法名之前，func 关键字之后的括号中指定 receiver。

如果 recv 是 receiver 的实例，Method1 是它的方法名，那么方法调用遵循传统的 object.name 选择器符号：recv.Method1()。

如果 recv 是一个指针，Go 会自动解引用。

如果方法不需要使用 recv 的值，可以用 _ 替换它，比如：

func (_ receiver_type) methodName(parameter_list) (return_value_list) {
     ... }

函数和方法的区别

函数将变量作为参数：Function1(recv)

func UserUpdate(c *gin.Context) {
    
	var service service.UserUpdateService
	if err := c.ShouldBind(&service); err == nil {
    
		res := service.Update()  //方法
		c.JSON(200, res)
	} else {
    
		c.JSON(200, ErrorResponse(err))
		logging.Info(err)
	}
}

方法在变量上被调用：recv.Method1()

func (service *UserUpdateService) Update() serializer.Response {
    
	var user model.User
	code := e.SUCCESS
	//找到用户
	err := model.DB.First(&user, service.ID).Error
	if err != nil {
    
		logging.Info(err)
		code = e.ERROR_DATABASE
		return serializer.Response{
    
			Status: code,
			Msg:    e.GetMsg(code),
			Error:  err.Error(),
		}
	}
	user.Nickname = service.NickName
	user.UserName = service.UserName
	if service.Avatar != "" {
    
		user.Avatar = service.Avatar
	}
	err = model.DB.Save(&user).Error
	if err != nil {
    
		logging.Info(err)
		code = e.ERROR_DATABASE
		return serializer.Response{
    
			Status: code,
			Msg:    e.GetMsg(code),
			Error:  err.Error(),
		}
	}
	return serializer.Response{
    
		Status: code,
		Data:   serializer.BuildUser(user),
		Msg:    e.GetMsg(code),
	}
}

在接收者是指针时，方法可以改变接收者的值（或状态），这点函数也可以做到（当参数作为指针传递，即通过引用调用时，函数也可以改变参数的状态）。

不要忘记 Method1 后边的括号 ()

否则会引发编译器错误：method recv.Method1 is not an expression, must be called

接收者必须有一个显式的名字，这个名字必须在方法中被使用。

receiver_type 叫做 （接收者）基本类型，这个类型必须在和方法同样的包中被声明。

在 Go 中，（接收者）类型关联的方法不写在类型结构里面，就像类那样；耦合更加宽松；类型和方法之间的关联由接收者来建立。

方法没有和数据定义（结构体）混在一起：它们是正交的类型；表示（数据）和行为（方法）是独立的。

Go中的“多态”

1.Go明确避免了子类型和重载
2.Go尚未提供泛型
3.Go的接口提供了多态功能
从语法层面来说，go语言中并没有面向对象的类(class)或是对象(object)，但是我们可以通过对方法的使用来间接面向对象编程。举个例子：
在同一个package service中
可以有以下的方法:

func (service *UserRegisterService) Valid(userId, status interface{
    }) *serializer.Response {
    ...}
func (service *UserRegisterService) Register(userID, status interface{
    }) *serializer.Response {
    ...}
func (service *UserLoginService) Login(userID, status interface{
    }) serializer.Response {
    ...}

func (service *AdminRegisterService) Valid() *serializer.Response {
    ...}
func (service *AdminRegisterService) Register() *serializer.Response {
    ...}
func (service *AdminLoginService) Login() serializer.Response {
    ...}


func (service *SearchProductsService) Show() serializer.Response {
    ...}
func (service *ShowProductService) Show(id string) serializer.Response {
    ...}


func (service *UpdateProductService) Update() serializer.Response {
    ...}
func (service *UpdateCartService) Update() serializer.Response {
    ...}


func (service *DeleteProductService) Delete(id string) serializer.Response {
    ...}
func (service *DeleteFavoriteService) Delete(id string) serializer.Response {
    ...}

不同的receiver_type,即使相同的函数名称也可以。这里的多态就可以多多提高编程中的效率。使得go语言也可以面向对象编程.