1. 类型别名
类型别名需要在别名和原类型之间加上赋值符号 = ，使用类型别名定义的类型与原类型等价，Go  语言内建的基本类型中就存在两个别名类型。

byte 是 uint8 的别名类型；
rune 是 int32 的别名类型；

类型别名定义形式如下：
type MyString = string

上面代码表明 MyString 是 string 类型的别名类型。也就是说别名类型和源类型表示的是同一个目标，就譬如每个人的学名和乳名一样，都表示同一个人。
定义 string 类型的别名，示例代码：
func main() {
	type MyString = string
	str := "hello"
	a := MyString(str)
	b := MyString("A" + str)
	fmt.Printf("str type is %T\n", str)
	fmt.Printf("a type is %T\n", a)
	fmt.Printf("a == str is %t\n", a == str)
	fmt.Printf("b > a is %t\n", b > a)
}

输出结果
str type is string
a type is string
a == str is true
b > a is false

定义 []string 类型的别名，示例代码：
func main() {
	type MyString = string
	strs := []string{"aa", "bb", "cc"}
	a := []MyString(strs)

	fmt.Printf("strs type is %T\n", strs)
	fmt.Printf("a type is %T\n", a)
	fmt.Printf("a == nil is %t\n", a == nil)
	fmt.Printf("strs == nil is %t\n", strs != nil)
}

运行结果为：
strs type is []string
a type is []string
a == nil is false
strs == nil is true

从上面结果可以得出以下结论：

别名类型与源类型是完全相同的；
别名类型与源类型可以在源类型支持的条件下进行相等判断、比较判断、与 nil 是否相等判断等；

2. 类型定义
类型定义是定义一种新的类型，它与源类型是不一样的。看下面代码：

func main() {
	type MyString string
	str := "hello"
	a := MyString(str)
	b := MyString("A" + str)
	fmt.Printf("str type is %T\n", str)
	fmt.Printf("a type is %T\n", a)
	fmt.Printf("a value is %#v\n", a)
	fmt.Printf("b value is %#v\n", b)
	// fmt.Printf("a == str is %t\n", a == str)
	fmt.Printf("b > a is %t\n", b > a)
}

输出结果为：
str type is string
a type is main.MyString
a value is "hello"
b value is "Ahello"
b > a is false

可以看到 MyString 类型为 main.MyString 而原有的 str 类型为 string，两者是不同的类型，如果使用下面的判断相等语句
fmt.Printf("a == str is %t\n", a == str)

会有编译错误提示
invalid operation: a == str (mismatched types MyString and string)

说明类型不匹配。
下面代码
func main() {
	type MyString string

	strs := []string{"E", "F", "G"}
	myStrs := []MyString(strs)
	fmt.Println(myStrs)
}

编译报错提示
cannot convert strs (type []string) to type []MyString


对于这里的类型再定义来说，string 可以被称为 MyString2 的潜在类型。潜在类型的含义是，某个类型在本质上是哪个类型。潜在类型相同的不同类型的值之间是可以进行类型转换的。
因此，MyString2 类型的值与 string 类型的值可以使用类型转换表达式进行互转。但对于集合类的类型[]MyString2 与 []string 来说这样做却是不合法的，因为 []MyString2 与 []string 的潜在类型不同，分别是 []MyString2 和 []string 。
另外，即使两个不同类型的潜在类型相同，它们的值之间也不能进行判等或比较，它们的变量之间也不能赋值。
func main() {
	type MyString1 = string
	type MyString2 string
	str := "BCD"
	myStr1 := MyString1(str)
	myStr2 := MyString2(str)
	myStr1 = MyString1(myStr2)
	myStr2 = MyString2(myStr1)

	myStr1 = str

	myStr2 = str
	// cannot use str (type string) as type MyString2 in assignment

	myStr1 = myStr2
	// cannot use myStr2 (type MyString2) as type string in assignment

	myStr2 = myStr1
	// cannot use myStr1 (type string) as type MyString2 in assignment
}

参考：

https://time.geekbang.org/column/article/13601

学名
别名




PR_KWP2000OnTP20
VW-Can


PR_KWP2000OnTP16
CanKwp


PR_KWP1281OnKLine
Bosch


PR_UDSOnCan
UDS


大众CAN_TP20参考https://www.cnblogs.com/Galesaur-wcy/p/13306992.html

基于UDS的BootLoader

人有乳名和学名,,标志识别电脑(的)(地)址也有本名和别名..名字存在(的)意义就是把人与人、物与物区别开来,,同一事物多个名称,,主要用于不同场合,,再者就是身份和(地)位(的)象征..记录(的)别名,,大抵也不外乎这几个目(的).. 　　别名记录(CNAME)也被称为规范名字..这种记录允许您将多个名字映射到同一台计算机..就像我们人一样,,无论有多少个名字,,最终都是指向一个人..最常见(的)就是同时提供WWW和MAIL服务(的)计算机..如::host.123.com,,它同时提供WWW和MAIL服务,,为了便于用户访问服务..可以为该计算机设置两个别名(CNAME)::WWW和MAIL..
 这两个别名(的)全称就是“www.123.com”和“mail.123.com”..实际上他们都指向“host.123.com”..同样(的)技巧可以用于当您拥有多个域名需要指向同一服务器IP,,此时您就可以将一个域名做A记录指向服务器IP然后将其他(的)域名做别名到之前做A记录(的)域名上,,那么当您(的)服务器IP(地)址变更时您就可以不必麻烦(的)一个一个域名更改指向了
 只需要更改做A记录(的)那个域名其他做别名(的)那些域名(的)指向也将自动更改到新(的)IP(地)址上了.. 　　别名::www.123.com指向 主机名::host.mydomain.com 指向 主机IP::127.0.0.1 　　别名::mail.123.com
 指向 主机名::host.mydomain.com 指向 主机IP::127.0.0.1 　　无论是哪个别名,,被访问时首先指向主机名,,然后对主机名进行解析,,解析结果按原路返回.. 　　关于别名设置程序也很简单,,如下图::　  别名下面文本框内,,可自行设定别名,,填好主机名,,选择网络运营商,,电信?网通?还是其它..TTL值全称是“生存时间(Time
 To Live)”,,它表示DNS记录在DNS服务器上缓存时间,,这里是一个钟..假设,,有这样一个域名myhost.123.com对应IP(地)址为1.1.1.1,,它(的)TTL为一个钟..这个域名或称这条记录存储在一台名为dns.123.com(的)DNS服务器上,,时间为一个小时

1. 类型别名定义
定义类型别名的写法为：
type TypeAlias = Type

类型别名规定： TypeAlias  只是 Type  的别名，本质上 TypeAlias  与 Type  是同一个类型，就像一个孩子小时候有小名、乳名，上学后用学名，英语老师又会给他起英文名，但这些名字都指的是他本人。
2. 类型定义
类型定义语法如下：
type newType Type

其中 newType  是一种新的类型， newType  本身依然具备 Type 类型的特性。
类型声明语句一般出现在包一级，因此如果新创建的类型名字的首字符大写，则在包外部也可以使用。
一个类型声明语句创建了一个新的类型名称，和现有类型具有相同的底层结构。新命名的类型提供了一个方法，用来分隔不同概念的类型，这样即使它们底层类型相同也是不兼容的。
为了说明类型声明，我们将不同温度单位分别定义为不同的类型：
package tempconv

type Celsius float64    // 摄氏温度
type Fahrenheit float64 // 华氏温度

const (
	AbsoluteZeroC Celsius = -273.15 // 绝对零度
	FreezingC     Celsius = 0       // 结冰点温度
	BoilingC      Celsius = 100     // 沸水温度
)

func CToF(c Celsius) Fahrenheit {
	return Fahrenheit(c*9/5 + 32)
}

func FToC(f Fahrenheit) Celsius {
	return Celsius((f - 32) * 5 / 9)
}

我们在这个包声明了两种类型： Celsius 和 Fahrenheit 分别对应不同的温度单位。它们虽然有着相同的底层类型 float64 ，但是它们是不同的数据类型，因此它们不可以被相互比较或混在一个表达式运算。
刻意区分类型，可以避免一些像无意中使用不同单位的温度混合计算导致的错误；因此需要一个类似 Celsius(t) 或 Fahrenheit(t) 形式的显式转型操作才能将 float64 转为对应的类型。
Celsius(t) 和 Fahrenheit(t) 是类型转换操作，它们并不是函数调用。类型转换不会改变值本身，但是会使它们的语义发生变化。另一方面， CToF 和 FToC 两个函数则是对不同温度单位下的温度进行换算，它们会返回不同的值。
对于每一个类型 T ，都有一个对应的类型转换操作 T(x) ，用于将 x 转为 T 类型（译注：如果 T 是指针类型，可能会需要用小括弧包装 T，比如(*int)(0)）。
只有当两个类型的底层基础类型相同时，才允许这种转型操作，或者是两者都是指向相同底层结构的指针类型，这些转换只改变类型而不会影响值本身。如果 x 是可以赋值给 T 类型的值，那么 x 必然也可以被转为 T 类型，但是一般没有这个必要。
数值类型之间的转型也是允许的，并且在字符串和一些特定类型的 slice 之间也是可以转换的。
例如，将一个浮点数转为整数将丢弃小数部分，将一个字符串转为[]byte类型的 slice 将拷贝一个字符串数据的副本。在任何情况下，运行时不会发生转换失败的错误（译注: 错误只会发生在编译阶段）。
底层数据类型决定了内部结构和表达方式，也决定是否可以像底层类型一样对内置运算符的支持。这意味着， Celsius 和 Fahrenheit 类型的算术运算行为和底层的 float64 类型是一样的，正如我们所期望的那样。
fmt.Printf("%g\n", BoilingC-FreezingC) // "100" °C
boilingF := CToF(BoilingC)
fmt.Printf("%g\n", boilingF-CToF(FreezingC)) // "180" °F
fmt.Printf("%g\n", boilingF-FreezingC)       // compile error: type mismatch

比较运算符==和<也可以用来比较一个命名类型的变量和另一个有相同类型的变量，或有着相同底层类型的未命名类型的值之间做比较。但是如果两个值有着不同的类型，则不能直接进行比较：
var c Celsius
var f Fahrenheit
fmt.Println(c == 0)          // "true"
fmt.Println(f >= 0)          // "true"
fmt.Println(c == f)          // compile error: type mismatch
fmt.Println(c == Celsius(f)) // "true"!

注意最后那个语句。尽管看起来像函数调用，但是 Celsius(f) 是类型转换操作，它并不会改变值，仅仅是改变值的类型而已。测试为真的原因是因为 c 和 g 都是零值。
一个命名的类型可以提供书写方便，特别是可以避免一遍又一遍地书写复杂类型（译注：例如用匿名的结构体定义变量）。虽然对于像 float64 这种简单的底层类型没有简洁很多，但是如果是复杂的类型将会简洁很多，特别是我们即将讨论的结构体类型。
命名类型还可以为该类型的值定义新的行为。这些行为表示为一组关联到该类型的函数集合，我们称为类型的方法集。
下面的声明语句， Celsius 类型的参数 c 出现在了函数名的前面，表示声明的是 Celsius 类型的一个名叫 String 的方法，该方法返回该类型对象 c 带着 °C 温度单位的字符串：
func (c Celsius) String() string { 
	return fmt.Sprintf("%g°C", c) 
}

许多类型都会定义一个 String 方法，因为当使用 fmt 包的打印方法时，将会优先使用该类型对应的 String 方法返回的结果打印。
c := FToC(212.0)
fmt.Println(c.String()) // "100°C"
fmt.Printf("%v\n", c)   // "100°C"; no need to call String explicitly
fmt.Printf("%s\n", c)   // "100°C"
fmt.Println(c)          // "100°C"
fmt.Printf("%g\n", c)   // "100"; does not call String
fmt.Println(float64(c)) // "100"; does not call String

3. 类型别名与类型定义差异
类型别名与类型定义表面上看只有一个等号的差异，那么它们之间实际的区别有哪些呢？下面通过一段代码来理解。
package main

import (
	"fmt"
)

// 将NewInt定义为int类型
// 通过 type 关键字的定义，NewInt 会形成一种新的类型，NewInt 本身依然具备 int 类型的特性。
type NewInt int

// 将int取一个别名叫IntAlias, 将 IntAlias 设置为 int 的一个别名，使 IntAlias 与 int 等效。
type IntAlias = int

func main() {

	// 将a声明为NewInt类型
	var a NewInt
	// 查看a的类型名
	fmt.Printf("a type: %T\n", a)	// a type: main.NewInt

	// 将 b 声明为IntAlias类型
	var b IntAlias
	// 查看b的类型名
	fmt.Printf("b type: %T\n", b)	// b type: int
}


结果显示 a 的类型是 main.NewInt ，表示 main 包下定义的 NewInt  类型，b 类型是 int ， IntAlias  类型只会在代码中存在，编译完成时，不会有 IntAlias  类型。
4. 非本地类型不能定义方法
能够随意地为各种类型起名字，是否意味着可以在自己包里为这些类型任意添加方法呢？参见下面的代码演示：
package main

import (
	"time"
)

// 定义time.Duration的别名为MyDuration
type MyDuration = time.Duration

// 为 MyDuration 添加一个方法
func (m MyDuration) EasySet(a string) {

}

func main() {

}


错误信息：
./hello.go:11:6: cannot define new methods on non-local type time.Duration

编译器提示：不能在一个非本地的类型 time.Duration  上定义新方法，非本地类型指的就是 time.Duration  不是在 main  包中定义的，而是在 time  包中定义的，与 main  包不在同一个包中，因此不能为不在一个包中的类型定义方法。
修改方案为将第 8 行类型别名修改为类型定义，如下：
type MyDuration time.Duration

5. 在结构体成员嵌入时使用别名
当类型别名作为结构体嵌入的成员时会发生什么情况呢？请参考下面的代码。
package main

import (
	"fmt"
	"reflect"
)

// 定义商标结构
type Brand struct {
}

// 为商标结构添加Show()方法
func (t Brand) Show() {
}

// 为Brand定义一个别名FakeBrand
type FakeBrand = Brand

// 定义车辆结构
type Vehicle struct {

	// 嵌入两个结构
	FakeBrand
	Brand
}

func main() {

	// 声明变量a为车辆类型
	var a Vehicle

	// 指定调用FakeBrand的Show
	a.FakeBrand.Show()

	// 取a的类型反射对象
	ta := reflect.TypeOf(a)

	// 遍历a的所有成员
	for i := 0; i < ta.NumField(); i++ {

		// a的成员信息
		f := ta.Field(i)

		// 打印成员的字段名和类型
		fmt.Printf("FieldName: %v, FieldType: %v\n", f.Name, f.Type.
			Name())
	}
}


输出结果：
FieldName: FakeBrand, FieldType: Brand
FieldName: Brand, FieldType: Brand

这个例子中，FakeBrand 是 Brand 的一个别名，在 Vehicle 中嵌入 FakeBrand 和 Brand 并不意味着嵌入两个 Brand，FakeBrand 的类型会以名字的方式保留在 Vehicle 的成员中。
如果尝试将第 33 行改为：
a.Show()

编译器将发生报错：
ambiguous selector a.Show

在调用 Show() 方法时，因为两个类型都有 Show() 方法，会发生歧义，证明 FakeBrand 的本质确实是 Brand 类型。
6. 函数也是类型，可以作为参数传递给别的函数
package main

type math func(int, int) int //定义一个函数类型，两个 int 参数，一个 int 返回值

//定义一个函数 add，这个函数两个 int 参数一个 int 返回值，与 math 类型相符
func add(i int, j int) int {
    return i + j
}

//再定义一个 multiply，这个函数同样符合 math 类型
func multiply(i, j int) int {
    return i * j
}

//foo 函数，需要一个 math 类型的参数，用 math 类型的函数计算第 2 和第 3 个参数数字，并返回计算结果
//稍后在 main 中我们将 add 函数和 multiply 分别作为参数传递给它
func foo(m math, n1, n2 int) int {
    return m(1, 2)
}

func main() {
    //传递 add 函数和两个数字，计算相加结果
    n := foo(add, 1, 2)
    println(n)

    //传递 multply 和两个数字，计算相乘结果
    n = foo(multiply, 1, 2)
    println(n)
}

7. type 类型用法
type  有如下几种用法：

定义结构体
定义接口
类型定义
类型别名
类型查询

7.1 定义结构体
结构体是用户自定义的一种抽象的数据结构， Golang  中 struct  类似于 Java  语言中的 class ，在程序设计中，有着举足轻重的地位。结构体的用法，将会在 struct  关键字中详细的介绍。下边来看一下定义一个结构体的语法格式：
type name struct {
    Field1  dataType
    Field2  dataType
    Field3  dataType
}

7.2 定义接口
接口相关知识点，将会在 interface  关键字中详细介绍，下边来看一段定义接口的语法格式：
type name interface{
    Read()
    Write()
}

7.3 类型定义
使用类型定义定义出来的类型与原类型不相同，所以不能使用新类型变量赋值给原类型变量，除非使用强制类型转换。下面来看一段示例代码，根据 string  类型，定义一种新的类型，新类型名称是 name ：
type name string

为什么要使用类型定义呢？
类型定义可以在原类型的基础上创造出新的类型，有些场合下可以使代码更加简洁，如下边示例代码：
package main
import (
    "fmt"
)
// 定义一个接收一个字符串类型参数的函数类型
type handle func(str string)
// exec函数，接收handle类型的参数
func exec(f handle) {
    f("hello")
}
func main() {
    // 定义一个函数类型变量，这个函数接收一个字符串类型的参数
    var p = func(str string) {
        fmt.Println("first", str)
    }
    exec(p)
    // 匿名函数作为参数直接传递给exec函数
    exec(func(str string) {
        fmt.Println("second", str)
    })
}

输出信息是：
first hello
second hello

上边的示例是类型定义的一种简单应用场合，如果不使用类型定义，那么想要实现上边示例中的功能，应该怎么书写这段代码呢？
// exec函数，接收handle类型的参数
func exec(f func(str string)) {
    f("hello")
}

exec  函数中的参数类型，需要替换成 func(str string)  了，咋一看去也不复杂，但是假如 exec  接收一个需要 5 个参数的函数变量呢？是不是感觉参数列表就会很长了。
func exec(f func(str string, str2 string, num int, money float64, flag bool)) {
    f("hello")
}

从上边的代码可以发现， exec  函数的参数列表可读性变差了。下边再来看看使用类型定义是怎么实现这个功能：
package main
import (
    "fmt"
)
// 定义一个需要五个参数的函数类型
type handle func(str string, str2 string, num int, money float64, flag bool)
// exec函数，接收handle类型的参数
func exec(f handle) {
    f("hello", "world", 10, 11.23, true)
}
func demo(str string, str2 string, num int, money float64, flag bool) {
    fmt.Println(str, str2, num, money, flag)
}
func main() {
    exec(demo)
}

7.4 类型别名
类型别名这个特性在 Golang 1.9 中引入。使用类型别名定义出来的类型与原类型一样，即可以与原类型变量互相赋值，又拥有了原类型的所有方法集。给 strng  类型取一个别名，别名名称是 name ：
type name = string

类型别名与类型定义不同之处在于，使用类型别名需要在别名和原类型之间加上赋值符号（ = ）；使用类型别名定义的类型与原类型等价，而使用类型定义出来的类型是一种新的类型。
如下边示例：
package main
import (
    "fmt"
)
type a = string
type b string
func SayA(str a) {
    fmt.Println(str)
}
func SayB(str b) {
    fmt.Println(str)
}
func main() {
    var str = "test"
    SayA(str)
    //错误参数传递，str是字符串类型，不能赋值给b类型变量
    SayB(str)
}

这段代码在编译时会出现如下错误：
.\main.go:21:6: cannot use str (type string) as type b in argument to SayB

从错误信息可知， str  为字符串类型，不能当做 b  类型参数传入 SayB  函数中。而 str  却可以当做 a  类型参数传入到 SayA  函数中。由此可见，使用类型别名定义的类型与原类型一致，而类型定义定义出来的类型，是一种新的类型。
给类型别名新增方法，会添加到原类型方法集中
给类型别名新增方法后，原类型也能使用这个方法。下边请看一段示例代码：
package main
import (
    "fmt"
)
// 根据string类型，定义类型S
type S string
func (r *S) Hi() {
    fmt.Println("S hi")
}
// 定义S的类型别名为T
type T = S
func (r *T) Hello() {
    fmt.Println("T hello")
}
// 函数参数接收S类型的指针变量
func exec(obj *S) {
    obj.Hello()
    obj.Hi()
}
func main() {
    t := new(T)
    s := new(S)
    exec(s)
    // 将T类型指针变量传递给S类型指针变量
    exec(t)
}

输出信息是：
T hello
S hi
T hello
S hi

上边的示例中，S 是原类型，T 是 S 类型别名。在给 T 增加了 Hello 方法后，S 类型的变量也可以使用 Hello 方法。说明给类型别名新增方法后，原类型也能使用这个方法。从示例中可知，变量 t 可以赋值给 S 类型变量 s，所以类型别名是给原类型取了一个小名，本质上没有发生任何变化。
类型别名，只能对同一个包中的自定义类型产生作用。举个例子，Golang SDK 中有很多个包，是不是我们可以使用类型别名，给 SDK 包中的结构体类型新增方法呢？答案是：不行。请牢记一点：类型别名，只能对包内的类型产生作用，对包外的类型采用类型别名，在编译时将会提示如下信息：
cannot define new methods on non-local type string

7.5 类型查询
类型查询，就是根据变量，查询这个变量的类型。为什么会有这样的需求呢？
Goalng  中有一个特殊的类型 interface{} ，这个类型可以被任何类型的变量赋值，如果想要知道到底是哪个类型的变量赋值给了 interface{} 类型变量，就需要使用类型查询来解决这个需求，示例代码如下：
package main
import (
    "fmt"
)
func main() {
    // 定义一个interface{}类型变量，并使用string类型值”abc“初始化
    var a interface{} = "abc"
    // 在switch中使用 变量名.(type) 查询变量是由哪个类型数据赋值。
    switch v := a.(type) {
    case string:
        fmt.Println("字符串")
    case int:
        fmt.Println("整型")
    default:
        fmt.Println("其他类型", v)
    }
}

如果使用 .(type) 查询类型的变量不是 interface{}  类型，则在编译时会报如下错误：
cannot type switch on non-interface value a (type string)

如果在 switch  以外地方使用 .(type) ，则在编译时会提示如下错误：
use of .(type) outside type switch

所以，使用 type  进行类型查询时，只能在 switch  中使用，且使用类型查询的变量类型必须是 interface{} 。