在 Go 中所有需要被定义和声明的对象都是 Type，Go Type 默认包含常用的基础数据类型，称为 Pre-declarered types 比如:
- int
- string
- boolean
基础类型又可以进一步构成更复杂的类型，称之为Composite Types比如： - array
- struct
- map
- slice
- interface
- func
- pointer
- ch
Composite Types 形式常常是 Type Literal ，比如 array 的字面量声明 var array [10]int ，map 的字面量 var dict map[int]string。
Named Type
通过type关键字为一个已有的类型取别名，如：type NewType ExistingType，NewType 被称为别名。
通过查看源码可知（以int类型为例）：
type int int
Pre-declarered types 也是Named Types，也可以为 Pre-Declared Types 起个别名: type Integer int。
Unamed Type
Unamed Types 是一个 Literal Type，也就是没有名字只有 type 本身，像这样 [6]int 、map[string]int。
每一个类型都有自己的 Underlying Type ，如果 T 是 Pre-declared type 或者 Type Literal，它们对应的 Underlying Type 就是自身 T，否则 T 的 Underlying Type 是 T 定义时引用的类型的 Underlying Type，比如 type T int 的 Underlying Type 是 int，int 是 Pre-declared；type T map[int]string 的 Underlying Type 是 map[int]string，map[int]string 是 Type Literal。
Underlying type
如果两个 type 的 Underlying Type 相同，则它们可以有以下特性。
如果两个 type 都是 named type ，彼此之间不能相互赋值
type duration int64
func main() {
var t1 duration
var t2 int64
t1 = t2 // Cannot use 't2' (type int64) as the type duration
}
虽然它们的Underlying Type都是int64，但是不能互相赋值。
如果两个 type 其中一个是 Unnamed Type，彼此之间可以相互赋值
type strMap map[string]string
func main() {
var m1 strMap
var m2 map[string]string
m1 = m2
fmt.Println(m1)
}
如果为一个类型起了名字，说明你想要做区分，所以两个 named types 即使 Underlying Type 相同也是不能相互赋值的。
Named type 和 Unamed type的区别
当 named types 被作为一个 function 的 receiver 时，它就拥有了自己的方法，unamed types 则不能，这是它们的重要区别。
type NewMap map[int]string
func (nm NewMap) add(key int, value string) {
nm[key] = value
}
// Invalid receiver type 'map[int]string' ('map[int]string' is an unnamed type)
func (m map[int]string) add1(key int, value string) {
m[key] = value
}
func main() {
var p NewMap = make(map[int]string)
p.add(10, "a")
fmt.Println(p) //map[10:a]
}
有个一例外是 Pre-Declared Types 不能拥有自己的方法。
func (i int) print() {
fmt.Println(i)
}
编译器会抛出 cannot define new methods on non-local type int 错误，不能对包之外的 type 定义方法，解决这个问题就是对 pre-declared types 重新定义别名。
type 的属性继承
直接继承
已经声明的 Named Type 不会从它的 Underlying Type 或 existing type 继承 method，但是会继承 field。
package main
import (
"fmt"
)
type Person struct {
name string
}
func (p *Person) Speak() {
fmt.Println("I am a person")
}
//Student 是 Named Type
type Student Person
func main() {
var p Person
p.Speak()
var s Student
s.name = "jone"
fmt.Println(s.name)
// s.Speak()
}
Named Type Student 不会继承来自 Person 的 Speak 的方法，打开注释执行报错 s.Speak undefined (type Student has no field or method Speak)，但是 Student 可以继承 Person 的 filed: s.name 可以使用。
The declared type does not inherit any methods bound to the existing type, but the method set of an interface type or of elements of a composite type remains unchanged:
但是也有例外的情况。
如果 existing type 是 interface，它的 method set 会被继承。
package main
import (
"fmt"
)
type I interface {
Talk()
}
// existing type 是 I，I 是个接口，可以直接继承 I 的方法，II 等同于 I
type II I
type Person struct {
name string
}
func (p *Person) Speak() {
fmt.Println("I am a person")
}
func (p *Person) Talk() {
fmt.Println("I am talking")
}
func main() {
var p Person
p.Speak()
p.Talk()
var i I
i = &p
i.Talk()
var ii II
ii = &p
ii.Talk()
}
如果 existing type 被嵌入新 type 作为 filed
如果一个 type TB 被嵌入另一个 type T 作为它的 filed，TB 的所有 field 和 method 都可以在 T 中使用，这种方法称之为 type embedding。
package main
import (
"fmt"
)
type I interface {
Talk()
}
type Person struct {
name string
}
func (p *Person) Speak() {
fmt.Println("I am a person")
}
func (p *Person) Talk() {
fmt.Println("I am talking")
}
type People struct {
Person
}
func main(){
var people People
people.name = "people"
people.Speak()
people.Talk()
}
type 转换
Type 之间是可以相互转换的，但要遵循一定的转换规则，详细请看官方规范 https://golang.org/ref/spec#Conversions。
