Golang 学习十九（接口）

最新推荐文章于 2023-06-13 17:29:11 发布
最新推荐文章于 2023-06-13 17:29:11 发布
阅读量181 收藏 1
点赞数
分类专栏： devops 云计算 golang 文章标签： golang 学习 开发语言
无
本文链接：https://blog.csdn.net/shenyuanhaojie/article/details/124286120
版权
云计算 同时被 3 个专栏收录
196 篇文章 26 订阅
订阅专栏
devops
26 篇文章 0 订阅
订阅专栏
golang
25 篇文章 4 订阅
订阅专栏

文章目录

发现输出哪里不同

package main

import "fmt"

// 父类结构体 Car
type Car struct {
    weight int
    name string
}

// 父方法
func (c Car) Run() {
    fmt.Println("Running")
}

// 子结构体 Train
type Train struct {
    // 匿名
    Car
    wheel int
}

// 子方法
func (p Train) String() string {
    str := fmt.Sprintf("name=[%s],wheel=[%d]",p.name,p.wheel)
    return str
}

func main() {
    var train Train
    train.weight = 140000
    train.name = "train"
    train.wheel = 8
    
    fmt.Println(train)
    train.Run()
    fmt.Printf("%s",train)
}

/* 结果
name=[train],wheel=[8]
Running
name=[train],wheel=[8]
*/

1. 接口定义

  • Interface 类型可以定义一组方法，不需要实现，并且不能包含任何变量，称之为接口。
  • 接口不需要显示的实现，只需要一个变量，含有接口类型中的所有方法，那么这个变量就实现了这个接口，如果一个变星含有了多个 interface 类型的方法，那么这个变量就实现了多个接口。

语法

type example interface {
    Method1(参数列表)返回值列表
    Method2(参数列表)返回值列表
    ...
}

示例：空接口使用

package main

import "fmt"

// 空接口(空指针)
type Test interface{}

func main() {
    // 声明接口
    var t Test
    var a interface{}	// 等于 var a Test
    var b int
    a = b
    fmt.Printf("a 数据类型：%T\n",a)
    fmt.Printf("Test 数据类型：%T\n",t)
}

/* 结果
a 数据类型：int
Test 数据类型：<nil>
*/

示例：结构体使用接口打印信息

package main

import "fmt"

type Student struct {
    Name string
    Age int
    Score float32
}

// 接口定义：接口是功能的抽象，不需要实现
type Test interface {
    Print()
}

// 指针类型实现接口（接口中的方法）
func (p *Student) Print() {
    fmt.Println("name:",p.Name)
    fmt.Println("age:",p.Age)
    fmt.Println("score:",p.Score)
}

/* 值类型实现接口
func (p Student) Print() {
    fmt.Println("name:",p.Name)
    fmt.Println("age:",p.Age)
    fmt.Println("score:",p.Score)
}
*/

func main() {
    // 定义接口变量
    var t Test
    // 结构体初始化
    var stu Student = Student {
        Name: "zhangsan",
        Age: 18,
        Score: 90,
    }

    // 结构体赋值接口
    // t = stu 是值类型使用
	t = &stu
    // 实现接口功能
	t.Print()
}

/* 结果
name: zhangsan
age: 18
score: 90
*/

示例：多接口方法实现

package main

import "fmt"

type Student struct {
    Name string
    Age int
    Score float32
}

// 接口定义
type Test interface {
    Print()
    Sleep()
}

// 指针类型实现接口
func (p *Student) Print() {
    fmt.Println("name:",p.Name)
    fmt.Println("age:",p.Age)
    fmt.Println("score:",p.Score)
}

// 接口中包含多个方法，如果要使用此接口，就要实现接口中包含的所有方法
func (p *Student) Sleep() {
    fmt.Println("学生在睡觉")
}

func main() {
    var t Test
    var stu Student = Student {
        Name: "zhangsan",
        Age: 18,
        Score: 90,
    }

    // 接口应用
    t = &stu
    t.Print()
    t.Sleep()
}

/*
name: zhangsan
age: 18
score: 90
学生在睡觉
*/

2. 多态

示例：为不同数据类型的实体提供统一的接口。

package main

import "fmt"

// 学生
type Student struct {
	Name string
	Age int
	Score float32
}

// 教师
type Teacher struct {
	Name string
	Age int
	Class int
}

// 接口定义
type Test interface {
	Print()
	Sleep()
}

// 学生实现接口
func (p Student) Print() {
	fmt.Println("name:",p.Name)
	fmt.Println("age:",p.Age)
	fmt.Println("score:",p.Score)
}

func (p Student) Sleep() {
	fmt.Println("学生在睡觉")
}

// 教师实现接口
func (t Teacher) Print() {
	fmt.Println("name:",t.Name)
	fmt.Println("age:",t.Age)
	fmt.Println("class:",t.Class)
}

func (t Teacher) Sleep() {
	fmt.Println("教师在休息")
}

func main() {
	var t Test
	var stu Student = Student {
		Name: "zhangsan",
		Age: 18,
		Score: 90,
	}

	var tea Teacher = Teacher {
		Name: "lisi",
		Age: 50,
		Class: 01,
	}

	// 多态表现
	t = stu
	t.Print()
	t.Sleep()
	fmt.Println("---------------------------")
	t = tea
	t.Print()
	t.Sleep()
}
 
/*
name: zhangsan
age: 18
score: 90
学生在睡觉
---------------------------
name: lisi
age: 50
class: 1
教师在休息
*/

继承关系实现多态

package main

import "fmt"

// 父结构体
type Persion struct {
    Name string
    Age int
}

// 学生子结构体
type Student struct {
	Persion
	Score float32
}

// 教师子结构体
type Teacher struct {
	Persion
	Class int
}

// 接口定义
type Test interface {
	Print()
	Sleep()
}

// 学生实现接口
func (p Student) Print() {
	fmt.Println("name:",p.Name)
	fmt.Println("age:",p.Age)
	fmt.Println("score:",p.Score)
}

func (p Student) Sleep() {
	fmt.Println("学生在睡觉")
}

// 教师实现接口
func (t Teacher) Print() {
	fmt.Println("name:",t.Name)
	fmt.Println("age:",t.Age)
	fmt.Println("class:",t.Class)
}

func (t Teacher) Sleep() {
	fmt.Println("教师在休息")
}

func main() {
	var t Test
    // 学生初始化
	var stu Student
	stu.Name = "zhangsan"
	stu.Age = 18
	stu.Score = 90

    // 教师初始化
	var tea Teacher 
	tea.Name = "lisi"
	tea.Age = 50
	tea.Class = 01

	// 多态表现
	t = stu
	t.Print()
	t.Sleep()
	fmt.Println("---------------------------")
	t = tea
	t.Print()
	t.Sleep()
}
 
/*
name: zhangsan
age: 18
score: 90
学生在睡觉
---------------------------
name: lisi
age: 50
class: 1
教师在休息
*/

综合示例：在电脑上定义一个 USB 接口，实现鼠标、U 盘存储、电扇的功能

package main

// 电脑结构体
type Computer struct {
    Brand string	// 品牌
    Price float32	// 价格
}

// USB 接口
type USB interface {
    mouse()		// 鼠标功能
    store()		// 存储
    fan()		// 风扇
}

// 接口实现
func (c Computer) mouse() {
    fmt.Println("鼠标控制")
}
func (c Computer) store() {
    fmt.Println("U 盘存储")
}
func (c Computer) fan() {
    fmt.Println("吹风扇")
}

func main() {
    // 接口变量
    var u USB
    // 笔记本初始化
    var computer Computer
    computer.Brand = "thinkpad"
    computer.Price = 5000
    // 接口调用
    u = computer
    u.mouse()
    u.store()
    u.fan()
}

/*
鼠标控制
U 盘存储
吹风扇
*/

示例：多接口的实现

package main

import "fmt"

// 接口1
type Test1 interface {
    Print()
}

// 接口2
type Test2 interface {
    Sleep()
}

type Student struct {
    Name string
    Age int
}

// 多接口实现
func (s Student) Print() {
    fmt.Println("name:",s.Name)
    fmt.Println("age:",s.Age)
}

func (s Student) Sleep() {
    fmt.Println("正在睡觉")
}

func main() {
    // 接口1变量
    var t1 Test1
    // 接口2变量
    var t2 Test2
    // 初始化结构体
    var stu Student = Student {
        Name: "zhangsan",
        Age: 18,
    }
    
    // 多接口应用
    t1 = stu
    t2 = stu
    t1.Print()
    t2.Sleep()
}

/*
name: zhangsan
age: 18
正在睡觉
*/

3. 系统接口调用

示例：使用接口进行排序

结构体切片插入

package main

import (
    "fmt"
    "math/rand"
)

// 结构体
type Student struct {
    Name string
    Age int
    Score float32
}

// 切片
type StudentArray []Student

func main() {
    // Student 切片
    var stus StudentArray
    // 生成 10 个结构体放入切片中
    for i:=0;i<10;i++ {
        var stu Student = Student {
            Name: fmt.Sprintf("stu%d",rand.Intn(100)),
            Age: rand.Intn(120),
            Score: rand.Float32()*100,
        }
        // 结构体元素存放入切片中
        stus = append(stus,stu)
    }
    
    // 遍历
    for _,v := range stus {
        fmt.Println(v)
    }
}

/* 结果
{stu81 87 66.45601}
{stu59 1 68.682304}
{stu25 20 9.696952}
{stu0 14 81.36399}
{stu62 89 31.805817}
{stu74 51 29.310184}
{stu37 26 20.318687}
{stu66 8 86.249146}
{stu47 67 75.2573}
{stu88 30 69.67192}
*/

示例：实现排序

API 官方地址：https://pkg.go.dev/sort#Interface

package main

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

// 结构体
type Student struct {
    Name string
    Age int
    Score float32
}

// 切片
type StudentArray []Student

// 实现 sort 接口
func (sa StudentArray) Len() int {
    return len(sa)
}
func (sa StudentArray) Less(i,j int) bool {
    return sa[i].Name > sa[j].Name	// < 升序
}
func (sa StudentArray) Swap(i,j int) {
    sa[i],sa[j]=sa[j],sa[i]
} 

func main() {
    // Student 切片
    var stus StudentArray
    // 生成 10 个结构体放入切片中
    for i:=0;i<10;i++ {
        var stu Student = Student {
            Name: fmt.Sprintf("stu%d",rand.Intn(100)),
            Age: rand.Intn(120),
            Score: rand.Float32()*100,
        }
        // 结构体元素存放入切片中
        stus = append(stus,stu)
    }
    
    // 遍历
    for _,v := range stus {
        fmt.Println(v)
    }
    fmt.Println("--------------------")
    
    // 排序
    sort.Sort(stus)
    
    // 遍历
    for _,v := range stus {
        fmt.Println(v)
    }
}

/*
{stu81 87 66.45601}
{stu59 1 68.682304}
{stu25 20 9.696952}
{stu0 14 81.36399}
{stu62 89 31.805817}
{stu74 51 29.310184}
{stu37 26 20.318687}
{stu66 8 86.249146}
{stu47 67 75.2573}
{stu88 30 69.67192}
--------------------
{stu88 30 69.67192}
{stu81 87 66.45601}
{stu74 51 29.310184}
{stu66 8 86.249146}
{stu62 89 31.805817}
{stu59 1 68.682304}
{stu47 67 75.2573}
{stu37 26 20.318687}
{stu25 20 9.696952}
{stu0 14 81.36399}
*/

4. 接口嵌套

示例:文件读写测试

package main

import "fmt"

type Reader interface {
    Read()
}

type Writer interface {
    Writer()
}

// 接口嵌套
type ReadWriter interface {
    Reader
    Writer
}

// 文件结构体
type File struct {}

// 实现 Reader 接口
func (f *File) Read() {
    fmt.Println("文件读取")
}

// 实现 Writer 接口
func (f *File) Writer() {
    fmt.Println("文件写入")
}

// 读写操作函数
func Test(rw ReadWriter) {
    rw.Read()
    rw.Writer()
}

func main() {
    // 初始化文件
    var f File
    Test(&f)
}

/* 结果
文件读取
文件写入
*/

5. 类型断言

作用：因为接口是一般类型，需要明确具体类型的时候就需要使用类型断言。

package main

import "fmt"

func main() {
    var a interface{}
    var b int
    a = b
    // 断言赋值
    c := a.(int)
    fmt.Printf("类型:%T\n",c)
}

/*
类型:int
*/

示例：断言判断

package main

import "fmt"

func Test(t interface{}) {
    // 转换类型判断
    v,err := t.(int)
    if err == false {
        fmt.Println("convert type err")
        return
    }
    v++
    fmt.Println(v)
}

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

/*
1
*/

示例：多类型判断

package main

import (
	"fmt"
)

// 传递多个类型数据
// 长度不固定，类型不固定的数据传递给 items
// ... 表示长度不固定，interface{} 空接口表示任意数据类型
func classifier(items ...interface{}) {
	// i 是下标，x 是值（k/v）
	for i, x := range items {
		// 变量.(type) 只能作用在 Switch 语句中，专门用于类型判断
		switch x.(type) {
		case bool:
			fmt.Printf("%d is a bool\n", i)
		case int, int32, int64:
			fmt.Printf("%d is a int\n", i)
		case float32, float64:
			fmt.Printf("%d is a float\n", i)
		case string:
			fmt.Printf("%d is a string\n", i)
		default:
			fmt.Printf("unkown")
		}
	}
}

func main() {
	classifier("zhangsan", 18, 90.5, false, nil)
}

/*
0 is a string
1 is a int
2 is a float
3 is a bool
unkown
*/

6. 链表使用

示例

package main

import "fmt"

// 节点结构体
type LinkNode struct {
    data interface{}
    next *LinkNode
}

// 链表结构体
type Link struct {
    head *LinkNode
    tail *LinkNode
}

// 从头部插入
func (p *Link) InsertHead(data interface{}) {
    node := &LinkNode {
        data: data,
        next: nil,
    }
    // 判断是否为空链表
    if p.head == nil && p.tail == nil {
        p.head = node
        p.tail = node
        return
    }
    // 当前节点的 next 是原头部节点
    node.next = p.head
    // 更新头部
    p.head = node
}

// 从尾部插入
func (p *Link) InsertTail(data interface{}) {
    node := &LinkNode {
        data: data,
        next: nil,
    }
    // 判断是否为空链表
    if p.head == nil && p.tail == nil {
        p.head = node
        p.tail = node
        return
    }
    // 原尾部节点的 next 是当前节点
    p.tail.next = node
    // 更新尾部
    p.tail = node
}

// 遍历方法
func (p *Link) Req() {
    lp := p.head
    for lp != nil {
        fmt.Println(lp)
        lp = lp.next
    }
}

func main() {
    // 定义链表
    var intLink Link
    for i := 0; i < 10; i++ {
        // intLink.InsertHead(i)
        intLink.InsertTail(i)
    }
    intLink.Req()
}

/*
&{0 0xc000004090}
&{1 0xc0000040a8}
&{2 0xc0000040c0}
&{3 0xc0000040d8}
&{4 0xc0000040f0}
&{5 0xc000004108}
&{6 0xc000004120}
&{7 0xc000004138}
&{8 0xc000004150}
&{9 <nil>}
*/

注意：切片不可以赋值给空接口，只能单独每个元素赋值

var a []int
var b []interface
b = a	// 出现报错
公博义
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
实例学习Golang–接口（一、接口的实现）
01-08
在Go语言中接口（interface）是一种类型，一种抽象的类型。 每个接口类型由数个方法组成。接口的形式代码如下： type 接口类型名 interface{ 方法名1( 参数列表1 ) 返回值列表1 方法名2( 参数列表2 ) 返回值列表2...
实例学习Golang–接口（三、error处理）
01-20
Golang通过内置的`error`接口提供了灵活且强大的错误处理机制。本篇文章将深入探讨`error`接口及其在实际编程中的应用。 `error`接口非常简单，它只有一个方法`Error() string`，用于返回一个字符串，该字符串通常...
Go语言-接口
Zlwriii的博客
04-15 199
目录 前言 1、接口的定义 2、多态 3、系统接口调用 4、接口嵌套 5、类型断言 6、链表使用 前言 接口不需要显示的实现，只需要一个变量，含有接口类型的所有方法，那么这个变量就实现了这个接口，如果一个变量含有多个interface类型的方法，那么这个变量就实现了多个接口。 1、接口的定义 概念：Interface类型可以定义一组的方法，不需要实现，并且不能包含任何变量，称之为接口。 语法格式： type example interface { Method1(参数
【go语言系列学习】01.接口-实例：对结构体切片按照自定义要求排序
weixin_42072280的博客
10-05 733
对结构体切片按照自定义要求排序
00013.01接口的概念以及声明和实现
小良的博客
09-12 336
一、声明是接口？ 1、 接口的思想，一开始不是那么容易理解，但是语法很简单 原因是什么？因为编程思想没有到一定的高度，而接口是用在比较复杂的项目当中的，初学者也没有接触到稍微大一点的项目，我们做练习题的时候用接口反而会更复杂了，这样就导致天生的抗拒，我为什么要让我的代码变得“复杂”呢？哈哈，这样就导致了一种尴尬排斥的局面。 办法：你先不要去纠结为什么要使用接口，反正你要知道它很有用就行了，你看假如你去对接阿里支付宝 接口，这些，他不可能给你源代码，只能给你提供接口 1、什么是接口： 举例如我们的电脑接口为什
GO编程模式系列（一）：切片，接口，时间和性能
Go中国
12-27 356
在本篇文章中，我会对Go语言编程模式的一些基本技术和要点，这样可以让你更容易掌握Go语言编程。其中，主要包括，数组切片的一些小坑，还有接口编程，以及时间和程序运行性能相关的话题。本文是全...
golang 切片 接口_Go学习每日一问(12)-cap和空接口
weixin_39748928的博客
12-17 283
每次学习并整理一个Golang的知识点，每天进步一点点。今天学习下cap和空接口的知识点。代码片段1.关于 cap() 函数的适用类型，下面说法正确的是()A. arrayB. sliceC. mapD. channel2.下面这段代码的输出结果？func main() { var i interface{} if i == nil { fmt.Println("ni...
Golang 使用接口实现泛型的方法示例
09-19
主要介绍了Golang 使用接口实现泛型的方法示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
golang基础学习资料
12-13
九、包和导入 Go 语言的组织方式是基于包的，每个源文件都属于一个包。使用 `import` 语句可以引入其他包的功能，例如 `fmt` 包提供了格式化输入输出的函数。 十、函数 Go 语言的函数可以有多个返回值，并且支持可...
golang的学习笔记
04-21
《Golang学习笔记》第四版，是一份深入探讨Go语言的宝贵资料，旨在帮助开发者全面理解和掌握这门现代、高效且简洁的后端开发语言。Go语言，又称Golang，由Google公司于2009年推出，由Robert Griesemer、Rob Pike及...
go语言接口（详解）
热门推荐
一个非常Cool的人
01-12 1万+
详细的介绍了Go语言接口类型,包括实现应用还有类型断言实现方法。相信阅读之后受益匪浅。
go语言—接口
最新发布
fanfjaiyun的博客
06-13 1076
接口就是一系列方法的集合，但是还没有实现，需要对象自己去实现type 接口类型名 interface {
[Go语言入门] 13 Go语言接口(interface)详解
时空旅客的专栏
07-11 7468
Go语言入门, Go语言接口
Go语言之接口（接口实现条件，使用，原理，类型断言）
Sheena997的博客
03-17 4387
Go语言之接口（接口实现条件，使用，原理，类型断言）
go中实现接口的几种方式
domorejojo
08-21 1万+
go中实现接口的几种方式 //定义1个接口student，它包含1个 StudentName 方法 type student interface { StudentName() string } //定义1个结构体 type Boy struct { Name string } //给他这个结构体绑定一个方法 StudentName。这样就表示它实现了 student接口 func (a Boy) StudentName() string { return a.Name } 上面是常见的接口申
go语言基础之接口
weixin_44706011的博客
06-04 243
接口（interface）定义了一个对象的行为规范，只定义规范不实现，由具体的对象来实现规范的细节。（接口是一种类型） 接口 接口类型 在Go语言中接口（interface）是一种类型，一种抽象的类型。 interface是一组method的集合，是duck-type programming的一种体现。接口做的事情就像是定义一个协议（规则），只要一台机器有洗衣服和甩干的功能，我就称它为洗衣机。不关心属性（数据），只关心行为（方法）。 为了保护你的Go语言职业生涯，请牢记接口（interface）是一种类型。
Go基础篇：接口
林钟一的博客
05-17 855
前段时间忙着春招面试，现在也算告一段落，找到一家比较心仪的公司实习，开始慢慢回归状态，这后面几章我会学习go1.19版本的语言特性或者机制：类型系统、接口、断言以及反射的内容，也算是补上之前没有深入底层的内容。Go语言中的接口（interface）是一种类型，它定义了一组方法的集合，但没有具体的实现。接口可以被任何类型实现，只要该类型实现了接口中定义的所有方法。这种设计方式使得Go语言具有很高的灵活性和可扩展性。
GO 接口详解
baidu_41917849的博客
02-25 2515
在go语言中，接口是一种就是一种类型。同map、struct等的定义，语法是一样。 如： type People interface { Speak(string) string } 关键字是interface。此时就称People是一个接口。 接口的作用就是定义一些对象的共同特征，特征以接口内的方法来定义。如上例的speak方法。 具有上述特征的类型，那就称它实现了这个接口。语法如下： // 定义类型Student，它是一种struct类型 type Student struct{}
Go语言基础之接口
大河之犬的博客
03-09 576
一个类型可以同时实现多个接口，而接口间彼此独立，不知道对方的实现。接口就是规定了一个需要实现的方法列表，在 Go 语言中一个类型只要实现了接口中规定的所有方法，那么我们就称它实现了这个接口。因为Singer接口只包含一个Sing方法，所以只需要给Bird结构体添加一个Sing方法就可以满足Singer接口的要求。这样我们在代码中就可以把狗和汽车当成一个会动的类型来处理，不必关注它们具体是什么，只需要调用它们的Move方法就可以了。接口值可能赋值为任意类型的值，那我们如何从接口值获取其存储的具体数据呢？
golang 学习路线
06-10
好的，关于 golang 的学习路线，我可以提供以下建议： 1. 先了解 golang 的基本...7. 学习 golang 的高级编程，包括 golang 的反射、接口、垃圾回收机制等等。 以上是我推荐的 golang 学习路线，希望对你有所帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值