type | Helium

定义结构体、接口、类型别名等。
定义自定义类型：
- 自定义类型由一组值以及作用于这些值的方法组成。
- 类型一般有类型别名，往往从现有类型组合通过type关键字构造出一个新的类型。

自定义类型

Go基础数据类型：
- bool、complex64、complex128、float32、float64。
- int、int8、int16、int32、int64、rune、string。
- uint、uint8、uint16、uint32、uint64、byte、uintptr。
使用type关键字可以定义自己的类型，可以使用type定义一个新的结构体。
也可以把一个已经存在的类型作为基础类型而定义新类型，然后在代码中使用新的类型名字。

1

type IZ int

IZ是一种新类型，然后可以使用下面方式声明变量。

1

var a IZ = 5

可以看到int是变量a的底层类型，这也使得他们之间成为相互转化的可能。
定义多个类型如下：

1
2
3
4
5


type (
    IZ int
    FZ float64
    STR string
)

在type IZ int中，IZ就是在int类型基础上构建的新名称，这称为自定义类型，使用IZ来操作int类型的数据。
这种方法定义之后的类型可以拥有更多的特性，但是在类型转换时必须显示转换。
每个值都必须在经过编译后属于某个类型（编辑器必须能够推断出所有值得类型）因为Go是一种静态类型语言。
在必要以及可行的情况下，一种类型的值可以被转换成另外一种类型的值。
Go语言不存在隐式转换，因此所有的转换都必须显式说明，就像调用一个函数一样（类型在这里的作用可以看作是一种函数）。

1

valueOfTypeB = typeB(valueOfTypeA)

类型B的值 = 类型B(类型A的值)。
type TZ int中，新类型TZ不会拥有原基础类型所附带的方法。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


package main

import (
    "fmt"
)

type A struct {
    Face int
}

func (a A) f () {
    fmt.Println("hi ", a.Face)
}

// 自定义新类型Aa。没有基础类型A的方法
type Aa A

func main()  {
    var s A = A{Face:9}
    s.f()           // hi  9

    var sa Aa = Aa{Face:90}
    //sa.f()    // 方法不存在
    fmt.Println(sa) // {90}
}

通过type关键字在原有类型基础上构造出一个新类型，需要针对新类型来重新创建新方法。

类型别名

类型别名在Go1.9版本中实现，将别名类型和原类型这两个类型视为完全一致。

1

type IZ = int

与type IZ int不同，type IZ = int只是为int取了个别名，而type IZ int却是定义了新类型。
自定义类型不会拥有原类型附带的方法，而别名拥有原类型附带的方法，类型别名拥有原类型全部的方法。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


package main

import (
    "fmt"
)

type A struct {
    Face int
}

func (a A) f () {
    fmt.Println("hi ", a.Face)
}

// 自定义新类型Aa。没有基础类型A的方法
type Aa = A

func main()  {
    var s A = A{Face:9}
    s.f()           // hi  9

    var sa Aa = Aa{Face:90}
    sa.f()          // hi  90
    fmt.Println(sa) // {90}
}

Go语言不存在类型继承。
函数也是一个确定的类型，就是以函数签名作为类型，函数签名：函数的参数和返回值。

1

type typeFunc func(int, int) int

可以在函数体中的某处返回使用类型为typeFunc的变量varfunc。

1

return varfunc

自定义类型不会继承原有类型的方法，但接口方法或组合类型的内嵌元素则保留原有的方法。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


package main

import (
    "fmt"
)

// Mutex 用两种方法，Lock和Unlock
type Mutex struct{}

func (m *Mutex) Lock() {}

func (m *Mutex) Unlock() {}

//NewMutex 和 Mutex 的数据结构一样，但是其方法是空的
type NewMutex Mutex

// PtrMutex 的方法也是空的
type PtrMutex Mutex

// PrintableMutex 拥有Lock和Unlock方法
type PrintableMutex struct {
    Mutex	// 组合
}

func main()  {}

自定义类型#

类型别名#

自定义类型

类型别名