golang基础-接口、接口嵌套、类型断言、接口与结构体_接口等转换

最新推荐文章于 2024-04-25 20:53:46 发布
最新推荐文章于 2024-04-25 20:53:46 发布
阅读量675 收藏 1
点赞数 1
接口
package main

import "fmt"
type Test interface {
    Print()
    Sleep()
}

type Student struct {
    name  string
    age   int
    score int
}
/*student实现接口Print方法*/
func (p Student) Print() {
    fmt.Println("name:", p.name)
    fmt.Println("age:", p.age)
    fmt.Println("score:", p.score)
}
/*student实现接口Sleep方法*/
func (p Student) Sleep() {
    fmt.Println("student sleep")
}


func main() {

    var t Test
    fmt.Println(t)
    fmt.Println("--------------------")

    var stu Student = Student{
        name:  "stu1",
        age:   20,
        score: 200,
    }
    //使用接口方法
    t = stu
    t.Print()
    t.Sleep()

    fmt.Println("=============")
    fmt.Println("t:", t)
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45

输出如下：

PS E:\golang\go_pro\src\safly> go run demo.go
<nil>
--------------------
name: stu1
age: 20
score: 200
student sleep
=============
t: {stu1 20 200}
PS E:\golang\go_pro\src\safly>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

或者如下的代码也可以：

package main

import "fmt"
type Test interface {
    Print()
    Sleep()
}

type Student struct {
    name  string
    age   int
    score int
}
/*student实现接口Print方法*/
func (p *Student) Print() {
    fmt.Println("name:", (*p).name)
    fmt.Println("age:", (*p).age)
    fmt.Println("score:", (*p).score)
}
/*student实现接口Sleep方法*/
func (p *Student) Sleep() {
    fmt.Println("student sleep")
}


func main() {

    var t Test
    fmt.Println(t)
    fmt.Println("--------------------")

    var stu *Student = &Student{
        name:  "stu1",
        age:   20,
        score: 200,
    }
    //使用接口方法
    t = stu
    t.Print()
    t.Sleep()

    fmt.Println("=============")
    fmt.Println("t:", t)
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45

输出如下：

PS E:\golang\go_pro\src\safly> go run demo.go
<nil>
--------------------
name: stu1
age: 20
score: 200
student sleep
=============
t: &{stu1 20 200}
PS E:\golang\go_pro\src\safly>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
sort接口实现

一种事物的多种形态，都可以按照统一的接口进行操作 
我们来做一个例子，通过实现sort接口，来对切片实现排序

package main

import (
    "fmt"
    "math/rand"
    "sort"
)

type Student struct {
    Name     string
    Id       string
    Age      int
    sortType int
}

type Book struct {
    Name   string
    Author string
}
//别名
type StudentArray []Student

func (p StudentArray) Len() int {
    return len(p)
}

func (p StudentArray) Less(i, j int) bool {
    return p[i].Name < p[j].Name
}

func (p StudentArray) Swap(i, j int) {
    p[i], p[j] = p[j], p[i]
}

func main() {
    var stus StudentArray
    for i := 0; i < 10; i++ {
        stu := Student{
            Name: fmt.Sprintf("stu%d", rand.Intn(100)),
            Id:   fmt.Sprintf("110%d", rand.Int()),
            Age:  rand.Intn(100),
        }

        stus = append(stus, stu)
    }

    for _, v := range stus {
        fmt.Println(v)
    }

    fmt.Println("\n\n")
    sort.Sort(stus)
    for _, v := range stus {
        fmt.Println(v)
    }
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57

输出如下：

PS E:\golang\go_pro\src\safly> go run demo.go
{stu81 1108674665223082153551 47 0}
{stu59 1103916589616287113937 18 0}
{stu25 1101443635317331776148 56 0}
{stu0 1104751997750760398084 11 0}
{stu62 1103510942875414458836 28 0}
{stu74 1102610529275472644968 45 0}
{stu37 1102015796113853353331 95 0}
{stu66 1105263531936693774911 58 0}
{stu47 1102740103009342231109 87 0}
{stu88 1107981306761429961588 15 0}



{stu0 1104751997750760398084 11 0}
{stu25 1101443635317331776148 56 0}
{stu37 1102015796113853353331 95 0}
{stu47 1102740103009342231109 87 0}
{stu59 1103916589616287113937 18 0}
{stu62 1103510942875414458836 28 0}
{stu66 1105263531936693774911 58 0}
{stu74 1102610529275472644968 45 0}
{stu81 1108674665223082153551 47 0}
{stu88 1107981306761429961588 15 0}
PS E:\golang\go_pro\src\safly>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
接口嵌套
package main

import "fmt"

type Reader interface {
    Read()
}

type Writer interface {
    Write()
}

type ReadWriter interface {
    Reader
    Writer
}

type File struct {
}

func (f *File) Read() {
    fmt.Println("read data")
}

func (f *File) Write() {
    fmt.Println("write data")
}
//类似java里面的多态
func TestReader(r Reader) {
    r.Read()
}

//测试接口嵌套
func Test(rw ReadWriter) {
    rw.Read()
    rw.Write()
}


func main() {
    var f File
    //多态
    TestReader(&f)
    //嵌套接口
    Test(&f)

}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48

输出如下：

PS E:\golang\go_pro\src\safly> go run demo.go
read data
read data
write data
PS E:\golang\go_pro\src\safly>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
类型断言

类型断言，由于接口是一般类型，不知道具体类型，如果要转成具体类型

接口.()转换方式
package main

import "fmt"


func main() {
    var i int
    var inter interface{}

    inter = i
    a:=inter.(int)
    fmt.Printf("%d,%T\n",a,a)
    fmt.Printf("%d,%T\n",inter,inter)
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

输出如下：

PS E:\golang\go_pro\src\safly> go run demo.go
0,int
0,int
PS E:\golang\go_pro\src\safly>
 
 
  • 1
  • 2
  • 3
  • 4

或者如下更简单方式

package main

import "fmt"

func Test(a interface{}){
    fmt.Printf("%d,%T\n",a,a)

}

func main() {
    var b int 
    Test(b)
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

输出如下：

PS E:\golang\go_pro\src\safly> go run demo.go
0,int
PS E:\golang\go_pro\src\safly>
 
 
  • 1
  • 2
  • 3
结构体转为接口
package main

import "fmt"

type Stu struct{
    Name string
    Sex string
}

func Test(a interface{}){
    b,ok := a.(Stu)
    if ok == false{
        fmt.Println("convert failed")
        return
    }
    b.Name = "safly"
    fmt.Println(b)

}

func main() {
    var b Stu 
    Test(b)
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

输出如下：

PS E:\golang\go_pro\src\safly> go run demo.go
{safly }
PS E:\golang\go_pro\src\safly>
 
 
  • 1
  • 2
  • 3
结构体指针转为接口
package main

import "fmt"

type Student struct {
    Name string
    Sex  string
}

func Test(a interface{}) {
    b, ok := a.(*Student)
    if ok == false {
        fmt.Println("convert failed")
        return
    }
    fmt.Println(*b)
}


func main() {
    var b Student = Student{
        Name: "stu01",
        Sex:  "female",
    }
    Test(&b)
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

输出如下：

PS E:\golang\go_pro\src\safly> go run demo.go
{stu01 female}
PS E:\golang\go_pro\src\safly>
 
 
  • 1
  • 2
  • 3
接口转为接口
package main

import "fmt"

type Reader interface {
    Read()
}

type Writer interface {
    Write()
}

type ReadWriter interface {
    Reader
    Writer
}

type File struct {
}

func (f *File) Read() {
    fmt.Println("read data")
}

func (f *File) Write() {
    fmt.Println("write data")
}

func Test(rw ReadWriter) {
    rw.Read()
    rw.Write()
}

func main() {
    var f *File
    var b interface{}
    b = f

    //结构体指针
    c:=b.(*File)
    c.Read()
    //接口赋值接口
    oo := b.(Reader)
    oo.Read()
    //接口赋值接口
    v := b.(ReadWriter)
    v.Read()
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49

输出如下：

PS E:\golang\go_pro\src\safly> go run demo.go
read data
read data
read data
PS E:\golang\go_pro\src\safly>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
switch x.(type) 转换方式
package main

import "fmt"

type Student struct {
    Name string
    Sex  string
}


func just(items ...interface{}) {
    for index, v := range items {
        switch v.(type) {
        case bool:
            fmt.Printf("%d params is bool, value is %v\n", index, v)
        case int, int64, int32:
            fmt.Printf("%d params is int, value is %v\n", index, v)
        case float32, float64:
            fmt.Printf("%d params is float, value is %v\n", index, v)
        case string:
            fmt.Printf("%d params is string, value is %v\n", index, v)
        case Student:
            fmt.Printf("%d params student, value is %v\n", index, v)
        case *Student:
            fmt.Printf("%d params *student, value is %v\n", index, v)
        }
    }
}

func main() {
    var b Student = Student{
        Name: "stu01",
        Sex:  "female",
    }

    just(28, 8.2, "this is a test", b, &b)
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38

输出如下：

PS E:\golang\go_pro\src\safly> go run demo.go
0 params is int, value is 28
1 params is float, value is 8.2
2 params is string, value is this is a test
3 params student, value is {stu01 female}
4 params *student, value is &{stu01 female}
PS E:\golang\go_pro\src\safly>
zhchzh1000
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Go 语言接口嵌套
GeeCode的博客
07-04 690
在Go语言中，接口嵌套是指一个接口可以包含另一个或多个接口类型。通过接口嵌套，我们可以将多个接口组合成一个更复杂的接口类型，从而提高代码的可重用性和可扩展性。ReaderWriter }在这个例子中，我们定义了三个接口类型：Reader、Writer和ReadWriter。Reader和Writer分别定义了Read和Write方法，而ReadWriter接口类型则嵌套了Reader和Writer，因此它也包含了Read和Write方法。
实例学习Golang–接口（二、空接口和类型断言）
01-07
空接口的内部实现保存了对象的类型和指针。 使用空接口保存一个数据的过程会比直接用数据对应类型的变量保存稍慢。 因此在开发中，应在需要的地方使用空接口，而不是在所有地方使用空接口。 package main import ...
Golang 接口、接口嵌套
wgchen
08-22 205
Golang 接口、接口嵌套
Golang深入浅出之-接口（Interfaces）详解：抽象、实现与空接口
最新发布
zevjay的博客
04-25 447
接口定义一组方法签名，任何类型只要实现了这些方法，就被视为实现了该接口，无需显式声明。// ...例如，定义一个表示可读写的常见问题与避免方法问题1：接口方法签名不匹配导致实现无效若类型提供的方法与接口方法签名（包括参数类型、返回值类型和数量）不完全一致，将无法实现该接口。避免方法：在实现接口时，确保类型方法与接口方法签名完全匹配。Go语言接口作为一种强大的抽象机制，为软件设计带来了极大的灵活性和可扩展性。
golang interface{}转换成struct结构体的两种方法
秋̶᭄ꦿ攻城狮࿆ྂ
11-05 5127
golang interface{} 转 struct结构体 1.使用断言,强制转换 p, ok := (Value).(user) if ok { fmt.Println("id:" + p.Id) fmt.Println("name:" + p.Name) } els...
golang中结构体嵌套接口
猛犸象
11-23 5374
在golang中结构体A嵌套另一个结构体B见的很多，可以扩展A的能力。 A不仅拥有了B的属性，还拥有了B的方法，这里面还有一个字段提升的概念。 示例： package main import "fmt" type Worker struct { Name string Age int Salary } func (w Worker) fun1() { fmt.Println("Worker fun1") } type Salary struct { Money int } func (s
C# 反射与特性
mozhi
12-25 563
一、一些基本概念 程序集：程序集是为协同工作而生成的类型和资源的集合，这些类型和资源构成了一个逻辑功能单元。程序集向公共语言运行时提供了解类型实现所需要的信息。对于运行时，类型不存在于程序集上下文之外。 元数据：程序集中包含元数据； 类型：System.Type类是反射的中心，当反射提出请求时，CLR为已加载的类型创建 Type ，可使用 Type 对象的方法、字段、属性和嵌套类来查找...
golang基础之Interface接口的使用
09-20
1. **类型转换**：通过接口，你可以实现不同类型的对象之间的转换，而不必关心它们的具体类型。 2. **多态**：接口允许你在不依赖具体实现的情况下编写代码，实现代码的复用和通用性。 3. **错误处理**：Go 语言中的...
golang nil接口和空接口
01-08
接口： 接口类型 是由一组方法签名定义的集合。 接口类型的变量可以保存任何实现了这些方法的值。 类型通过实现一个接口的所有方法来实现该接口。既然无需专门显式声明，也就没有“implements”关键字。 接口也是值...
Golang 使用接口实现泛型的方法示例
09-19
主要介绍了Golang 使用接口实现泛型的方法示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
golang使用sort接口实现排序示例
09-21
总的来说，Golang的`sort`包通过`sort.Interface`接口提供了一种灵活的方式来处理各种类型的排序需求。通过自定义结构体并实现这三个方法，我们可以轻松地对任何数据结构进行排序，只要这些数据结构可以转化为满足`...
Go语言自学系列 | golang标准库os模块 - File文件写操作
COCO_gsta的博客
03-21 1084
视频来源：B站《golang入门到项目实战 [2021最新Go语言教程，没有废话，纯干货！持续更新中...]》 一边学习一边整理老师的课程内容及试验笔记，并与大家分享，请移步至知乎网站，谢谢支持！ 附上汇总贴：Go语言自学系列 | 汇总 - 知乎 (zhihu.com)https://zhuanlan.zhihu.com/p/484035621 这里结束和File结构体相关的文件写操作 package main import ( "os" ) // 写字节数组 fu.
Go 小技巧之接口嵌套与实现
叮当猫的喵i
02-10 505
接口嵌套与实现 接口的嵌套就相当于，函数数量的累加 type Print3 interface { Print2 PrintSingle } 要实现 Print3 接口就相当于实现 print1，print2，print3 函数 结构体嵌套 子结构体实现了接口就相当于父结构体实现了接口 device 实现了 Print2 接口，其父结构体 device2 也实现了此接口 父结构体可以调用子结构体中的数据 device2 可使用子结构体 device 中的 str 数据
Golang interface{} 转换为某个结构体
baobaoxiannv的博客
09-15 9456
ps：开发中实际遇到的场景，在 go 语言中 interface{} 可以接收任何类型，但是我们实际使用不光需要接收，我们接收之后更是要操作这些值 简单的类型转换 var num1 int32 = 10 fmt.Printf("Type: %T, Value: %d\n", num1, num1) num2 := uint32(num1) fmt.Printf("Type: %T, Value: %d\n", num2, num2) output Type: int32, Value: 10 Type:
golang 接口嵌套实现复用
先拙的博客
09-18 3723
package mainimport ( "fmt" )func main() { start(NewB(C{})) start(NewB(D{})) }type A interface { what() }type B struct { A }type C struct { }func (b C) what() { fmt.Println("this
GOLANG使用嵌入结构实现接口
OSSRS
05-19 2725
原文：https://gocn.io/article/332考虑一个Packet接口，一般会返回一个Header，例如：type PacketHeader struct { ID uint32 Timestamp uint64 }type Packet interface { encoding.BinaryMarshaler encoding.BinaryUnmars
Go结构体里嵌套接口
qq_39871498的博客
07-02 2947
目的是当前结构体实例可以用所有实现了该接口的其他结构体来初始化（即使他们的属性不完全一致）
golang接口类型强转
10-12
在 Golang 中，接口类型强转可以使用类型断言来实现。具体来说，可以使用如下语法： ``` value, ok := interfaceVar.(Type) ``` 其中，`interfaceVar` 是接口变量，`Type` 是目标类型。如果 `interfaceVar` 的底层...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值