go type关键字

[TOC]
type有几种用法：定义结构体，定义接口， 类型别名， 类型定义， 类型开关

定义结构体

结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。类似Java 的类，我们可以把Go中的struct看作是不支持继承行为的轻量级的“类”。

我们来看看使用type怎么定义结构体：

//定义一个 Books结构体
type Books struct {
   title string
   author string
   subject string
   book_id int
}

//结构体内内嵌匿名成员变量定义
func main() {
   p := person{"abc",12}
   fmt.Println(p.string,p.int)
}

type person struct {
   string
   int
}

定义接口

//定义电话接口
type Phone interface {
   call()
}

自定义类型

type name string   // 使用 type 基于现有基础类型，结构体，函数类型创建用户自定义类型。

在这里要区别 var声明方式

var name string    //这里是定义一个string变量

注：类型别名，只能对包内的类型产生作用，对包外的类型采用类型别名，在编译时将会提示如下信息：

cannot define new methods on non-local type string

在Go 语言中，基础类型有下面几种：

  bool byte complex64 complex128 error float32 float64
    int int8 int16 int32 int64 rune string
    uint uint8 uint16 uint32 uint64 uintptr

使用 type 关键字可以定义我们自己的类型，如我们可以使用type定义一个新的结构体，但也可以把一个已经存在的类型作为基础类型而定义新类型，然后就可以在我们的代码中使用新的类型名字，这称为自定义类型，如：

type IZ int

这里IZ就是完全是一种新类型，然后我们可以使用下面的方式声明变量：

var a IZ = 5

这里我们可以看到 int 是变量 a 的底层类型，这也使得它们之间存在相互转换的可能。

如果我们有多个类型需要定义，可以使用因式分解关键字的方式，例如：

type (
   IZ int
   FZ float64
   STR string
)

在 type IZ int 中，IZ 就是在 int 类型基础构建的新名称，这称为自定义类型。然后就可以使用 IZ 来操作 int 类型的数据。使用这种方法定义之后的类型可以拥有更多的特性，但是在类型转换时必须显式转换。

每个值都必须在经过编译后属于某个类型（编译器必须能够推断出所有值的类型），因为 Go 语言是一种静态类型语言。在必要以及可行的情况下，一个类型的值可以被转换成另一种类型的值。由于 Go 语言不存在隐式类型转换，因此所有的转换都必须显式说明，就像调用一个函数一样（类型在这里的作用可以看作是一种函数）：

valueOfTypeB = typeB(valueOfTypeA)

类型 B 的值 = 类型 B(类型 A 的值)

type TZ int 中，新类型不会拥有原基础类型所附带的方法，如下面代码所示：

package main

import (
    "fmt"
)

type A struct {
    Face int
}
type Aa A // 自定义新类型Aa，没有基础类型A的方法

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

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

    var sa Aa = Aa{ Face: 9 }
    sa.f()
}

编译错误信息：sa.f undefined (type Aa has no field or method f)

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

类型定义

除了给已知的类型起别名，还可以针对新类型（自定义类型）函数进行定义

type handle func(str string)  //自定义一个函数func，别名叫做handle，传入一个string参数

类型开关

在Go语言中中存在interface{}类型，可以用来保存任何类型的值，如果我们需要知道具体保存了哪些类型，就需要使用类型开关来判断，具体代码如下：

func classifier(items ...interface{})  {
   for i,x := range items {
      switch x.(type) {
      case bool:
         fmt.Printf("type #%d is bool",i)
      case float64:
         fmt.Printf("type #%d is float64",i)
      case string:
         fmt.Printf("type #%d is string",i)
      case int:
         fmt.Printf("type #%d is int",i)
      default:
         fmt.Printf("type is unknow")
      }
   }
}

Type 定义类型别名

type IZ = int

这种写法其实是定义了int类型的别名，可将别名类型和原类型这两个类型视为完全一致使用。type IZ int 其实是定义了新类型，这和类型别名完全不是一个含义。自定义类型不会拥有原类型附带的方法，而别名是拥有原类型附带的。下面举2个例子说明：

如果是类型别名，完整拥有其方法：

package main

import (
    "fmt"
)

type A struct {
    Face int
}
type Aa=A // 类型别名

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

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

    var sa Aa = Aa{Face: 9}
    sa.f()
}

程序输出：
hi 9
hi 9

结构化的类型没有真正的值，它使用 nil 作为默认值（在 Objective-C 中是 nil，在 Java 中是 null，在 C 和 C++ 中是NULL或 0）。值得注意的是，Go 语言中不存在类型继承。

函数也是一个确定的类型，就是以函数签名作为类型。这种类型的定义例如：

type  typeFunc func ( int, int) int

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

return varfunc