Go——类型方法

末蓝、 2023-10-09 20:57 63阅读 0赞

### 1、自定义类型 ###

用户自定义类型使用关键字ype,其语法格式是`type newtype oldtype`。oldtype可以是自定义类型、预声明类型、未命名类型中的任意一种。newtype是新类型的标识符，与oldtype具有相同的底层类型，并且都继承了底层类型的操作集  
合（这里的操作不是方法，比如底层类型是map,支持range迭代访问，则新类型也可以使用range迭代访问).除此之外，newtype和oldtype是两个完全不同的类型，newtype不会继承oldtype的方法。无论oldtype是什么类型，使用ype声明的新类型都是一种命名类型，也就是说，自定义类型都是命名类型。

type INT int //INT是一个使用预声明类型声明的自定义类型
    type Map map[string]string //Map是一个使用类型字面量声明的自定义类型
    type myMap Map //myMap是一个自定义类型Map声明的自定义类型
    //INT、Map、myMap都是命名类型

##### 自定义struct类型 #####

//使用type自定义的结构类型属于命名类型
    type XXXname struct {
        
    	Field1 type1
    	Field2 type2
    ...
    }
    
    //errorString是一个自定义结构类型，也是命名类型
    type errorString struct {
        
    	s string
    }
    
    //结构字面量属于未命名类型
    struct {
        
    	Field1 type1
    	Field2 type2
    ...
    }
    
    //struct{}是非命名类型空结构
    var s = struct{
        }{
        }

##### struct初始化 #####

type Person struct {
        
    	name string
    	age int
    }

1.  按照字段顺序进行初始化

//三种
    a := Person{
        "andes", 18}
    
    b := Person{
        
    	"andes",
    	18,
    	}
    
    c := Person{
        
    	"andes",
    	18}
    //这不是一种推荐的方法，一旦结构增加字段，则不得不修改顺序初始化语句。

1.  指定字段名进行初始化

a := Person{
        name:"andes", age:18}
    
    b := Person{
        
    	name: "andes",
    	age: 18,
    }
    
    c := Person{
        
    	name: "andes",
    	age: 18}
    //这是一种推荐的方法，一旦结果增加字段，这不用修改初始化语句

注意：如果上述两种结构的初始化语句结尾的"\}"独占一行，则最后一个字段的后面一定要带上逗号。

1.  使用new创建内置函数，字段默认初始化为其类型的零值，返回值是指向结构的指针

p := new(Person)
    //这种方法不常用，一般使用struct都不会将所有字段初始化为零值

1.  一次初始化一个字段

p := Person{
        }
    
    p.name = "andes"
    p.age = 18
    //不常用，没有封装，违背了struct本身抽象封装的理念

1.  使用构造函数进行初始化

//这是推荐的一种方法，当结果发生变化时，构造函数可以屏蔽细节，下面是标准库中errors的New函数示例
    
    //${GOROOT}/src/errors/errors.go
    // New returns an error that formats as the given text.
    func New(text string) error {
        
    	return &errorString{
        text}
    }
    
    // errorString is a trivial implementation of error.
    type errorString struct {
        
    	s string
    }

##### 结构字段的特点 #####

结构的字段可以是任意的类型，基本类型、接口类型、指针类型、函数类型都可以作为struct的字段。结构字段的类型名必须唯一，struct字段类型可以是普通类型，也可以是指针。另外，结构支持内嵌自身的指针，这也是实现树形和链表等复杂数据结构的基础。例如：

//标准库container/list
    
    type Element struct {
        
    	//指向自身类型的指针
    	next, prev *Element
    	list *List
    	Value interface{
        }
    }

##### 匿名字段 #####

在定义suct的过程中，如果字段只给出字段类型，没有给出字段名，则称这样的字段为“匿名字段”。被匿名嵌入的字段必须是命名类型或命名类型的指针，类型字面量不能作为匿名字段使用。匿名字段的字段名默认就是类型名，如果匿名字段是指针类型，则默认的字段名就是指针指向的类型名。但一个结构体里面不能同时存在某一类型及其指针类型的匿名字段，原因是二者的字段名相等。如果嵌入的字段来自其他包，则需要加上包名，并且必须是其他包可以导出的类型。示例如下：

//interface{}是接口字面量类型标识，所有i是非命名类型变量
    var i interface{
        }
    
    //Reader是定义接口类型，属于命名类型
    type Reader interface {
        
    	Read(p []byte) (n int, err error)
    }

### 2、方法 ###

Go语言的类型方法是一种对类型行为的封装。Go语言的方法非常纯粹，可以看作特殊类型的函数，其显式地将对象实例或指针作为函数的第一个参数，并且参数名可以自己指定，而不强制要求一定是this或self。这个对象实例或指针称为方法的接收者(reciever)。为命名类型定义方法的语法格式如下：

//类型方法接受者是值类型
    func (t TypeName) MethodName(ParamList) (Returnlist){
        
    	//method body
    } 
    
    //类型方法接受者指针
    func (t *TypeName) MethodName(ParamList) (Returnlist){
        
    	//method body
    }

说明：

*  t是接收者，可以自由指定名称。
 *  TypeName为命名类型的类型名。
 *  MethodName为方法名，是一个自定义标识符。
 *  ParamList是形参列表。
 *  ReturnList是返回值列表。

Go语言的类型方法本质上就是一个函数，没有使用隐式的指针，这是Go的优点，简单明了。我们可以将类型的方法改写为常规的函数。示例如下：

//类型方法接受者是值类型
    func TypName_MethodName(t TypeName, otherParamList)(Returnlist) {
        
    	//method body
    }
    
    //类型方法接受者指针
    func TypName_MethodName(t *TypeName, otherParamList)(Returnlist) {
        
    	//method body
    }
    
    //示例
    package main
    
    import (
    	"fmt"
    )
    
    func main() {
        
    	var s SliceInt = []int{
        1, 2, 3, 4}
    	s.Sum()
    	SliceInt_Sum(s)
    
    }
    
    type SliceInt []int
    
    func (s SliceInt) Sum() int {
        
    	sum := 0
    	for _, i := range s {
        
    		sum += i
    	}
    	return sum
    }
    
    //这个函数和上面的方法等价
    func SliceInt_Sum(s SliceInt) int {
        
    	sum := 0
    	for _, i := range s {
        
    		sum += i
    	}
    	return sum
    }

类型方法有如下特点：

1.  可以为命名类型增加方法（除了接口），非命名类型不能自定义方法。比如不能为\[\]int类型增加方法，因为\[\]int是非命名类型。命名接口类型本身就是一个方法的签名集合，所以不能为其增加具体的实现方法。
2.  为类型增加方法有一个限制，就是方法的定义必须和类型的定义在同一个包中。不能再为int bool等预声明类型增加方法，因为它们是命名类型，但它们是Go语言内置的  
    预声明类型，作用域是全局的，为这些类型新增的方法是在某个包中，这与第2条规则冲突，所以Go编译器拒绝为int增加方法。
3.  方法的命名空间的可见性和变量一样，大写开头的方法可以在包外被访问，否则只能在包内可见。
4.  使用type定义的自定义类型是一个新类型，新类型不能调用原有类型的方法，但是底层类型支持的运算可以被新类型继承。

package main
    
    import "fmt"
    
    func main() {
        
    	var a MyInt = 10
    	var b MyInt = 10
    
    	//int类型支持的加减乘除运算，新类型同样可用
    	c := a + b
    	d := a * b
    
    	fmt.Printf("%d\n", c)
    	fmt.Printf("%d\n", d)
    }
    
    type MyInt int
    type Map map[string]string
    
    func (m Map) Print() {
        
    	//底层类型支持的range运算，新类型可用
    	for _, key := range m {
        
    		fmt.Println(key)
    	}
    }