GO-接口

news2024/9/21 18:43:50

1. 接口

在Go语言中接口（interface）是一种类型，一种抽象的类型。

interface是一组method的集合，接口做的事情就像是定义一个协议（规则），只要一台机器有洗衣服和甩干的功能，我就称它为洗衣机。不关心属性（数据），只关心行为（方法）。

接口（interface）是一种类型

接口类型是对其它类型行为的抽象和概括；因为接口类型不会和特定的实现细节绑定在一起，通过这种抽象的方式我们可以让我们的函数更加灵活和更具有适应能力。

接口是双方约定的一种合作协议。接口实现者不需要关心接口会被怎样使用，调用者也不需要关心接口的实现细节。接口是一种类型，也是一种抽象结构，不会暴露所含数据的格式、类型及结构。

1.2 接口定义

Go语言提倡面向接口编程。

每个接口类型由数个方法组成。接口的形式代码如下：

type 接口类型名 interface{
    方法名1( 参数列表1 ) 返回值列表1
    方法名2( 参数列表2 ) 返回值列表2
    …
}

对各个部分的说明：

  • 接口类型名：使用 type 将接口定义为自定义的类型名。Go语言的接口在命名时，一般会在单词后面添加 er，如有写操作的接口叫 Writer，有字符串功能的接口叫 Stringer，有关闭功能的接口叫 Closer 等。
  • 方法名：当方法名首字母是大写时，且这个接口类型名首字母也是大写时，这个方法可以被接口所在的包（package）之外的代码访问。
  • 参数列表、返回值列表：参数列表和返回值列表中的参数变量名可以被忽略
type Writer interface {
	//接口名和方法首字母大写，意味着可以被其他包访问
	Write([]byte)string
}

1.3 接口实现条件

如果一个任意类型 T 的方法集为一个接口类型的方法集的超集，则我们说类型 T 实现了此接口类型。

T 可以是一个非接口类型，也可以是一个接口类型。

实现关系在Go语言中是隐式的。两个类型之间的实现关系不需要在代码中显式地表示出来。Go语言中没有类似于 implements 的关键字。 Go编译器将自动在需要的时候检查两个类型之间的实现关系。

接口定义后，需要实现接口，调用方才能正确编译通过并使用接口。

接口的实现需要遵循两条规则才能让接口可用：

  1. 接口的方法与实现接口的类型方法格式一致在类型中添加与接口签名一致的方法就可以实现该方法。签名包括方法中的名称、参数列表、返回参数列表。也就是说，只要实现接口类型中的方法的名称、参数列表、返回参数列表中的任意一项与接口要实现的方法不一致，那么接口的这个方法就不会被实现。
// 定义一个数据写入器
type DataWriter interface {
	Write(interface{}) error
}

// 定义文件结构，用于实现DataWriter
type file struct {
}

// 实现DataWriter接口的WriteData方法
func (f *file) Write(b interface{}) error {
	return fmt.Sprintf("writer:", b)
}

func main() {
	// 实例化file
	f := new(file)
	// 声明一个DataWriter的接口
	var write DataWriter
	// 将接口赋值f，也就是*file类型
	write = f
	// 使用DataWriter接口进行数据写入
	write.Write("hhhhhhhh")
}
  1. 当类型无法实现接口时，编译器会报错：
    1. 函数名不一致导致的报错
    2. 实现接口的方法签名不一致导致的报错
  1. 接口中所有方法均被实现当一个接口中有多个方法时，只有这些方法都被实现了，接口才能被正确编译并使用。

// 定义一个数据写入器
type DataWriter interface {
	Write(interface{}) error
    //上述代码中新增一个方法
	Content() bool
}

运行结果

.\main.go:28:10: cannot use f (variable of type *file) as DataWriter value in assignment: *file does not implement DataWriter (missing method Content)

Go语言的接口实现是隐式的，无须让实现接口的类型写出实现了哪些接口。

这个设计被称为非侵入式设计。

1.4 类型与接口的关系

在Go语言中类型和接口之间有一对多和多对一的关系

一个类型可以实现多个接口

一个类型可以同时实现多个接口，而接口间彼此独立，不知道对方的实现。

例如，狗可以叫，也可以动。

我们就分别定义Sayer接口和Mover接口，如下：

type Sayer interface {
	Say()
}

type Mover interface {
	Move()
}

type Dog struct {
	name string
}

// dog实现say和move接口
func (d Dog) Say() {
	fmt.Println(d.name, " saying......")
}

func (d Dog) Move() {
	fmt.Println(d.name, "moving ......")
}

func main() {
	var x Sayer
	var y Mover

	var dog = Dog{"wangwang"}

	x = dog
	y = dog
	x.Say()  //wangwang  saying......
	y.Move() //wangwang moving ......

}

多个类型实现同一接口

type Mover interface {
	Move()
}

type Dog struct {
	name string
}

type Car struct {
	name string
}

//dog 和 car都实现mover接口

func (d Dog) Move() {
	fmt.Println(d.name, "moving,....")
}

func (c Car) Move() {
	fmt.Println(c.name, "moving .....")
}

func main() {
	var d = Dog{"旺财"}
	var c = Car{"小米"}

	var move Mover
	move = d
	move.Move() //旺财 moving,....
	move = c
	move.Move() //小米 moving .....

}

接口嵌套

接口与接口间可以通过嵌套创造出新的接口

// Sayer 接口
type Sayer interface {
    say()
}

// Mover 接口
type Mover interface {
    move()
}

// 接口嵌套
type animal interface {
    Sayer
    Mover
}

嵌套得到的接口的使用与普通接口一样，这里我们让cat实现animal接口：

type cat struct {
    name string
}

func (c cat) say() {
    fmt.Println("喵喵喵")
}

func (c cat) move() {
    fmt.Println("猫会动")
}

func main() {
    var x animal
    x = cat{name: "花花"}
    x.move()
    x.say()
}

1.5 空接口

空接口是指没有定义任何方法的接口。

因此任何类型都实现了空接口。

空接口类型的变量可以存储任意类型的变量。

func main() {
	var x interface{}
	var i = 100
	x = i
	fmt.Println(x) //100

	var name = "hhhhh"
	x = name
	fmt.Println(x)  //hhhhh
}

1.5.1 空接口的应用

空接口作为函数的参数

使用空接口实现可以接收任意类型的函数参数。

func show(a interface{}) {
	fmt.Println(a)
}

func main() {
	//空接口作为函数参数
	show("空接口传参")  //空接口传参

}

空接口作为map的值

使用空接口实现可以保存任意值的字典。

func main() {
	var student = make(map[string]interface{}, 3)
	student["小明"] = 100
	student["小红"] = "hahah"
	student["小高"] = false
	fmt.Printf("%+v", student)  //map[小明:100 小红:hahah 小高:false]

}

1.5.2 类型断言

空接口可以存储任意类型的值，那我们如何获取其存储的具体数据呢？

接口值

一个接口的值（简称接口值）是由一个具体类型和具体类型的值两部分组成的。

这两部分分别称为接口的动态类型和动态值。

想要判断空接口中的值这个时候就可以使用类型断言，其语法格式：

x.(T)

1

其中：

  1. x：表示类型为interface{}的变量
  2. T：表示断言x可能是的类型。

该语法返回两个参数，第一个参数是x转化为T类型后的变量，第二个值是一个布尔值，若为true则表示断言成功，为false则表示断言失败。

func main() {
	var student = make(map[string]interface{}, 3)
	student["小明"] = 100
	student["小红"] = "hahah"
	student["小高"] = false
	fmt.Printf("%+v\n", student) //map[小明:100 小红:hahah 小高:false]

	_, ok := student["小明"].(bool)
	if ok != true {
		fmt.Println("student[\"小明\"]不是bool")  
	}
}

2. I/O操作

I/O操作也叫输入输出操作。其中I是指Input，O是指Output，用于读或者写数据的，有些语言中也叫流操作，是指数据通信的通道。

Golang 标准库对 IO 的抽象非常精巧，各个组件可以随意组合，可以作为接口设计的典范。

io包中提供I/O原始操作的一系列接口。

它主要包装了一些已有的实现，如 os 包中的那些，并将这些抽象成为实用性的功能和一些其他相关的接口。

由于这些接口和原始的操作以不同的实现包装了低级操作，客户不应假定它们对于并行执行是安全的。

io库比较常用的接口有三个，分别是Reader，Writer和Closer。

2.1 Reader

Reader接口的定义，Read()方法用于读取数据。

type Reader interface {
        Read(p []byte) (n int, err error)
}

io.Reader 表示一个读取器，它将数据从某个资源读取到传输缓冲区。在缓冲区中，数据可以被流式传输和使用。

  • 对于要用作读取器的类型，它必须实现 io.Reader 接口的唯一一个方法 Read(p []byte)。
  • 换句话说，只要实现了 Read(p []byte) ，那它就是一个读取器。
  • Read() 方法有两个返回值，一个是读取到的字节数，一个是发生错误时的错误。

通过 string.NewReader(string) 创建一个字符串读取器，然后流式地按字节读取：


func main() {
	reader := strings.NewReader("this is a reader")
	// 每次读取4个字节
	p := make([]byte, 4)

	for {
		n, err := reader.Read(p)
		if err != nil {
			if err == io.EOF {
				log.Println("读完了")
				break
			}
			log.Fatalln("read error", err)
			os.Exit(2)
		}
		log.Println("读取到的字节数：", n)
	}

}
  • 最后一次返回的 n 值有可能小于缓冲区大小。
  • io.EOF 来表示输入流已经读取到头

2.1.1 文件操作相关API
func Create(name string) (file *File, err Error)

1

    • 根据提供的文件名创建新的文件，返回一个文件对象，默认权限是0666
func NewFile(fd uintptr, name string) *File

1

    • 根据文件描述符创建相应的文件，返回一个文件对象
func Open(name string) (file *File, err Error)

1

    • 只读方式打开一个名称为name的文件
func OpenFile(name string, flag int, perm uint32) (file *File, err Error)

1

    • 打开名称为name的文件，flag是打开的方式，只读、读写等，perm是权限
func (file *File) Write(b []byte) (n int, err Error)

1

    • 写入byte类型的信息到文件
func (file *File) WriteAt(b []byte, off int64) (n int, err Error)

1

    • 在指定位置开始写入byte类型的信息
func (file *File) WriteString(s string) (ret int, err Error)

1

    • 写入string信息到文件
func (file *File) Read(b []byte) (n int, err Error)

1

    • 读取数据到b中
func (file *File) ReadAt(b []byte, off int64) (n int, err Error)

1

    • 从off开始读取数据到b中
func Remove(name string) Error

1

    • 删除文件名为name的文件
2.1.2 读文件

type Closer interface {
    Close() error
}

os.Open()函数能够打开一个文件，返回一个*File和一个err。对得到的文件实例调用Close()方法能够关闭文件。

文件读取可以用file.Read()，读到文件末尾会返回io.EOF的错误

func main() {
	// 打开文件
	file, err := os.Open("C:\\Users\\Administrator\\Desktop\\新建 文本文档 (2).txt")
	if err != nil {
		log.Println("打开失败")
	}
	defer file.Close()
	// 定义接收文件读取的字节数组
	buff := make([]byte, 128)
	var content []byte
	for {
		_, err := file.Read(buff)
		if err == io.EOF {
			log.Println("读完了")
			break
		}

		if err != nil {
			log.Println("读取失败:", err)
			return
		}
	}
	content = append(content, buff...)
	fmt.Sprintln(content)
}

Writer

type Writer interface {
    //Write() 方法有两个返回值，一个是写入到目标资源的字节数，一个是发生错误时的错误。
    Write(p []byte) (n int, err error)
}

  • io.Writer 表示一个写入器，它从缓冲区读取数据，并将数据写入目标资源。
  • 对于要用作编写器的类型，必须实现 io.Writer 接口的唯一一个方法 Write(p []byte)
  • 同样，只要实现了 Write(p []byte) ，那它就是一个编写器。
func main() {
	// 打开文件
	file, err := os.Open("C:\\Users\\Administrator\\Desktop\\新建 文本文档 (2).txt")
	if err != nil {
		log.Println("打开失败")
	}
	defer file.Close()
	// 定义接收文件读取的字节数组
	buff := make([]byte, 128)
	var content []byte
	for {
		_, err := file.Read(buff[:])
		if err == io.EOF {
			log.Println("读完了")
			break
		}

		if err != nil {
			log.Println("读取失败:", err)
			return
		}
	}
	content = append(content, buff...)
	fmt.Println(string(content))
}

2.2 Writer

type Writer interface {
    //Write() 方法有两个返回值，一个是写入到目标资源的字节数，一个是发生错误时的错误。
    Write(p []byte) (n int, err error)
}
  • io.Writer 表示一个写入器，它从缓冲区读取数据，并将数据写入目标资源。
  • 对于要用作编写器的类型，必须实现 io.Writer 接口的唯一一个方法 Write(p []byte)
  • 同样，只要实现了 Write(p []byte) ，那它就是一个编写器。

写文件：

func main() {
	file, err := os.Create("test.txt")
	if err != nil {
		log.Println("create error")
	}
	defer file.Close()
	b := make([]byte, 0)
	for i := 0; i < 10; i++ {
		b = append(b, byte(i))
	}
	file.WriteString(string(b))
}

2.3 bufio

  • bufio包实现了带缓冲区的读写，是对文件读写的封装
  • bufio缓冲写数据

模式

含义

os.O_WRONLY

只写

os.O_CREATE

创建文件

os.O_RDONLY

只读

os.O_RDWR

读写

os.O_TRUNC

清空

os.O_APPEND

追加

bufio读写数据

func wr() {
	// 参数2：打开模式，所有模式d都在上面
	// 参数3是权限控制
	// w写 r读 x执行   w  2   r  4   x  1
	//特殊权限位，拥有者位，同组用户位，其余用户位
	file, err := os.OpenFile("./xxx.txt", os.O_CREATE|os.O_WRONLY, 0666)
	if err != nil {
		return
	}
	defer file.Close()
	// 获取writer对象
	writer := bufio.NewWriter(file)
	for i := 0; i < 10; i++ {
		writer.WriteString("hello\n")
	}
	// 刷新缓冲区，强制写出
	writer.Flush()
}

func re() {
	file, err := os.Open("./xxx.txt")
	if err != nil {
		return
	}
	defer file.Close()
	reader := bufio.NewReader(file)
	for {
		line, _, err := reader.ReadLine()
		if err == io.EOF {
			break
		}
		if err != nil {
			return
		}
		fmt.Println(string(line))
	}

}

func main() {
	re()
}


2.5 实现一个cat命令

使用文件操作相关知识，模拟实现linux平台cat命令的功能。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1484507.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

13. Springboot集成Protobuf

13. Springboot集成Protobuf

目录 1、前言 2、Protobuf简介 2.1、核心思想 2.2、Protobuf是如何工作的&#xff1f; 2.3、如何使用 Protoc 生成代码&#xff1f; 3、Springboot集成 3.1、引入依赖 3.2、定义Proto文件 3.3、Protobuf生成Java代码 3.4、配置Protobuf的序列化和反序列化 3.5、定义…
阅读更多...
事件循环相关知识

事件循环相关知识

事件循环 浏览器的进程模型 何为进程 程序运行需要有专属的内存空间&#xff0c;可以吧这块内存空间简单的理解为进程 每个应用至少有一个进程&#xff0c;进程之间相互独立&#xff0c;即使要通信也需要双方同意 何为线程 有了进程就可以运行代码 运行代码的人称为线程 一…
阅读更多...
RISC-V特权架构 - 特权模式与指令

RISC-V特权架构 - 特权模式与指令

RV32/64 特权架构 - 特权模式与指令 1 特权模式2 特权指令2.1 mret&#xff08;从机器模式返回到先前的模式&#xff09;2.2 sret&#xff08;从监管模式返回到先前的模式&#xff09;2.3 wfi&#xff08;等待中断&#xff09;2.4 sfence.vma&#xff08;内存屏障&#xff09; …
阅读更多...
beets，一个有趣的 Python 音乐信息管理工具！

beets，一个有趣的 Python 音乐信息管理工具！

前些天发现了一个巨牛的人工智能学习网站&#xff0c;通俗易懂&#xff0c;风趣幽默&#xff0c;忍不住分享一下给大家。点击跳转到网站AI学习网站。 目录 前言 什么是Beet库&#xff1f; 安装Beet库 使用Beet库 Beet库的功能特性 1. 多种音乐格式支持 2. 自动标签识…
阅读更多...
Golang embed 库全面解析：从基础到高级应用

Golang embed 库全面解析：从基础到高级应用

Golang embed 库全面解析&#xff1a;从基础到高级应用 引言Golang的 embed&#xff1a;简化资源管理提升可移植性与便利性适用场景的拓展 embed 库的基本概念embed 库的工作原理使用 embed 的基本语法访问嵌入资源的方法embed 的限制 如何使用 embed嵌入单个文件嵌入整个目录结…
阅读更多...
JMeter实现接口自动化测试

JMeter实现接口自动化测试

一、JMETER的环境搭建 参考&#xff1a;https://www.cnblogs.com/qmfsun/p/4902534.html 二、JMETER的汉化 临时汉化方法&#xff1a;打开jmeter&#xff0c;options-->choose language-->选择语言 可以根据自己的需要选择简体中文或者繁体中文&#xff0c;如图&#xf…
阅读更多...
力扣180 连续出现的数字

力扣180 连续出现的数字

如何有效地识别在数据库中至少连续出现三次的数字&#xff1f; 目录 题目描述 解题思路 完整代码 进一步探索 题目描述 表&#xff1a;Logs ---------------------- | Column Name | Type | ---------------------- | id | int | | num | varch…
阅读更多...
13 双口 RAM IP 核

13 双口 RAM IP 核

双口 RAM IP 核简介 双口 RAM IP 核有两个端口&#xff0c;它又分为伪双端口 RAM 和真双端口 RAM&#xff0c;伪双端口 RAM 一个端口只能读&#xff0c;另一个端口只能 写&#xff0c;真双端口 RAM 两个端口都可以进行读写操作。同时对存储器进行读写操作时就会用到双端口 RAM…
阅读更多...
1、swagger knife4j 3.0.3 集成 springboot

1、swagger knife4j 3.0.3 集成 springboot

这里写目录标题 一、项目版本二、增加 knife4j maven 依赖三、增加项目配置类四、配置文件增加登录密码五 、访问文档地址 一、项目版本 springboot &#xff1a;2.6.7 swagger&#xff1a;knife4j-spring-boot-starter &#xff1a;3.3.0 二、增加 knife4j maven 依赖 <…
阅读更多...
Linux系统源代码数据防泄密加密软件

Linux系统源代码数据防泄密加密软件

数据防泄密系统 是一套从源头上保障数据安全和使用安全的软件系统。包含了文件透明加解密、内部文件流转功能、密级管控、离线管理、文件外发管理、灵活的审批流程、工作模式切换、服务器白名单等功能。从根本上严防信息外泄&#xff0c;保障信息安全。 www.weaem.com 功能介绍…
阅读更多...
【k8s管理--集群日志管理elk】

【k8s管理--集群日志管理elk】

1、ELKF日志部署框架 使用docker部署的k8s集群所有的容器日志统一都在目录&#xff1a;/var/log/containers/1、filebeat是一个轻量级的日志手机工具&#xff0c;主要功能是收集日志2、logstash通可以收集日志&#xff0c;也可以进行数据清洗&#xff0c;但是一般不用logstash来…
阅读更多...
C++ Algorithm Tutorial (1)

C++ Algorithm Tutorial (1)

中文版 c算法入门教程(1)_c怎么学习算法-CSDN博客 Cis a powerful and widely used programming language, and for those who want to delve deeper into programming and algorithms, mastering Cis an important milestone. This article will take you step by step to und…
阅读更多...
殿堂级Flink源码极精课程预售

殿堂级Flink源码极精课程预售

一、为什么我们要读源码? 1、让个人技术快速成长: 优秀的开源框架,底层的源码设计思想也非常优秀,同时还有含有大量的设计模式和并发编程技术&#xff0c;优秀的解决方案,熟读源码对猿们技术提升有很大帮助 2、新技术学习能力: Java开源码框架的源码熟读后&#xff0c;若出现…
阅读更多...
微服务day03-Nacos配置管理与Nacos集群搭建

微服务day03-Nacos配置管理与Nacos集群搭建

一.Nacos配置管理 Nacos不仅可以作为注册中心&#xff0c;可以进行配置管理 1.1 统一配置管理 统一配置管理可以实现配置的热更新&#xff08;即不用重启当服务发生变更时也可以直接更新&#xff09; dataId格式&#xff1a;服务名-环境名.yaml&#xff0c;分组一般使用默认…
阅读更多...
基于YOLOv8/YOLOv7/YOLOv6/YOLOv5的番茄成熟度检测系统（Python+PySide6界面+训练代码）

基于YOLOv8/YOLOv7/YOLOv6/YOLOv5的番茄成熟度检测系统（Python+PySide6界面+训练代码）

摘要&#xff1a;开发番茄成熟度检测系统对于提高农业产量和食品加工效率具有重大意义。本篇博客详细介绍了如何利用深度学习构建一个番茄成熟度检测系统&#xff0c;并提供了完整的实现代码。该系统基于强大的YOLOv8算法&#xff0c;并结合了YOLOv7、YOLOv6、YOLOv5的对比&…
阅读更多...
【机器学习】CIFAR-10数据集简介、下载方法(自动)

【机器学习】CIFAR-10数据集简介、下载方法(自动)

【机器学习】CIFAR-10数据集简介、下载方法(自动) &#x1f308; 个人主页&#xff1a;高斯小哥 &#x1f525; 高质量专栏&#xff1a;Matplotlib之旅&#xff1a;零基础精通数据可视化、Python基础【高质量合集】、PyTorch零基础入门教程&#x1f448; 希望得到您的订阅和支…
阅读更多...
Linux第67步_linux字符设备驱动_注册和注销

Linux第67步_linux字符设备驱动_注册和注销

1、字符设备注册与注销的函数原型” /*字符设备注册的函数原型*/ static inline int register_chrdev(unsigned int major,\ const char *name, \ const struct file_operations *fops) /* major:主设备号&#xff0c;Limnux下每个设备都有一个设备号&#xff0c;设备号分…
阅读更多...
Ainx的全局配置

Ainx的全局配置

&#x1f4d5;作者简介&#xff1a; 过去日记&#xff0c;致力于Java、GoLang,Rust等多种编程语言&#xff0c;热爱技术&#xff0c;喜欢游戏的博主。 &#x1f4d7;本文收录于Ainx系列&#xff0c;大家有兴趣的可以看一看 &#x1f4d8;相关专栏Rust初阶教程、go语言基础系列…
阅读更多...
[SS]语义分割_膨胀卷积

[SS]语义分割_膨胀卷积

膨胀卷积 目录 一、概念 1、定义 2、知识点 二、详细介绍 1、引入 2、膨胀系数设定 一、概念 1、定义 膨胀卷积&#xff08;Dilated Convolution&#xff09;&#xff0c;也称为空洞卷积&#xff08;Atrous Convolution&#xff09;&#xff0c;是一种在卷积神经网络…
阅读更多...
Vue3 条件渲染 v-show

Vue3 条件渲染 v-show

v-show 指令&#xff1a;用于控制元素的显示或隐藏。 执行条件&#xff1a;当条件为 false 时&#xff0c;会添加一个 display:none 属性将元素隐藏。 应用场景&#xff1a;适用于显示隐藏切换频率较高的场景。 <div v-show"数据">内容</div> 基础用法…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023