go实战基础（一）-go实战interface（十二）-《GO开发知识笔记》

admin
admin
admin
0
文章
0
评论
2025-11-04 01:18:37 编程 来源：ZONE.CI 全球网 0 阅读模式 
    1. package main
    3. import "fmt"
    5. //接口是一个规范
    6. type Usber interface {
    7.     start()
    8.     stop()
    9. }
    11. //如果接口里面有方法的话，必要要通过结构体或者通过自定义类型实现这个接口
    13. type Phone struct {
    14.     Name string
    15. }
    17. //手机要实现usb接口的话必须得实现usb接口中的所有方法
    18. func (p Phone) start() {
    19.     fmt.Println(p.Name, "启动")
    20. }
    22. func (p Phone) stop() {
    23.     fmt.Println(p.Name, "关机")
    24. }
    26. type Camera struct {
    27. }
    29. func (p Camera) start() {
    30.     fmt.Println("相机启动")
    31. }
    33. func (p Camera) stop() {
    34.     fmt.Println("相机关机")
    35. }
    37. func (p Camera) run() {
    38.     fmt.Println("run")
    39. }
    41. func main() {
    43.     p := Phone{
    44.         Name: "华为手机",
    45.     }
    46.     // p.start1()
    48.     var p1 Usber //golang中接口就是一个数据类型
    49.     p1 = p       //表示手机实现Usb接口
    50.     p1.stop()
    52.     c := Camera{}
    53.     var c1 Usber = c //表示相机实现了Usb接口
    54.     c1.start()
    55.     // c1.run()  //错误：type Usber has no field or method run)
    56.     c.run() //run
    58. }
    1. package main
    3. import "fmt"
    5. type Usber interface {
    6.     start()
    7.     stop()
    8. }
    10. //电脑
    11. type Computer struct {
    12. }
    14. // var usb Usber =camera
    16. func (c Computer) work(usb Usber) {
    17.     usb.start()
    18.     usb.stop()
    19. }
    21. //手机
    22. type Phone struct {
    23.     Name string
    24. }
    26. func (p Phone) start() {
    27.     fmt.Println(p.Name, "启动")
    28. }
    30. func (p Phone) stop() {
    31.     fmt.Println(p.Name, "关机")
    32. }
    34. //照相机
    35. type Camera struct {
    36. }
    38. func (p Camera) start() {
    39.     fmt.Println("相机启动")
    40. }
    41. func (p Camera) stop() {
    42.     fmt.Println("相机关机")
    43. }
    45. func main() {
    47.     var computer = Computer{}
    48.     var phone = Phone{
    49.         Name: "小米",
    50.     }
    51.     var camera = Camera{}
    53.     computer.work(phone)
    55.     computer.work(camera)
    57. }
    1. package main
    3. import "fmt"
    5. type A interface{} //空接口  表示没有任何约束  任意的类型都可以实现空接口
    7. func main() {
    9.     var a A
    10.     var str = "你好golang"
    11.     a = str                          //让字符串实现A这个接口
    12.     fmt.Printf("值:%v 类型:%T\n", a, a) //值:你好golang 类型:string
    14.     var num = 20
    15.     a = num //表示让int类型实现A这个接口
    16.     fmt.Printf("值:%v 类型:%T\n", a, a)
    18.     var flag = true
    19.     a = flag //表示让bool类型实现A这个接口
    20.     fmt.Printf("值:%v 类型:%T", a, a)
    22. }
    1. package main
    3. import "fmt"
    5. //golang中空接口也可以直接当做类型来使用，可以表示任意类型
    7. //空接口作为函数的参数
    8. func show(a interface{}) {
    9.     fmt.Printf("值:%v 类型:%T\n", a, a)
    10. }
    11. func main() {
    13.     // var a interface{}
    14.     // a = 20
    15.     // fmt.Printf("值:%v 类型:%T\n", a, a)
    16.     // a = "你好golang"
    17.     // fmt.Printf("值:%v 类型:%T\n", a, a)
    18.     // a = true
    19.     // fmt.Printf("值:%v 类型:%T\n", a, a)
    21.     // show(20)
    22.     // show("你好golang")
    23.     // slice := []int{1, 2, 34, 4}
    24.     // show(slice)
    26.     // var m1 = make(map[string]string)
    27.     // m1["username"] = "张三"
    28.     // m1["age"] = "20"
    29.     // fmt.Println(m1)
    31.     // var m1 = make(map[string]interface{})
    32.     // m1["username"] = "张三"
    33.     // m1["age"] = 20
    34.     // m1["married"] = true
    35.     // fmt.Println(m1)
    37.     var s1 = []interface{}{1, 2, "你好", true} //[1 2 你好 true]
    38.     fmt.Println(s1)
    39. }
    1. package main
    3. import "fmt"
    5. //定义一个方法，可以传入任意数据类型，然后根据不同的类型实现不同的功能
    6. func MyPrint1(x interface{}) {
    7.     if _, ok := x.(string); ok {
    8.         fmt.Println("string类型")
    9.     } else if _, ok := x.(int); ok {
    10.         fmt.Println("int类型")
    11.     } else if _, ok := x.(bool); ok {
    12.         fmt.Println("bool类型")
    13.     }
    14. }
    16. //x.(type) 判断一个变量的类型  这个语句只能用在switch语句里面
    17. func MyPrint2(x interface{}) {
    19.     switch x.(type) {
    20.     case int:
    21.         fmt.Println("int类型")
    22.     case string:
    23.         fmt.Println("string类型")
    24.     case bool:
    25.         fmt.Println("bool类型")
    26.     default:
    27.         fmt.Println("传入错误...")
    28.     }
    29. }
    31. //类型断言
    32. func main() {
    33.     // var a interface{}
    34.     // a = "你好golang"
    35.     // v, ok := a.(string)
    36.     // if ok {
    37.     //     fmt.Println("a就是一个string类型,值是：", v)
    38.     // } else {
    39.     //     fmt.Println("断言失败")
    40.     // }
    42.     // MyPrint1("你好golang")
    43.     // MyPrint1(true)
    45.     MyPrint2("你好golang")
    46.     MyPrint2(true)
    48. }
    1. package main
    3. import "fmt"
    5. type Usber interface {
    6.     start()
    7.     stop()
    8. }
    10. //电脑
    11. type Computer struct {
    12. }
    14. func (c Computer) work(usb Usber) {
    15.     //要判断usb的类型
    16.     if _, ok := usb.(Phone); ok { //类型断言
    17.         usb.start()
    18.     } else {
    19.         usb.stop()
    20.     }
    22. }
    24. //手机
    25. type Phone struct {
    26.     Name string
    27. }
    29. func (p Phone) start() {
    30.     fmt.Println(p.Name, "启动")
    31. }
    33. func (p Phone) stop() {
    34.     fmt.Println(p.Name, "关机")
    35. }
    37. //照相机
    38. type Camera struct {
    39. }
    41. func (p Camera) start() {
    42.     fmt.Println("相机启动")
    43. }
    44. func (p Camera) stop() {
    45.     fmt.Println("相机关机")
    46. }
    48. func main() {
    50.     var computer = Computer{}
    51.     var phone = Phone{
    52.         Name: "小米手机",
    53.     }
    54.     var camera = Camera{}
    56.     computer.work(phone)
    57.     computer.work(camera)
    59. }
    1. package main
    3. import "fmt"
    5. /*
    6. 结构体值接收者实现接口：
    8. 值接收者： 如果结构体中的方法是值接收者，那么实例化后的结构体值类型和结构体指针类型都可以赋值给接口变量
    10. */
    11. type Usber interface {
    12.     start()
    13.     stop()
    14. }
    16. type Phone struct {
    17.     Name string
    18. }
    20. func (p Phone) start() { //值接收者
    21.     fmt.Println(p.Name, "启动")
    22. }
    24. func (p Phone) stop() {
    25.     fmt.Println(p.Name, "关机")
    26. }
    28. func main() {
    30.     // 结构体值接收者例化后的结构体值类型和结构体指针类型都可以赋值给接口变量
    32.     var p1 = Phone{
    33.         Name: "小米手机",
    34.     }
    35.     var p2 Usber = p1 //表示让Phone实现Usb的接口
    36.     p2.start()
    38.     var p3 = &Phone{
    39.         Name: "苹果手机",
    40.     }
    41.     var p4 Usber = p3 //表示让Phone实现Usb的接口
    42.     p4.start()
    44. }
    1. package main
    3. import "fmt"
    5. /*
    6. 结构体指针接收者实现接口：
    8. 指针接收者： 如果结构体中的方法是指针接收者，那么实例化后结构体指针类型都可以赋值给接口变量， 结构体值类型没法赋值给接口变量。
    10. */
    11. type Usber interface {
    12.     start()
    13.     stop()
    14. }
    16. type Phone struct {
    17.     Name string
    18. }
    20. func (p *Phone) start() { //指针接收者
    21.     fmt.Println(p.Name, "启动")
    22. }
    24. func (p *Phone) stop() {
    25.     fmt.Println(p.Name, "关机")
    26. }
    28. func main() {
    30.     /*
    31.        错误写法
    32.            var phone1 = Phone{
    33.                Name: "小米",
    34.            }
    35.            var p1 Usber = phone1 // Phone does not implement Usber (start method has pointer receiver
    36.            p1.start()
    37.     */
    39.     var phone1 = &Phone{
    40.         Name: "小米",
    41.     }
    42.     var p1 Usber = phone1
    43.     p1.start()
    44. }
    1. package main
    3. import "fmt"
    5. //定义一个Animal的接口，Animal中定义两个方法，分别是SetName和GetName。分别让Dog结构体和Cat结构体实现这个方法
    7. type Animaler interface {
    8.     SetName(string)
    9.     GetName() string
    10. }
    12. type Dog struct {
    13.     Name string
    14. }
    16. func (d *Dog) SetName(name string) {
    17.     d.Name = name
    18. }
    20. func (d Dog) GetName() string {
    21.     return d.Name
    22. }
    24. type Cat struct {
    25.     Name string
    26. }
    28. func (c *Cat) SetName(name string) {
    29.     c.Name = name
    30. }
    31. func (c Cat) GetName() string {
    32.     return c.Name
    33. }
    35. func main() {
    37.     //Dog实现Animal的接口
    38.     d := &Dog{
    39.         Name: "小黑",
    40.     }
    41.     var d1 Animaler = d
    42.     fmt.Println(d1.GetName())
    43.     d1.SetName("阿奇")
    44.     fmt.Println(d1.GetName())
    46.     //Cat实现Animal的接口
    47.     c := &Cat{
    48.         Name: "小花",
    49.     }
    50.     var c1 Animaler = c
    51.     fmt.Println(c1.GetName())
    52. }
    1. package main
    3. import "fmt"
    5. //一个结构体实现多个接口
    6. type Animaler1 interface {
    7.     SetName(string)
    8. }
    9. type Animaler2 interface {
    10.     GetName() string
    11. }
    13. type Dog struct {
    14.     Name string
    15. }
    17. func (d *Dog) SetName(name string) {
    18.     d.Name = name
    19. }
    21. func (d Dog) GetName() string {
    22.     return d.Name
    23. }
    25. func main() {
    27.     //Dog实现Animal的接口
    28.     d := &Dog{
    29.         Name: "小黑",
    30.     }
    32.     var d1 Animaler1 = d //表示让Dog实现Animaler1这个接口
    33.     var d2 Animaler2 = d //表示让Dog实现Animaler2这个接口
    35.     d1.SetName("小花狗狗")
    36.     fmt.Println(d2.GetName()) //小花狗狗
    38. }
    1. package main
    3. import "fmt"
    5. //接口嵌套
    6. type Ainterface interface {
    7.     SetName(string)
    8. }
    9. type Binterface interface {
    10.     GetName() string
    11. }
    13. type Animaler interface { //接口的嵌套
    14.     Ainterface
    15.     Binterface
    16. }
    18. type Dog struct {
    19.     Name string
    20. }
    22. func (d *Dog) SetName(name string) {
    23.     d.Name = name
    24. }
    26. func (d Dog) GetName() string {
    27.     return d.Name
    28. }
    30. func main() {
    32.     //Dog实现Animal的接口
    33.     d := &Dog{
    34.         Name: "小黑",
    35.     }
    37.     var d1 Animaler = d //表示让Dog实现Animaler这个接口
    38.     d1.SetName("小花狗狗")
    39.     fmt.Println(d1.GetName()) //小花狗狗
    41. }
    1. package main
    3. import "fmt"
    5. type Address struct {
    6.     Name  string
    7.     Phone int
    8. }
    10. // Golang中空接口和类型断言使用细节
    11. func main() {
    13.     var userinfo = make(map[string]interface{})
    14.     userinfo["username"] = "张三"
    15.     userinfo["age"] = 20
    16.     userinfo["hobby"] = []string{"睡觉", "吃饭"}
    18.     fmt.Println(userinfo["age"])
    19.     fmt.Println(userinfo["hobby"])
    21.     // fmt.Println(userinfo["hobby"][1]) //interface {} does not support indexing
    23.     var address = Address{
    24.         Name:  "李四",
    25.         Phone: 1521242141,
    26.     }
    27.     fmt.Println(address.Name) //李四
    29.     userinfo["address"] = address
    31.     fmt.Println(userinfo["address"]) //{李四 1521242141}
    33.     // var name = userinfo["address"].Name //type interface {} is interface with no methods
    34.     // fmt.Println(name)
    36.     hobby2, _ := userinfo["hobby"].([]string)
    38.     fmt.Println(hobby2[1]) //吃饭
    40.     address2, _ := userinfo["address"].(Address)
    41.     fmt.Println(address2.Name, address2.Phone) //李四 1521242141
    43. }

    版权声明

    本站仅做备份收录，仅供研究与教学参考之用。
    读者将信息用于其他用途的，全部法律及连带责任由读者自行承担，本站不承担任何责任。

    ZONE.CI 全球网 | 安全领域涉猎者-乌云独行地带
    ZONE.CI 全球网
    安全领域涉猎者-乌云独行地带
    以太坊cppgolang区别 编程

    以太坊cppgolang区别

    以太坊是一种去中心化的开源平台，它采用智能合约技术，旨在构建和运行不受干扰的分布式应用程序。作为目前最受欢迎的区块链平台之一，以太坊提供了多种编程语言的支持，其
    12-282 评论
    progolang 编程

    progolang

    Go语言（Golang）是由Google开发的一门静态类型编程语言。作为一名专业的Golang开发者，我深知这门语言的优势和特点。在本文中，我将介绍Golang
    12-281 评论
    golangn个发送者 编程

    golangn个发送者

    Golang是一种开源的编程语言，由Google团队开发，旨在提高程序的并发性和简化软件开发过程。在Go语言中，有时需要向多个接收者发送信息。本文将介绍如何在G
    12-280 评论
    golang技能图谱 编程

    golang技能图谱

    从互联网行业的快速发展到人工智能技术的日益成熟，各种编程语言也应运而生。而在这众多的编程语言中，Golang（即Go）作为一门强大且高效的开发语言备受关注。Go
    12-281 评论
    ZONE.CI 全球网 | 安全领域涉猎者-乌云独行地带
    安全领域涉猎者-乌云独行地带
    ZONE.CI 全球网
    评论：0   参与：  6