Go语言中只有强制类型转换，没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用。

  1.     import "fmt"
  3.     func main() {
  4.         var i int = 33
  5.         var i64 int64
  6.         i64 = int64(i)
  7.         fmt.Println(i, i64)
  8.     }

在同类型之间，精度高的类型可以向精度低的类型转换，但是可能会造成精度损失，低类型转换到高类型就没有这个问题了。
并且高精度类型向低精度类型转换的时候，还需要注意低精度类型的容量是否足够大。

在Go语言中，我们知道布尔类型不可以和0或1 进行转换，但是我们可以自己定义方法，来进行转换：

  1. // 布尔类型转换为0或者1
  2. func btoi(b bool) int{
  3.     if b {
  4.         return 1
  5.     }
  6.     return 0
  7. }
  1. // 数字转换为布尔类型
  2. func itob(i int) bool { return i != 0 }

所以别的类型之前也可以相互转换，最常用的就是转为 string类型，或者由 string 类型转换为别的类型：

  1.     import "strconv"
  3.     func main() {
  4.         str := "10"
  5.         // string -> int
  6.         i, _ := strconv.Atoi(str)
  7.     }
  1.     import "strconv"
  3.     func main() {
  4.         i := 10
  5.         // int -> string
  6.         str := strconv.Itoa(i)
  7.     }
  1.     import "strconv"
  3.     func main() {
  4.         str := "3.2222"
  5.         // string -> float
  6.         fl64, err := strconv.ParseFloat(str,64)
  7.         fl32, err := strconv.ParseFloat(str,32)
  8.     }
  1.     import (
  2.         "fmt"
  3.         "strconv"
  4.     )
  6.     func main() {
  7.         fl64 := 3.1415926
  8.         // float -> string
  9.         str := strconv.FormatFloat(fl64,'f',-1,64)
  10.         str = fmt.Sprintf("%.3f",fl64)
  11.     }

在 float -> string 时，我们可以使用两种方法：

第一种方法，可以获得更高精度的浮点数
第二种方法，可以更方便我们的使用，我自己日常使用的时候，都是使用第二种

  1.     import "strconv"
  3.     func main() {
  4.         b := true
  5.         // bool -> string
  6.         str: = strconv.FormatBool(b)
  7.     }
  1.     import "strconv"
  3.     func main() {
  4.         str := "true"
  5.         //  string -> bool
  6.         b, err := strconv.ParseBool(str)
  7.     }

当你在使用某个类型时，你可以给它起另一个名字，然后你就可以在你的代码中使用新的名字（用于简化名称或解决名称冲突），例如：

  1.     import "fmt"
  3.     type short int32
  4.     type long int64
  6.     func main() {
  7.         var sh short = 22
  8.         var lo long = 66
  9.         fmt.Println(sh)
  10.         fmt.Println(lo)
  11.     }

第三行和第四行，就是新定义的类型，它拥有原类型的所有特性，可以代替原类型来使用，但是不可以使用原来类型的方法，可以根据新的类型定义新的方法。
不光是语言自带的类型可以定义别名，我们自己定义的结构体，接口，函数，都可以定义别名。

细节决定成败!
个人愚见，如有不对，恳请扶正!

版权声明：本文为xdtg原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/xdtg/p/14507060.html