Go语言的接口详解

目录
  • 1、接口的用途
  • 2、类型断言
  • 3、类型选择
  • 4、空接口
  • 5、匿名空接口
  • 6、实现多个接口
  • 7、接口嵌套
  • 8、接口零值
  • 9、make和new的区别
  • 总结

接口就是一系列方法的集合(规范行为)

在面向对象的领域里,接口一般这样定义:接口定义一个对象的行为,规范子类对象的行为。

在 Go 语言中的接口是非侵入式接口(接口没了,不影响代码),侵入式接口(接口没了,子类报错)

Go 也是鸭子类型,比如我现在有个鸭子类,内有 speak 方法和 run 方法,子类只要实现了 speak 和 run,我就认为子类是鸭子,我只要子类中有这两个方法你就是鸭子,有这两个方法你就是鸭子,他是从下往上推导只要有你这里面的东西,那就是算是继承了你这个接口

1、接口的用途

接口是一个类型

// Duck 定义一个鸭子接口
type Duck interface {
   speak()
   run()
}

// WhiteDuck 定义一个白鸭子结构体
type WhiteDuck struct {
   name  string
   age int
   sex string
}

// BlackDuck 定义一个黑鸭子结构体
type BlackDuck struct {
   name  string
   age int
   sex string
}

// 让白鸭子和黑鸭子绑定接口中的所有方法,就叫实现该接口
// 让白鸭子实现 Duck 接口
func (w WhiteDuck) speak() {
   fmt.Println("白鸭子嘎嘎叫,它的名字叫", w.name)
}

func (w WhiteDuck) run() {
   fmt.Println("白鸭子慢悠悠的走,它的名字叫", w.name)
}

// 让黑鸭子实现 Duck 接口
func (b BlackDuck) speak() {
   fmt.Println("黑鸭子呱呱叫,它的名字叫", b.name)
}

func (b BlackDuck) run() {
   fmt.Println("黑鸭子歪歪扭扭的走,它的名字叫", b.name)
}

func main() {
   var duck Duck
   duck = WhiteDuck{"小白", 15, "男"}	// 把我的对象赋值给一个接口类型,就可以实现多态的效果
   fmt.Println(duck)

   // duck 现在他是一个接口,它只能取方法,不能取出属性了。
   duck.speak()
   duck.run()
}

// 输出:
{小白 15 男}
白鸭子嘎嘎叫,它的名字叫 小白
白鸭子慢悠悠的走,它的名字叫 小白

2、类型断言

用于提取接口的底层值,就是把接口类型转成 struct ,属性,自有方法也有了。

func main() {
	var duck Duck = WhiteDuck{"小白", 15, "男"}
	// 断言是 WhiteDuck 类型
	value, ok := duck.(WhiteDuck)
	// 断言成功,ok=true,value就是WhiteDuck结构体对象
	fmt.Println(value)		// 输出:{小白 15 男}
	fmt.Println(value.name)	// 输出:小白
	fmt.Println(ok)			// 输出:true

	// 断言失败,ok1=false,value1是BlackDuck类型的空值,因为没有赋值
	value1, ok1 := duck.(BlackDuck)
	fmt.Println(value1)		// 输出:{ 0 }
	fmt.Println(ok1)		// 输出:false
}

3、类型选择

(通过 Type Switch )

用于将接口的具体类型与很多 case 语句所指定的类型进行比较。

func main() {
   var duck Duck = WhiteDuck{"小白", 15, "男"}
   test(duck)
}

func test(duck Duck) {
   switch value := duck.(type) {
   case WhiteDuck:
      fmt.Println(value.name)
      fmt.Println("我是白鸭子")
   case BlackDuck:
      fmt.Println(value.name)
      fmt.Println("我是黑鸭子")
   default:
      fmt.Println(value)
      fmt.Println("我是鸭子这个类")
   }
}

4、空接口

没有任何方法,所有数据类型都实现了空接口

type Empty interface {} // 空接口

func main() {
   var a int = 10
   var b string = "XiaoYang"
   var c [3]int
   var e Empty    // e是空接口类型,可以接受任意的数据类型
   e = a
   e = b
   e = c

   // 这样的话需要把它类型选择回来
   // 正常情况下我只能接收 Empty 类型的,但是 a b c 都不是 Empty 类型的
   test(a)	// 输出:我是int 10
   test(b)	// 输出:我是字符串 XiaoYang
   test(c)	// 输出:我是数组 [0 0 0]
}

// 如果这不是一个空接口,比如是 Duck 那么只要实现了 Duck 接口的所有数据类型都可以传
func test(b Empty)  {
   switch v:=b.(type) {
   case string:
      fmt.Println("我是字符串", v)
   case int:
      fmt.Println("我是int", v)
   case [3]int:
      fmt.Println("我是数组", v)
   }
}

5、匿名空接口

没有名字的空接口,一般用在形参上

func main() {
   var duck Duck = WhiteDuck{"小白", 15, "男"}
   test(10)
   test("XiaoYang")
   test(duck)
}

// 这叫匿名空接口,所有数据类型都可以往里面传,如果想用原来的结构体还需要类型选择回来才能用
func test(b interface{}) {
   fmt.Println(b)
}

6、实现多个接口

// Duck 定义一个鸭子接口
type Duck interface {
   speak()
   run()
}

type Animal interface {
   eat()
   sleep()
}

// WhiteDuck 定义一个白鸭子结构体
type WhiteDuck struct {
   name string
   age  int
   sex  string
}

// 让白鸭子即实现 Duck 接口也实现了 Animal 接口
func (w WhiteDuck) speak() {
   fmt.Println("白鸭子嘎嘎叫,它的名字叫", w.name)
}

func (w WhiteDuck) run() {
   fmt.Println("白鸭子慢悠悠的走,它的名字叫", w.name)
}

func (w WhiteDuck) eat() {
   fmt.Println("白鸭子吃饭,它的名字叫", w.name)
}

func (w WhiteDuck) sleep() {
   fmt.Println("白鸭子睡觉,它的名字叫", w.name)
}

func main() {
	var w WhiteDuck = WhiteDuck{}
	var a Animal
	var d Duck

	// 这样的话我的 w 即可以给 a ,也可以给 d
	// 但是一旦转到某个接口上,只能使用该接口的方法,自身属性和自身方法需要类型断言后才能使用

	a = w		// w 给了 a ,那么 a 就只能调用 Animal 接口的方法
	a.sleep()
	a.eat()

	d = w		// w 给了 d ,那么 a 就只能调用 Duck 接口的方法
	d.run()
	d.speak()
}

7、接口嵌套

type Duck interface {
   Animal    // Duck 嵌套 Animal 接口
   speak()
   run()
}

type Animal interface {
   eat()
   sleep()
}

type WhiteDuck struct {
   name string
   age  int
   sex  string
}

// 这样白鸭子即实现 Duck 接口也实现了 Animal 接口
func (w WhiteDuck) speak() {
   fmt.Println("白鸭子嘎嘎叫,它的名字叫", w.name)
}

func (w WhiteDuck) run() {
   fmt.Println("白鸭子慢悠悠的走,它的名字叫", w.name)
}
func (w WhiteDuck) eat() {
   fmt.Println("白鸭子嘎嘎叫,它的名字叫", w.name)
}

func (w WhiteDuck) sleep() {
   fmt.Println("白鸭子慢悠悠的走,它的名字叫", w.name)
}

func main() {
   var a Animal
   var d Duck
   var w WhiteDuck = WhiteDuck{}

   // w 即可以给 a,也可以给 d
   a = w     // 但是 a 只能调用 Animal 中的两个方法
   a.sleep()
   a.eat()

   d = w     // d 却能调用 Duck 和 Animal 中的四个方法
   d.sleep()
   d.eat()
   d.speak()
   d.run()
}

8、接口零值

func main() {

   var a Animal   // nil 就是说明它是一个引用类型
   // 其内部表示就已经告诉了我们,它里面就存两个值,一个是它的类型,一个是指向具体值的指针

   fmt.Println(a) // 输出:<nil>
}

9、make和new的区别

type WhiteDuck struct {
   name string
   sex  string
   age  int
}

func main() {
   var per1 *WhiteDuck = new(WhiteDuck) // new 是返回指向这个类型的指针
   // 或者是我取 WhiteDuck 的地址,赋值给 per2
   var per2 = &WhiteDuck{}

   fmt.Println(per1)  // 输出:&{  0}
   fmt.Println(per2)  // 输出:&{  0}

   var per3 = make([]int, 3, 4)   // make 是具体的创建引用类型
                           // new 是创建指向这个类型的指针
   var per4 = new([]int)        // 是一个指向切片类型的指针

   fmt.Println(per3)  // 输出:[0 0 0]
   fmt.Println(per4)  // 输出:&[]
}

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注我们的更多内容!

(0)

相关推荐

  • Go语言-为什么返回值为接口类型,却返回结构体

    最近由于项目需求,阅读一些Go语言编写的项目的源代码,在某一个函数中发现了一个奇怪的现象:一个函数的返回值类型声明的是一个接口的类型,但是实际在函数体内返回的却是一个结构体类型的对象. 这个现象对于新手的我来说很是费解.在经过一些资料的查阅之后,自己得到了如下的解释: 一个结构体实现了一个接口,那么函数中返回值类型为接口时,就应该返回这个结构体. 下面举一个例子来说明: package main import ( "fmt" ) /** Shape接口定义两个函数: area() :计

  • 分析Go语言接口的设计原则

    目录 一.前言 二.开闭原则 三.依赖倒置原则 3.1.什么是依赖倒置原则 3.2.一个耦合度极高的模块关系设计 3.3.面向抽象层依赖倒转 一.前言 go的interface写起来更自由, 无需显示的实现, 只要实现了与interfece所包含的所有函数签名的相同的方法即可.让编码更灵活, 易扩展. 如何理解go语言中的interface呢? 1. interface是方法声明的集合 2.接口的方法与实现接口的类型方法格式一致 3.接口中所有方法均被实现 4. interface可以作为一种数

  • go语言实现接口查询

    一句话总结:如果接口A实现了接口B中所有方法,那么A可以转化为B接口. package options type IPeople interface { GetName() string } type IPeople2 interface { GetName() string GetAge() int } package main import ( "fmt" "options" ) type person struct { name string } func (

  • GO语言gin框架实现管理员认证登陆接口

    后台用户登录验证功能是很多项目的必须要有的逻辑 , 也是常见的技术需求 . 要实现这个逻辑首先要有数据库表结构如下: CREATE TABLE `user` ( `id` int(11) NOT NULL AUTO_INCREMENT, `name` varchar(50) NOT NULL DEFAULT '', `password` varchar(50) NOT NULL DEFAULT '', `nickname` varchar(50) NOT NULL DEFAULT '', `cr

  • 一篇文章带你玩转go语言的接口

    目录 一.其他语言 二.go语言 三.go接口实现多态 四.空接口的使用(重点) 4.1定义 4.2空接口使用 4.3空接口几个要注意的坑(我刚学时的错误) 总结 一.其他语言 其他语言中所提供的接口概念:接口主要作为不同组件之间的契约存在.对契约的实现是强制的(侵入式接口),你必须声明你的确实现了该接口.为了实现一个接口,你需要从该接口继承. interface IFoo { void Bar(); } // Java文法 // ... class Foo implements IFoo {

  • Go语言使用swagger生成接口文档的方法

    swagger介绍 Swagger本质上是一种用于描述使用JSON表示的RESTful API的接口描述语言.Swagger与一组开源软件工具一起使用,以设计.构建.记录和使用RESTful Web服务.Swagger包括自动文档,代码生成和测试用例生成. 在前后端分离的项目开发过程中,如果后端同学能够提供一份清晰明了的接口文档,那么就能极大地提高大家的沟通效率和开发效率.可是编写接口文档历来都是令人头痛的,而且后续接口文档的维护也十分耗费精力. 最好是有一种方案能够既满足我们输出文档的需要又能

  • Go语言的接口详解

    目录 1.接口的用途 2.类型断言 3.类型选择 4.空接口 5.匿名空接口 6.实现多个接口 7.接口嵌套 8.接口零值 9.make和new的区别 总结 接口就是一系列方法的集合(规范行为) 在面向对象的领域里,接口一般这样定义:接口定义一个对象的行为,规范子类对象的行为. 在 Go 语言中的接口是非侵入式接口(接口没了,不影响代码),侵入式接口(接口没了,子类报错) Go 也是鸭子类型,比如我现在有个鸭子类,内有 speak 方法和 run 方法,子类只要实现了 speak 和 run,我

  • spring的几个重要类和接口(详解)

    1. datasource接口是javax.sql包下的接口,不是spring,是javax.sql下的 datasource接口有个重要的方法getConnection()方法 Connection getConnection(String username, String password) throws SQLException; 那些spring支持的数据库连接池,都是实现了Datasource接口 比如下面是阿里的DruidDatasource数据库连接池源码,它就是实现了dataso

  • Java基础学习之接口详解

    目录 概述 定义格式 含有抽象方法 含有默认方法和静态方法 含有私有方法和私有静态方法 基本的实现 实现的概述 抽象方法的使用 默认方法的使用 静态方法的使用 私有方法的使用 接口的多实现 抽象方法 默认方法 静态方法 优先级的问题 接口的多继承 其他成员特点 概述 接口,是Java语言中一种引用类型,是方法的集合,如果说类的内部封装了成员变量.构造方法和成员方法,那么接口的内部主要就是封装了方法,包含抽象方法(JDK 7及以前),默认方法和静态方法(JDK 8),私有方法 (JDK 9). 接

  • 类似Object监视器方法的Condition接口(详解)

    在<基于线程.并发的基本概念(详解)>中,我们利用synchronized关键字.Queue队列.以及Object监视器方法实现了生产者消费者,介绍了有关线程的一些基本概念.Object类提供的wait的方法和notifyAll方法,与之对应的是Condition接口提供是await和signalAll.await(或wait)是让当前线程进入等待状态并释放锁,signalAll(或notifyAll)则是唤醒等待中的线程,使得等待中的线程有竞争锁的资格,注意只是资格,并不代表被唤醒的线程就一

  • 基于多态之虚方法、抽象类、接口详解

    虚方法: 1.在父类方法的返回值前加 virtual 关键字,标记为虚方法,表示这个方法可以被子类重写. 2.虚方法必须有方法体,方法体中可以没有任何内容. 3.子类可以根据需求选择性的是否重写虚方法.如果需要重写,在子类方法的返回值前加 override 关键字. 4.子类在重写虚方法时,可以根据需求选择性的是否使用 base 关键字调用父类中的该方法. 虚方法语法格式如下: public class Father { public virtual void Do() { //..... }

  • 微信小程序和百度的语音识别接口详解

    介绍 因为项目需要,使用到了微信小程序和百度的语音接口 现在将项目中的一个小模块拿出来单独分享. 技术关键字 微微信小程序 百度语音接口 nodejs,express fluent-ffmegp 环境 windows 10 vs code 1.20.1 微信小程序开发工具 1.02.1802270 花生壳-提供域名和内容穿透-用于方便本地远程调试微信小程序 考虑到业务并不复杂,所以就将所有的代码都放在一个页面就可以了(wxml,wxss,js统称为一个页面) 文件目录 页面 index.wxml

  • 对YOLOv3模型调用时候的python接口详解

    需要注意的是:更改完源程序.c文件,需要对整个项目重新编译.make install,对已经生成的文件进行更新,类似于之前VS中在一个类中增加新函数重新编译封装dll,而python接口的调用主要使用的是libdarknet.so文件,其余在配置文件中的修改不必重新进行编译安装. 之前训练好的模型,在模型调用的时候,总是在 lib = CDLL("/home/*****/*******/darknet/libdarknet.so", RTLD_GLOBAL)这里读不到darknet编译

  • 易语言子程序知识点详解

    将程序分割成较小的逻辑组件就可以简化程序设计任务,这些逻辑组件被称为子程序. 子程序可用于压缩重复任务或共享任务,例如,压缩频繁的计算处理等等. 用子程序编程有两大好处: 子程序可使程序划分成离散的逻辑组件,每个组件都比无子程序的整个程序容易调试及理解: 一个应用程序中的子程序,往往不必修改或只需稍作改动,便可以成为另一个程序的子程序. 每次调用子程序时,子程序中的所有语句都将被从第一条开始顺序执行,当执行到子程序尾部或者遇到"返回"命令时即返回到调用此子程序语句的下一条语句处. 子程

  • Spring表达式语言SpEL用法详解

    这篇文章主要介绍了spring表达式语言SpEL用法详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 (1)spring表达式语言是一个支持运行时查询和操作对象图得我强大表达式语言. (2)语言类似于EL:SpEL使用#{...}作为定界符.所有在大括号中的字符串均被认为是SpEL. (3)SpEL为bean的属性进行动态赋值提供了便利. (4)通过SpEL可以实现: 通过Bean的id对Bean进行引用 调用方法及引用对象的属性 计算表达式

  • python 发送get请求接口详解

    简介 如果想用python做接口测试,我们首先有不得不了解和学习的模块.它就是第三方模块:Requests. 虽然Python内置的urllib模块,用于访问网络资源.但是,它用起来比较麻烦,而且,缺少很多实用的高级功能.更好的方案是使用 requests.它是一个Python第三方库,处理URL资源特别方便.查看其中文官网:http://cn.python-requests.org/zh_CN/latest/index.html英文官网:http://www.python-requests.o

随机推荐