Golang进阶学习

已于 2023-08-03 23:23:39 修改
阅读量759 收藏 1
点赞数
分类专栏： Go 文章标签： golang 学习 开发语言 云原生
于 2023-08-01 22:17:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56517253/article/details/132051902
版权

Golang进阶学习

视频地址：https://www.bilibili.com/video/BV1Pg41187AS?p=35

1、包

1.1、包的引入

使用包的原因：

  • 我们不可能把所有函数放在同一个源文件中，可以分门别类的放在不同的文件中

  • 解决同名问题，同一个文件中不可以定义相同名字的函数

首先写一个连接数据库的工具函数：


package dbUtils



import "fmt"



func GetConn() { //如果方法首字母大写，则可以被其它包访问

    fmt.Println("我执行了dbUtils包下的getConn函数")

}

再去写main函数：


package main // 1.package是进行包的声明，建议：包的声明与所在文件夹相同



import (

    "GoStudy/advanced/dbUtils" // 2.导入其它包时，包名是从$GOPATH/src/后开始计算的，使用/分隔

    "fmt"

)



func main() {

    fmt.Println("我执行了main包下的main函数")

    dbUtils.GetConn() // 3.函数调用时，前面要定位到所在的包

}

1.2、包的细节

  1. 建议包的声明和所在文件夹同名

  2. main包是程序的入口包，一般main函数会放在这个包下

  3. 打包语法：package 包名

  4. 引入包的语法：import “包的文件夹的路径”，包名是从$GOPATH/src/后开始计算的，使用/分隔

  5. 如果有多个包要导入，推荐采用以下格式


import (

    "GoStudy/advanced/dbUtils"

    "fmt"

)

  1. 函数调用时前面要定位到所在的包

  2. 首字母大写，函数可以被其它包访问

  3. 一个目录下不能有重复的函数

  4. 包名和文件夹的名字可以不一样


// dbUtils.go

package aaa //这里声明的包是aaa



import "fmt"



func GetConn() { 

    fmt.Println("我执行了dbUtils包下的getConn函数")

}





//main.go

package main 



import (

    "GoStudy/advanced/dbUtils" //这里引用的依然是dbUtils

    "fmt"

)



func main() {

    fmt.Println("我执行了main包下的main函数")

    aaa.GetConn() //调用的变成了aaa.GetConn()

}
  1. 一个包下如果有多个go文件，则每个文件里**package 包名**必须一致

包是什么

  • 在程序层面看，包其实是所有使用相同 package 包名 的源文件组成的代码模块

  • 在源文件层面看，其实就是一个文件夹

1.3、init()函数

在Go语言程序执行时导入包语句会自动触发包内部init()函数的调用。

需要注意的是：init()函数没有参数，也没有返回值。

init()函数在程序运行时，会自动被调用执行，不能在代码中主动调用它。

分析init()和main()这两个函数：

相同点：

  • 在定义时不能有任何的参数和返回值

  • 只能由go自动调用，不可以被引用

不同点：

  • init()用于初始化信息，main()用于作为程序的入口

  • init可以应用于任意包中，且可以重复定义多个

  • main函数只能应用于main包中，且只能定义一个

init函数的执行顺序：

  • 对于同一个package

    • 如果是在同一个go文件下，按照init函数的顺序执行

    • 如果是在同一个包中不同go文件下，会将文件名按字符串排序，然后依次执行文件中的init函数

  • 对于不同package

    • 如果不相互依赖，按照 main 包中 import 的顺序调用其包中的 init()函数

    • 如果存在依赖，则最后被依赖的最先被初始化

2、错误处理

2.1、引入

故意写一个除0操作：


package main



import "fmt"



func main() {

    test()

    fmt.Println("继续执行。。。")

}



func test() {

    num1 := 10

    num2 := 0

    result := num1 / num2 // 这里除0了

    fmt.Println(result)

}

/*

    panic: runtime error: integer divide by zero  // panic：恐慌

*/

从输出可以看出来程序中出现错误/恐慌以后，程序被中断，无法继续执行。

类似于Java中的try catch异常捕获，Go中使用defer recover机制处理错误。


package main



import "fmt"



func main() {

    test()

    fmt.Println("继续执行。。。")

}



func test() {

    // 利用defer + recover来捕获错误：defer后加上匿名函数的调用

    defer func() {

        // 调用recover内置函数，可以捕获错误

        err := recover()

        // 如果没有捕获错误，返回值为零值：nil

        if err != nil {

            fmt.Println("错误已经捕获")

            fmt.Println(err)

        }

    }()

    num1 := 10

    num2 := 0

    result := num1 / num2

    fmt.Println(result)

}



/*

错误已经捕获

    runtime error: integer divide by zero

    继续执行。。。

*/

优点：

  • 提高程序健壮性

2.2、自定义错误

需要调用errors包下的New函数：函数返回error类型


package main



import (

    "errors"

    "fmt"

)



func main() {

    err := test()

    if err != nil {

        fmt.Println("错误为：", err)

    }

    fmt.Println("继续执行。。。")

}



func test() (err error) {

    num1 := 10

    num2 := 0

    if num2 == 0 {

        // 抛出自定义错误

        return errors.New("除数不能为0~")

    } else {

        result := num1 / num2

        fmt.Println(result)

        return nil

    }



}



/*

    错误为： 除数不能为0~

    继续执行。。。

*/

当出现这样的情况：出现错误以后，后续代码没必要执行了，直接退出。可以借助：builtin包下的内置函数：panic


package main



import (

    "errors"

    "fmt"

)



func main() {

    err := test()

    if err != nil {

        fmt.Println("错误为：", err)

        panic(err)

    }

    fmt.Println("继续执行。。。")

}



func test() (err error) {

    num1 := 10

    num2 := 0

    if num2 == 0 {

        // 抛出自定义错误

        return errors.New("除数不能为0~")

    } else {

        result := num1 / num2

        fmt.Println(result)

        return nil

    }



}



/*

    错误为： 除数不能为0~

    panic: 除数不能为0~    

*/

3、数组

3.1、数组定义格式


 var 数组名 [数组大小]数据类型

 var scores [5]int

3.2、数组内存分析

数组名中存的地址其实就是数组中下标为0的元素对应的地址。


package main



import "fmt"



func main() {





    var arr [3]int16



    fmt.Println(len(arr)) // 数组长度

    fmt.Println(arr)



    fmt.Printf("arr的地址是: %p\n", &arr)

    fmt.Printf("arr[0]的地址是: %p\n", &arr[0])

    fmt.Printf("arr[0]的地址是: %p\n", &arr[1])

}



/*

    3

    [0 0 0]

    arr中的地址是: 0xc0000a6058

    arr[0]中的地址是: 0xc0000a6058

    arr[1]中的地址是: 0xc0000a605a // 因为是int16，所以二者相差2字节

*/

3.3、数组的遍历


package main



import "fmt"



func main() {



    var arr [3]int



    arr[0] = 98

    arr[1] = 22

    arr[2] = 53



    sum := 0



    // 常规遍历

    for i := 0; i < len(arr); i++ {

        sum += arr[i]

    }



    // for range遍历

    for key, value := range arr {

        fmt.Println(key)

        sum += value

    }

    fmt.Println(sum)



}

3.4、数组初始化


package main



import "fmt"



func main() {



    // 第一种:

    var arr1 [3]int = [3]int{16, 88, 53}

    fmt.Println(arr1)



    // 第二种

    var arr2 = [3]int{16, 88, 53}

    fmt.Println(arr2)



    // 第三种

    var arr3 = [...]int{16, 88, 53}

    fmt.Println(arr3)



    // 第四种

    var arr4 = [...]int{2: 53, 0: 16, 1: 88}

    fmt.Println(arr4)



}

3.5、数组的注意事项

1.数组长度是数组类型的一部分，长度不同的数组类型也不同


package main



import "fmt"



func main() {



    var arr1 = [3]int{3, 6, 9}



    var arr2 = [6]int{1, 2, 3, 3, 6, 9}



    fmt.Printf("数组类型为:%T\n", arr1) // 数组类型为:[3]int



    fmt.Printf("数组类型为:%T\n", arr2) // 数组类型为:[6]int



}

2.Go语言中数组默认是值传递，因此会拷贝，新函数里对数组的修改不会同步到原数组


package main



import "fmt"



func main() {



    //值传递

    arr := [4]int{1, 2, 3, 4}

    fmt.Println(arr)



    update(arr, 1, 100)

    fmt.Println(arr)



}



// 更改数组中某个元素的值

func update(arr [4]int, j int, target int) {

    arr[j] = target

    fmt.Println(arr)

}



/*

    [1 2 3 4] //未修改前数组的值

    [1 100 3 4] //update方法里修改后的值

    [1 2 3 4]  //修改后数组的值

*/

3.如果修改想要同步，需要变为引用传递


package main



import "fmt"



func main() {



    //值传递

    arr := [4]int{1, 2, 3, 4}

    fmt.Println(arr)



    update(&arr, 1, 100)

    fmt.Println(arr)



}



// 更改数组中某个元素的值

func update(arr *[4]int, j int, target int) {

    (*arr)[j] = target

    fmt.Println(arr)

}

3.6、二维数组

定义：


var arr [2][3]int

内存分析：


package main



import "fmt"



func main() {



    var arr [2][3]int

    fmt.Println(arr)



    fmt.Printf("arr的地址是%p\n", &arr)

    fmt.Printf("arr[0]的地址是%p\n", &arr[0])

    fmt.Printf("arr[0][0]的地址是%p", &arr[0][0])



}



/*

[[0 0 0] [0 0 0]]

    arr的地址是0xc0000c8030      

    arr[0]的地址是0xc0000c8030   

    arr[0][0]的地址是0xc0000c803

*/

学过C语言的这里应该很好理解，高维数组实际还是一维数组，只是一维数组的每个元素又是一个数组。

初始化：


package main



import "fmt"



func main() {



    var arr [2][3]int = [2][3]int{{1, 2, 3}, {4, 5, 6}}

    fmt.Println(arr)



}

遍历：


package main



import (

    "fmt"

)



func main() {



    var arr = [2][3]int{{1, 2, 3}, {4, 5, 6}}



    // 普通for循环遍历

    for i := 0; i < len(arr); i++ {

        for j := 0; j < len(arr[0]); j++ {

            fmt.Print(arr[i][j], "\t")

        }

        fmt.Println()

    }



    // range遍历

    for _, v1 := range arr {

        for _, v2 := range v1 {

            fmt.Println(v2)

        }

    }



}

4、切片

4.1、引入

  • 切片是golang中一种特有的数据类型。

  • 数组有其特定用处，但是由于长度固定不可变等原因，其实代码中并不常见。切片是一种建立在数组类型之上的抽象，它构建在数组之上并且提供更强大的能力和便捷。

  • 切片（slice）是对数组一个片段的连续引用，所以切片是一个引用类型，这个片段可以是整个数组，或者是其中连续的一部分。


package main



import "fmt"



func main() {



    var intarr [6]int = [6]int{1, 4, 7, 2, 5, 8}



    // 从1开始，到3结束，不包含3

    slice := intarr[1:3]



    // 输出切片

    fmt.Println(slice)



    // 切片元素个数

    fmt.Println("slice的元素个数:", len(slice))



    // 切片容量

    fmt.Println("slice的容量:", cap(slice))



}



/*

    [4 7]

    slice的元素个数: 2

    slice的容量: 5  

*/

4.2、内存分析

切片实际上是有三个字段的数据结构：一个是指向底层数组的指针，一个是切片的长度，一个是切片的容量


package main



import "fmt"



func main() {



    var intarr = [6]int{1, 4, 7, 2, 5, 8}



    // 从1开始，到3结束，不包含3

    slice := intarr[1:3]



    // 输出切片

    fmt.Println(slice)



    // 切片元素个数

    fmt.Println("slice的元素个数:", len(slice))



    // 切片容量

    fmt.Println("slice的容量:", cap(slice))



    fmt.Printf("数组中第2个元素的地址是:%p\n", &intarr[1])

    fmt.Printf("切片中第1个元素的地址是:%p\n", &slice[0])



    slice[1] = 16

    fmt.Println(intarr[2])



}



/*

    [4 7]

    slice的元素个数: 2                  

    slice的容量: 5                      

    数组中第2个元素的地址是:0xc00000e338

    切片中第1个元素的地址是:0xc00000e338

    16  

*/

4.3、切片的定义

  1. 定义一个切片，让它去引用一个已经创建好的数组

package main



import "fmt"



func main() {



    var intarr = [6]int{1, 4, 7, 2, 5, 8}



    // 从1开始，到3结束，不包含3

    slice := intarr[1:3]



    // 输出切片

    fmt.Println(slice)



}
  1. 通过make内置函数来创建切片。

package main



import "fmt"



func main() {



    // make函数的三个参数，切片类型，切片长度，切片容量

    slice := make([]int, 4, 20)

    fmt.Println(slice)

    fmt.Printf("切片的长度为:%d\n", len(slice))

    fmt.Printf("切片的容量为:%d\n", cap(slice))



}



// 实际上是make底层创建一个数组，对外不可见，要通过slice去间接访问各个元素。
  1. 在定义的时候直接指向具体数组

func main() {

    slice := []int{1,4,7}

}

4.4、切片的遍历

  • 普通for循环遍历

  • for-range遍历

4.5、切片的注意事项

  1. 切片定义后不可以直接使用，需要让其引用到一个数组，或者make一个空间供切片使用

  2. 切片使用不能越界

  3. 简写方式

  • var slice = arr[0:end] -------> var slice = arr[:end]

  • var slice = arr[start,len(arr)] -------> var slice = arr[start:]

  • var slice = arr[0,len(arr)] -------> var slice = arr[:]

  1. 切片还可以继续切片

package main



import "fmt"



func main() {



    var intarr [6]int = [6]int{1, 4, 7, 2, 5, 8}



    var slice []int = intarr[1:4]



    slice2 := slice[1:2]



    fmt.Println(slice2)



}
  1. 切片可以动态增长

package main



import "fmt"



func main() {



    var intarr [6]int = [6]int{1, 4, 7, 2, 5, 8}



    var slice []int = intarr[1:4]



    slice2 := append(slice, 88, 60)



    fmt.Println(slice2)



}



/*

1. 底层追加元素的时候首先创建一个新数组

2. 新数组中追加append后的元素

3. 将切片指向新数组

4. 由于我们往往是想在原slice上追加新元素，所以日常使用slice = append(slice, 88, 60)

5. 通过append可以往切片后面追加切片 slice = append(slice,slice2...)

*/
  1. 切片的拷贝

package main



import "fmt"



func main() {



    var a []int = []int{1, 4, 7, 2, 5, 8}



    var b []int = make([]int, 10)



    copy(b, a) // 将a中对应的数组元素拷贝到b中对应的数组中去



    fmt.Println(b)



}

5、Map

Map 是一种无序的键值对的集合。

Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。

Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，遍历 Map 时返回的键值对的顺序是不确定的。

在获取 Map 的值时，如果键不存在，返回该类型的零值，例如 int 类型的零值是 0，string 类型的零值是 “”。

Map 是引用类型，如果将一个 Map 传递给一个函数或赋值给另一个变量，它们都指向同一个底层数据结构，因此对 Map 的修改会影响到所有引用它的变量。

5.1、引入


package main



import "fmt"



func main() {



    var a map[int]string



    a = make(map[int]string, 10)



    a[2009] = "张三"

    a[2010] = "李四"



    fmt.Println(a)



}



/*

1. map在使用之前一定要make

2. map是无序的

3. key不可以重复

*/

5.2、创建

  1. 定义---->初始化----->使用

var a map[int]string

a = make(map[int]string, 10)

a[2009] = "张三"
  1. 定义初始化---->使用

b := make(map[int]string)

b[2009] = "张三"
  1. 初始化使用

c := map[int]string{

    2009: "张三",

    2010: "李四",

}

5.3、操作

5.3.1、增加/更新

map["key"] = value // 如果key存在就是更新，否则是增加
5.3.2、删除/清空

delete(map,"key") // key不存在也不会报错

清空：

  • 逐一遍历key进行删除

  • map = make(…)，make一个新的，让原来的成为垃圾，被gc回收

5.3.3、查询

// value,bool = map[key]   其中value是查找的结果，bool代表是否找到

package main



import "fmt"



func main() {



    var a map[int]string



    a = make(map[int]string, 10)



    a[2009] = ""

    a[2010] = "李四"



    fmt.Println(a)



    d, flag := a[2022]

    fmt.Println(flag)

    fmt.Println(d)



}



/*

由于map的返回是有默认值的，比如key为int，map为string

    由于string可以为空

    因此在value的值可能为默认值时，一定要用bool判断是否获取key成功

*/
5.3.4、获取长度

fmt.Println(len(map))
5.3.5、遍历

for k, v := range map {

fmt.Println(k, v) // k是key，v是value

}

6、面向对象

Go语言关于面向对象的说明：

  • go支持面向对象编程（oop），但是和传统面向对象编程有区别，并不是纯粹的面向对象语言。

  • go中没有类，使用结构体来实现oop特性。

  • go面向对象编程非常简洁，去掉了传统oop语言的方法重载，构造函数和析构函数、隐藏的this指针等

  • go仍然有面向对象编程的继承、封装和多态的特性，只是实现方式不太一样。比如go中通过匿名字段而不是extends关键字实现继承

以下部分参考自菜鸟教程：Go 语言结构体 | 菜鸟教程 (runoob.com)

6.1、结构体

结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

结构体表示一项记录，比如保存图书馆的书籍记录，每本书有以下属性：

  • ID：图书ID

  • Title ：标题

  • Author ： 作者

  • Date：出版日期

结构体是值传递！！！

6.1.1、定义结构体

type name struct {

   member type

   member type

   ...

   member type

}



package main



import (

    "fmt"

    "time"

)



type Books struct {

    id     int

    title  string

    author string

    date   string

}



func main() {



    // 创建一个新的结构体

    fmt.Println(Books{1, "平凡的世界", "路遥", time.Now().Format("2006-01-02 15:04:05")})



    // key: value创建结构体

    fmt.Println(Books{id: 2, title: "从你的全世界路过", author: "张嘉佳", date: time.Now().Format("2006-01-02 15:04:05")})



    // 指针创建结构体

    var book2 *Books = new(Books)

    (*book2).id = 3

    book2.title = "aaa" // go在底层依然是将该句转化为(*book2).title

    fmt.Println(*book2)



}
6.1.2、访问结构体成员

// 结构体.成员名

package main



import (

    "fmt"

    "time"

)



type Books struct {

    id     int

    title  string

    author string

    date   string

}



func main() {



    book := Books{1, "平凡的世界", "路遥", time.Now().Format("2006-01-02 15:04:05")}

    fmt.Println(book.title)



}
6.1.3、结构体作为函数参数

package main



import (

    "fmt"

    "time"

)



type Books struct {

    id     int

    title  string

    author string

    date   string

}



func printBook(book Books) {

    fmt.Printf("Book id : %d\n", book.id)

    fmt.Printf("Book title : %s\n", book.title)

    fmt.Printf("Book author : %s\n", book.author)

    fmt.Printf("Book date : %s\n", book.date)

}



func main() {



    book := Books{1, "平凡的世界", "路遥", time.Now().Format("2006-01-02 15:04:05")}

    printBook(book)



}
6.1.4、结构体指针

你定义指向结构体的指针类似于其他指针变量，格式如下：


var struct_pointer *Books

以上定义的指针变量可以存储结构体变量的地址。查看结构体变量地址，可以将 & 符号放置于结构体变量前：


struct_pointer = &book

使用结构体指针访问结构体成员，使用 “.” 操作符：


struct_pointer.title

实例：


package main



import (

    "fmt"

    "time"

)



type Books struct {

    id     int

    title  string

    author string

    date   string

}



func printBook(book *Books) {

    fmt.Printf("Book id : %d\n", book.id)

    fmt.Printf("Book title : %s\n", book.title)

    fmt.Printf("Book author : %s\n", book.author)

    fmt.Printf("Book date : %s\n", book.date)

}



func main() {



    book := Books{1, "平凡的世界", "路遥", time.Now().Format("2006-01-02 15:04:05")}

    bookPointer := &book

    printBook(bookPointer)



}
6.1.5、结构体转化
  1. 结构体是用户自定义的类型：和其它类型转化时需要有完全相同的字段（名字、个数和类型）

package main



import "fmt"



type Student struct {

    Age int

}



type Person struct {

    Age int

}



func main() {



    var s Student

    var p Person = Person{10}



    s = Student(p)

    fmt.Println(s)



}
  1. 给结构体起别名后赋值时需要强制转换

package main



import "fmt"



type Student struct {

    Age int

}



type Person Student // 给Student起一个叫Person的别名



func main() {



    var s Student

    var p Person = Person{10}



    s = p // 这里会报错，不能直接赋值使用

    fmt.Println(s)



}

6.2、方法

方法是作用在指定的数据类型上，和指定的数据类型绑定。

6.2.1、方法的声明

type A struct {

    Num int

}



func (a A) test() {

    fmt.Println(a.Num)

}
6.2.2、方法的调用

func main() {

    a := A{10}

    a.test()

}
6.2.3、注意事项

  1. 结构体是值传递，因此如果方法中需要改变原数据的值，参数使用指针类型。如果参数中是指针类型，我们实际使用时可以进行简化，不用(*pointer).方法名，可以直接变量.方法名。

  2. Go中方法是绑定在指定数据类型之上的，因此自定义类型都可以有方法，而不仅仅是struct，比如int、float32等。

6.3、接口

面向对象中的接口的一般定义为"接口定义对象的行为"。它表示让指定对象应该做什么，实现这种行为的方法（实现细节）是针对对象的。

在Go中，接口是一组方法签名，当类型为接口中的所有方法提供定义时，它被称为实现接口。接口与类型的关系是非侵入式的。

接口指定了类型应该具有的方法，类型决定了如何实现这些方法。

视频链接：https://www.bilibili.com/video/BV1XC4y1W7Am?p=90

6.3.1、接口的声明

// USB 接口

type USB interface {

    start() // usb设备开始工作

    end()   // usb设备结束共工作

}
6.3.2、接口的实现

// Mouse 鼠标类型

type Mouse struct {

    name string

}



// FlashDisk u盘类型

type FlashDisk struct {

    name string

}



// 实现接口方法

func (m Mouse) start() {

    fmt.Println(m.name, "鼠标准备就绪，可以开始工作了")

}



func (m Mouse) end() {

    fmt.Println(m.name, "鼠标结束工作，可以安全退出了")

}



func (f FlashDisk) start() {

    fmt.Println(f.name, "u盘准备就绪，可以开始工作了")

}



func (f FlashDisk) end() {

    fmt.Println(f.name, "结束工作，可以弹出")

}
6.3.3、注意事项
  1. 当需要接口类型的对象时，可以使用任意实现类代替

func testInterface(usb USB) { // 参数是USB接口

    usb.start()

    usb.end()

}



func main() {



    m1 := Mouse{"罗技"}



    f1 := FlashDisk{"闪迪"}



    testInterface(m1) // 实际上传实现类即可



    testInterface(f1)



}
  1. 接口对象不能访问实现类中的属性

func main() {



    m1 := Mouse{"罗技"}



    var usb USB

    usb = m1

    fmt.Println(usb.name) // 这里是不合法的



}



// 其实这里很好理解，并不是所有的实现类都有某个属性
6.3.4、空接口

空接口中不包含任何的方法，正因为如此，所有的类型都实现了空接口，因此空接口可以存储任意类型的数值。


package main



import "fmt"



func main() {

    var a1 A = Cat{"橘猫"}

    var a2 A = Person{"白玉秀", 13}



    fmt.Println(a1)

    fmt.Println(a2)



}



type A interface {

}



type Cat struct {

    color string

}



type Person struct {

    name string

    age  int

}

既然这样，当我们不确定某个参数的类型时，就可以使用空接口来代替（泛型）


func print(i interface{}) {

    fmt.Println("a------>", i)

}



func main() {

    var a1 A = Cat{"橘猫"}

    var a2 A = Person{"白玉秀", 13}



    print(a1)

    print(a2)



}
6.3.5、接口嵌套

type A interface {

    test1()

}



type B interface {

    test2()

}



type C interface { // C接口里嵌套A接口和B接口

    A

    B

    test3()

}





// Cat结构体实现了C同时也实现了A和B

func (c Cat) test1() {

    fmt.Println("test1.....................")

}



func (c Cat) test2() {

    fmt.Println("test2.....................")

}

func (c Cat) test3() {

    fmt.Println("test3.....................")

}



func main() {



    var cat Cat = Cat{"橘猫"}

    cat.test1()

    cat.test2()

    cat.test3()



    var catA A = cat // 此时变量是什么类型的，就只能调用什么类型的方法

    catA.test1()



    var catB B = cat

    catB.test2()



}
6.3.6、接口断言

当一个函数的形参是interface{}，那么在函数中，需要对形参进行断言，从而得到它的真实类型。

语法格式：


// 安全类型断言

<目标类型的值>,<布尔参数> := <表达式>.( 目标类型 )



// 非安全类型断言

<目标类型的值> := <表达式>.( 目标类型 )

示例代码：


/*

    定义一个shape的接口，里面有周长和面积两个方法

    但是由于不同图形的计算方式不同，因此当传到一个封装好的计算周长和面积的方法时，我们需要判断图形的类型

    一般有以下两种方式：



    1. 

    if ins, ok := s.(Triangle); ok {

        fmt.Println("是三角形，三边是:", ins.a, ins.b, ins.c)

    } else {



    }



    2. switch instance := 接口对象.(type){

        case 实际类型1:

        ....

        case 实际类型2:

        ....

        ....

    }

*/

package main



import (

    "fmt"

    "math"

)



func main() {

    var t1 = Triangle{3, 4, 5}

    fmt.Println(t1.peri())

    fmt.Println(t1.area())

    fmt.Println(t1.a, t1.b, t1.c)



    var c1 = Circle{2}

    fmt.Println(c1.peri())

    fmt.Println(c1.area())

    fmt.Println(c1.radius)



    getType(t1)

    var t2 *Triangle = &Triangle{3, 4, 8}

    getType(t2)



}



type Shape interface {

    peri() float64 // 周长

    area() float64 // 面积

}



type Triangle struct {

    a, b, c float64

}



func (t Triangle) peri() float64 {

    return t.a + t.b + t.c

}



func (t Triangle) area() float64 {

    p := t.peri() / 2

    s := math.Sqrt(p * (p - t.a) * (p - t.b) * (p - t.c))

    return s

}



type Circle struct {

    radius float64

}



func (c Circle) peri() float64 {

    return c.radius * 4 * math.Pi

}



func (c Circle) area() float64 {

    return math.Pi * c.radius * c.radius

}



func getType(s Shape) {

    if ins, ok := s.(Triangle); ok {

        fmt.Println("是三角形，三边是:", ins.a, ins.b, ins.c)

    } else if ins, ok := s.(Circle); ok {

        fmt.Println("是圆形，半径是:", ins.radius)

    } else {

        fmt.Println("我也不懂了。。。。")

    }

}



func testShape(s Shape) {

    fmt.Printf("周长为:%.2f,面积为:%.2f", s.peri(), s.area())

}

6.4、type关键字

6.4.1、定义新类型

格式：


类型定义：type 类型名 Type

实例代码：


package main



import (

    "fmt"

    "strconv"

)



type myint int

type mystr string



func main() {



    var i1 myint

    var i2 = 100

    i1 = 200

    fmt.Println(i1, i2)



    var name mystr

    name = "像鱼"

    var s1 string

    s1 = "试试水"

    fmt.Println(name, s1)



    //i1 = i2 //Cannot use 'i2' (type int) as the type myint

    //name = s1 //Cannot use 's1' (type string) as the type mystr

    fmt.Printf("%T,%T,%T,%T\n", i1, i2, name, s1)



}
6.4.2、定义函数类型

格式：


type 自定义函数名 func(int, int) string // int 、string可选

实例代码：


package main



import (

    "fmt"

    "strconv"

)



// 2. 定义函数类型

type myfun func(int, int) string



func fun1() myfun {

    fun := func(a int, b int) string {

        s := strconv.Itoa(a) + strconv.Itoa(b)

        return s

    }

    return fun

}



func main() {



    res := fun1()

    fmt.Println(res(1, 2))



}
6.4.3、类型别名

格式：


类型别名：type 类型名 = Type

实例代码：


package main



import (

    "fmt"

    "strconv"

)



// 3. 给类型起别名

type myint2 = int



func main() {



    var i3 myint2

    i3 = 1000

    i4 := 200

    fmt.Printf("%T,%T\n", i3, i4)



}

注意：非本地类型不能定义方法，可参考这篇文章：https://blog.csdn.net/wohu1104/article/details/120463014

6.4.4、结构体成员嵌入

实例代码：


package main



import "fmt"



type Person struct {

    name string

}



func (p Person) show() {

    fmt.Println("p----------->", p.name)

}



type People = Person



type Student struct {

    // 嵌入两个结构体

    Person

    People

}



func main() {

    var s Student

    s.People.name = "王二狗"

    s.name = "王二浪" // ambiguous selector s.name 因为People和Person都有name属性，无法区分是给谁的

    fmt.Println(s)

}

用Java来解释的话，可以理解为如果一个对象中有两个其它的对象，且对象中存在相同的属性，在赋值时候需要指定赋给哪个对象。

笨手笨脚の
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Go语言实战(英文版)
12-10
golang的进阶书，有效提升Go语言实力，让你找工作得心应手
Golang进阶
RNGWGzZs的博客
01-26 1817
因此，在程序执行的过程中，总会存在执行状态的切换(用户到内核，内核到用户)。但是，golang中的协程完完全全解决了这个问题。大多数编程语言，在如何实现并发的问题上，采用的都是基于线程和内存同步访问控制。我们在linux处着重讲了，实现进程间的本质，就是让每个进程(线程)可看到同一份公共资源。此时，只需要在该函数前加上go，这两个执行流就不会处在所谓的"阻塞"状态，而是各管各的。并行的是追是针对多核CPU，它指的是多个核心同时执行多个任务的能力。并发的实质是针对单核CPU，它的交替调度不同任务的能力。
Golang简单入门教程——函数进阶篇
TechFlow的博客
06-15 353
本文始发于个人公众号：TechFlow，原创不易，求个关注 今天是golang专题的第八篇，我们来聊聊golang当中的函数。 我们在之前的时候已经介绍过了函数的基本用法，知道了怎么样设计或者是定义一个函数，以及怎么样调用一个函数，还了解了defer的用法。今天这篇文章我们来继续深入这个话题，来看看golang当中关于函数的一些进阶的用法。 返回error 前文当中我们曾经提到过，在golang当中并没有try catch捕获异常的机制。在其他语言当中异常只有一种，可以通过try catch语句进行捕
golang进阶教程目录
天天water的专栏
01-02 1912
1. Go语言的前世今生 2. 数组、切片和映射 3. 类型系统——类型的本质 4. 类型系统——接口 5. 类型系统——嵌入类型 6. 并发——锁住共享资源 7. 并发——通道 8. 常见并发模式 9. 测试和性能 ...
跟着猫哥学Golang 17 - Channel 进阶
Arthur Guo 的专栏
10-02 1184
上一章降到了Golang的channel有队列的特性，那么逻辑上很自然地可以引出两个操作： 循环channel元素；关闭channel； 依次循环channel中的内容是很容易理解的，先进先出。举个栗子： package main import "fmt" func main() { var pow = []int{1, 2, 4, 8, 16} c := make(chan i
golang基础到进阶系列教程学习
最新发布
08-20
golang基础到进阶系列教程学习
Golang JSON的进阶用法实例讲解
09-20
主要给大家介绍了关于Golang JSON进阶用法的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用golang具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
【go语言学习资料】Go语言基础和进阶以及学习Go语言的一些感悟.zip
05-04
【go语言学习资料】Go语言基础和进阶以及学习Go语言的一些感悟.zip 【资源介绍】 CGO、go_compile、HTTP、kafka_learning、pprof、unit_test、并发基础、底层编程、泛型、内存管理、设计模式、注入、 CGO、go_...
B站大佬谌嘉诚蓝图入门课程同步学习笔记
05-31
B站大佬谌嘉诚蓝图入门课程同步学习笔记
golang高级教程
01-05
非常好的go语言最新进阶教程，适用各类人群学习。pdf格式
golang进阶（二）——cobra更实用的命令行
独自登高楼 望断天涯路
10-11 6741
+++ title=”golang——cobra更实用的命令行” date=”2017-10-11” tags=[“golang”,”glide”,”docker”] categories=[“资源管理”] description=”golang自身带的命令行包，各种case，有代码洁癖的人看着就令人头大” +++cobra是个非常不错的命令行包，docker，hugo都在使用基命令首先
GOLANG进阶：Viper，Mysql，Swagger，Log
masterphp的博客
07-01 598
GOLANG进阶：Viper，Mysql，Swagger
golang高级进阶（一）：进程、线程、并发、并行、goroutine协程
genziisme的专栏
04-21 4928
目录 一、关于进程和线程 1. 进程（Process） 2. 线程 二、关于并发和并行 1. 并发 2. 并行 3. 通俗讲 三、goroutine协程以及主线程 1. 主线程 2. 协程 3. 多协程和多线程 四、go关键词实操 1. 顺序执行 2. 加入go 3. 加入时间 4. 主线程执行快的情况 5. sync.WaitGroup解决不等待 6. 多协程并发并行执行 五、设置golang运行时占用的cpu核数量（不是很重要） 重点：这一篇全是干货，一定要多
Go语言进阶
HY1273383167的博客
01-01 916
Go语言进阶
go语言进阶
bobi的博客
02-16 386
包的目录结构： src目录是专门用来存放go源码文件，每个文件夹都对应一个package 同一目录下所有go文件都属于一个包 import时从go安装目录GOPROOT和GOPATH开始索引 import时 绝对路径：根据src的下一级目录开始 import时 相对路径：main.go所在的路径，以"."开始 import时使用.操作 import ( . "fmt...
GO语言的进阶之路-Golang高级数据结构定义
weixin_33738982的博客
06-26 444
　　　　　　　　　　　　　　　　　　　　　　GO语言的进阶之路-Golang高级数据结构定义 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰 版权声明：原创作品，谢绝转载！否则将追究法律责任。   　　我们之前学习过Golang的基本数据类型，字符串和byte,以及rune也有所了解，但是说起高级点的数据类型，可能我们还是不太清楚，那么今天...
golang学习笔记（进阶篇）
lcynone的博客
01-13 512
Golang学习笔记_进阶篇
Golang 学习进阶资料整理
努力打工
01-03 258
基础 Go语言中文文档（官方文档） Iris中文文档（goWEB框架） Go入门视频 （密码:zd5x） 进阶 Golang的反射（nil!=nil）
【golang简明入门进阶指南01】golang基础变量、函数、条件控制
kouryoushine的博客
03-24 644
说明 本文目的：学习golang 必须掌握的基本语法和概念 前置条件：搭建号golang环境并输出helloworld 一、变量和常量 这部分要分清golang语言的优势特性 1.1 变量声明 名称在前，类型在后，重点突出 变量声明既有初值，不存在null 一旦声明必须使用，编译器决定 可以不声明类型，编译器做类型推断 var和: 等同，后者更短，短就是好 注 := 只能在函数内使用，不能声明全局变量 详细声明方法请参考代码（建议逐行演练一遍） package main import "fmt"
golang语法进阶
08-19
很高兴回答你关于Golang语法进阶的问题！Golang是一门简洁高效的编程语言，下面我将分享一些Golang语法的进阶知识。 1. 嵌套结构体：在Golang中，你可以在一个结构体中嵌套另一个结构体。这样可以更好地组织和管理...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值