Go语言中interface语法与使用详解

目录
  • 初识interface
    • 基本语法
    • 其他注意事项
  • interface底层实现
    • iface
    • eface
  • 侵入式与非侵入式的理解
  • interface的应用场景
    • 类型转换
    • 实现多态功能
  • 补充:interface 与 nil 的比较
  • 总结

初识interface

Go语言的面向对象的知识点时,发现它的面向对象能力全靠 interface 撑着,而且它的 interface 还与我们以前知道的 interface 完全不同。故而整个过程不断的思考为什么要如此设计?这样设计给我们带来了什么影响?

interface(接口)是golang最重要的特性之一,实现多态。Interface类型可以定义一组方法,但是这些不需要实现。并且interface不能包含任何变量。

基本语法

定义一个接口

type Person interface {
    // 声明方法
    method1(参数列表)返回值列表
    method2(参数列表)返回值列表
}

实现一个接口

func (t 自定义类型)method1(参数列表)返回值列表 {
    //方法实现
}
func (t 自定义类型)method2(参数列表)返回值列表 {
    //方法实现
}

小结:

(1)接口里的所有方法都没有方法体,即接口的方法都是没有实现的方法。接口体现了程序设计的多态和高内聚低耦合的思想。

(2)Go中的接口,不需要显示的实现。只要一个变量,含有接口类型中的所有方法,那么这个变量就实现这个接口。因此,Go中没有implement关键字样。

(3)Go实现接口与方法有关,与接口本身叫什么名字没有特别大的关系。变量需要实现接口所有的方法。

其他注意事项

(1)接口本身不能创建实例,但是可以指向一个实现了该接口的自定义类型的变量(实例)。

package main

import "fmt"

// Person 定义接口
type Person interface {
	GetName() string
	GetAge() uint32
}

// Student 定义类型
type Student struct {
	Name string
	Age uint32
}

func (s Student) GetName()  string{
	return s.Name
}
func (s Student) GetAge()  uint32{
	return s.Age
}

func main() {

var student Student
	student.Age = 12
	student.Name = "小明"

var person Person
	person = student  //接口执行向student
	fmt.Printf("name:%s,age: %d\n", person.GetName(), person.GetAge())
}

(2)接口中所有的方法都没有方法体,即都是没有实现的方法。

(3)在Go中,一个自定义类型需要将某个接口的所有方法都实现,我们说这个自定义类型实现了该接口。

(4)一个自定义类型只有实现了某个接口,才能将该自定义类型的实例(变量)赋给接口类型。

(5)只要是自定义数据类型就可以实现接口,不仅仅是结构体类型。

(6)一个自定义类型可以实现多个接口。

(7)Go接口不能有任何变量。

(8)一个接口可以继承多个别的接口,这时如果要实现这个接口必须实现它继承的所有接口的方法。在低版本的Go编辑器中,一个接口继承其他多个接口时,不允许继承的接口有相同的方法名。比如A接口继承B、C接口,B、C接口的方法名不能一样。高版本的Go编辑器没有相关问题。

(9)interface类型默认是一个指针(引用类型),如果没有对interface初始化就使用,那么会输出nil。

(10)空接口interface{}没有任何方法,所以所有类型都实现了空接口,即我们可以把任何一个变量赋给空接口类型。

interface底层实现

Go的interface源码在Golang源码的runtime目录中。

Go的interface是由两种类型来实现的:iface和eface。

iface

iface是包含方法的interface,如:

type Person interface {
	Print()
}

iface的源代码是:

type iface struct {
	tab  *itab
	data unsafe.Pointer
}

iface具体结构是:

itab是iface不同于eface的关键数据结构。其包含两部分:一部分是唯一确定包含该interface的具体结构类型,一部分是指向具体方法集的指针。其具体结构为:

属性 itab的源代码是:

type itab struct {
	inter *interfacetype //此属性用于定位到具体interface
	_type *_type         //此属性用于定位到具体interface
	hash  uint32         // copy of _type.hash. Used for type switches.
	_     [4]byte
	fun   [1]uintptr     // variable sized. fun[0]==0 means _type does not implement inter.
}

属性interfacetype类似于_type,其作用就是interface的公共描述,类似的还有maptype、arraytype、chantype…其都是各个结构的公共描述,可以理解为一种外在的表现信息。interfacetype源码如下:

type interfacetype struct {
	typ     _type
	pkgpath name
	mhdr    []imethod
}
type imethod struct {
	name nameOff
	ityp typeOff
}

iface的整体结构为:

我们来看一个例子,对于含有方法的interface赋值后的内部结构是怎样的呢?

package main

import "fmt"

// Person 定义接口
type Person interface {
	GetName() string
	GetAge() uint32
}

// Student 定义类型
type Student struct {
	Name string
	Age uint32
}

func (s Student) GetName()  string{
	return s.Name
}
func (s Student) GetAge()  uint32{
	return s.Age
}

func main() {

var student Student
	student.Age = 12
	student.Name = "小明"

var person Person
	person = student
	fmt.Printf("name:%s,age: %d\n", person.GetName(), person.GetAge())
}

运行结果:

name:小明,age: 12

Process finished with the exit code 0

内存分布示意图:

eface

eface是不包含方法的interface,即空interface,如:

type Person interface {
}

或者

var person interface{} = xxxx实体

侵入式与非侵入式的理解

侵入式

你的代码里已经嵌入了别的代码,这些代码可能是你引入过的框架,也可能是你通过接口继承得来的,比如:java中的继承,必须显示的表明我要继承那个接口,这样你就可以拥有侵入代码的一些功能。所以我们就称这段代码是侵入式代码。

优点:通过侵入代码与你的代码结合可以更好的利用侵入代码提供给的功能。

缺点:框架外代码就不能使用了,不利于代码复用。依赖太多重构代码太痛苦了。

非侵入式

正好与侵入式相反,你的代码没有引入别的包或框架,完完全全是自主开发。比如go中的接口,不需要显示的继承接口,只需要实现接口的所有方法就叫实现了该接口,即便该接口删掉了,也不会影响我,所有go语言的接口数非侵入式接口;再如Python所崇尚的鸭子类型。

优点:代码可复用,方便移植。非侵入式也体现了代码的设计原则:高内聚,低耦合。

缺点:无法复用框架提供的代码和功能。

接下来看看java与go语言编程实现接口来理解侵入式与非侵入式的区别。

java语言实现

定义接口

public interface IPersonService {
    String getName();
    Integer getAge();
}

实现接口的类

public class PersonService implements IPersonService{
    @Override
    public String getName() {
        return "小明";
    }
    @Override
    public Integer getAge() {
        return 12;
    }
}

go语言实现

package main
import "fmt"

// Person 定义接口
type Person interface {
	GetName() string
	GetAge() uint32
}
// Student 定义类型
type Student struct {
	Name string
	Age uint32
}

func (s Student) GetName()  string{
	return s.Name
}
func (s Student) GetAge()  uint32{
	return s.Age
}

func main() {

var student Student
	student.Age = 12
	student.Name = "小明"

var person Person
	person = student
	fmt.Printf("name:%s,age: %d\n", person.GetName(), person.GetAge())
}

通过上面的例子我们总结了以下问题:

  1. 侵入式通过 implements 把实现类与具体接口绑定起来了,因此有了强耦合;
  2. 假如修改了接口方法,则实现类方法必须改动;
  3. 假如类想再实现一个接口,实现类也必须进行改动;
  4. 后续实现此接口的类,必须了解相关的接口;
    Go语言非侵入式的方式很好地解决了这几个问题,只要实现了实现了与接口相同的方法,就实现了这个接口。随着代码量的增加,根本不需要的关心实现了哪些接口,不需要刻意去先定义接口再实现接口的固定模式,在原有类新增实现接口时,不需要更改类,做到低侵入式、低耦合开发的好处。

interface的应用场景

类型转换

类型推断可将接口变量还原为原始类型,或用来判断是否实现了某个更具体的接口类型。

type data int

func(d data)String()string{
   return fmt.Sprintf("data:%d",d)
} 

func main() {
   var d data=15
   var x interface{} =d

   if n,ok:=x.(fmt.Stringer);ok{  // 转换为更具体的接口类型
       fmt.Println(n)
    } 

   if d2,ok:=x.(data);ok{        // 转换回原始类型
       fmt.Println(d2)
    } 

   e:=x.(error)           // 错误:main.data is not error
   fmt.Println(e)
}

输出为:

data:15
data:15
panic:interface conversion:main.data is not error:missing method Error

但是此处会触发panic,使用ok-idiom模式,即便转换失败也不会引发panic。还可用switch语句在多种类型间做出推断匹配,这样空接口就有更多发挥空间。

func main() {
var x interface{} =func(x int)string{
       return fmt.Sprintf("d:%d",x)
    } 

   switch v:=x.(type) {            // 局部变量v是类型转换后的结果
   case nil:
       println("nil")
   case*int:
       println(*v)
   case func(int)string:
       println(v(100))
   case fmt.Stringer:
       fmt.Println(v)
   default:
       println("unknown")
    }
}

输出为:

d:100

实现多态功能

多态功能是interface实现的重要功能,也是Golang中的一大行为特色,其多态功能一般要结合Go method实现,作为函数参数可以容易的实现多台功能。

package main

import "fmt"

// notifier是一个定义了通知类行为的接口
type notifier interface {
  notify()
}

// 定义user及user.notify方法
type user struct {
  name string
  email string
}

func (u *user) notify() {
  fmt.Printf("Sending user email to %s<%s>\n",
    u.name,
    u.email)
}

// 定义admin及admin.notify方法
type admin struct {
  name string
  email string
}

func (a *admin) notify() {
  fmt.Printf("Sending admin email to %s<%s>\n",
    a.name,
    a.email)
}

func main() {
  // 创建一个user值并传给sendNotification
  bill := user{"Bill", "bill@email.com"}
  sendNotification(&bill)

  // 创建一个admin值并传给sendNotification
  lisa := admin{"Lisa", "lisa@email.com"}
  sendNotification(&lisa)
}

// sendNotification接受一个实现了notifier接口的值
// 并发送通知
func sendNotification(n notifier) {
  n.notify()
}

上述代码中实现了一个多态的例子,函数sendNotification接受一个实现了notifier接口的值作为参数。既然任意一个实体类型都能实现该接口,那么这个函数可以针对任意实体类型的值来执行notify方法,调用notify时,会根据对象的实际定义来实现不同的行为,从而实现多态行为。

补充:interface 与 nil 的比较

引用公司内部同事的讨论议题,觉得之前自己也没有理解明白,为此,单独罗列出来,例子是最好的说明,如下

package main

import (
    "fmt"
    "reflect"
)

type State struct{}

func testnil1(a, b interface{}) bool {
    return a == b
}

func testnil2(a *State, b interface{}) bool {
    return a == b
}

func testnil3(a interface{}) bool {
    return a == nil
}

func testnil4(a *State) bool {
    return a == nil
}

func testnil5(a interface{}) bool {
    v := reflect.ValueOf(a)
    return !v.IsValid() || v.IsNil()
}

func main() {
    var a *State
    fmt.Println(testnil1(a, nil))
    fmt.Println(testnil2(a, nil))
    fmt.Println(testnil3(a))
    fmt.Println(testnil4(a))
    fmt.Println(testnil5(a))
}

返回结果如下

false
false
false
true
true

为啥呢?

一个interface{}类型的变量包含了2个指针,一个指针指向值的类型,另外一个指针指向实际的值 对一个interface{}类型的nil变量来说,它的两个指针都是0;但是var a *State传进去后,指向的类型的指针不为0了,因为有类型了, 所以比较为false。 interface 类型比较, 要是 两个指针都相等, 才能相等。

总结

到此这篇关于Go语言中interface语法与使用详解的文章就介绍到这了,更多相关Go语言 interface详解内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Go语言interface 与 nil 的比较

    interface简介 Go语言以简单易上手而著称,它的语法非常简单,熟悉C++,Java的开发者只需要很短的时间就可以掌握Go语言的基本用法. interface是Go语言里所提供的非常重要的特性.一个interface里可以定义一个或者多个函数,例如系统自带的io.ReadWriter的定义如下所示: type ReadWriter interface { Read(b []byte) (n int, err error) Write(b []byte) (n int, err error)

  • Go语言中你不知道的Interface详解

    前言 最近在看Go语言的面向对象的知识点时,发现它的面向对象能力全靠 interface 撑着,而且它的 interface 还与我们以前知道的 interface 完全不同.故而整个过程不断的思考为什么要如此设计?这样设计给我们带来了什么影响? interface 我不懂你 Rob Pike 曾说: 如果只能选择一个Go语言的特 性移植到其他语言中,他会选择接口 被Go语言设计者如此看重,想来 interface 一定是资质不凡,颜值爆表.但是说实话,当我第一次读这部分内容的时候,我产生了以下

  • go语言interface接口继承多态示例及定义解析

    目录 1.什么是接口 2.接口定义 3.多态 多态加减计算器 4.接口继承与转换 5.空接口 6.接口转换 7.实现map字典接口 8.interface案例 1.什么是接口 接口就是一种规范与标准,在生活中经常见接口,例如:笔记本电脑的USB接口,可以将任何厂商生产的鼠标与键盘,与电脑进行链接.为什么呢?原因就是,USB接口将规范和标准制定好后,各个生产厂商可以按照该标准生产鼠标和键盘就可以了. 在程序开发中,接口只是规定了要做哪些事情,干什么.具体怎么做,接口是不管的.这和生活中接口的案例也

  • Go语言interface详解

    interface Go语言里面设计最精妙的应该算interface,它让面向对象,内容组织实现非常的方便,当你看完这一章,你就会被interface的巧妙设计所折服. 什么是interface 简单的说,interface是一组method的组合,我们通过interface来定义对象的一组行为. 我们前面一章最后一个例子中Student和Employee都能SayHi,虽然他们的内部实现不一样,但是那不重要,重要的是他们都能say hi 让我们来继续做更多的扩展,Student和Employe

  • 浅谈Go语言多态的实现与interface使用

    目录 一.多态的含义 二.抽象类与接口 三.Golang中的接口 四.总结 一.多态的含义 对于Java或者是C++而言,我们在使用变量的时候,变量的类型是明确的.但是如果我们希望它可以宽松一点,比如说我们用父类指针或引用去调用方法,但是在执行的时候,能够根据子类的类型去执行子类当中的方法.也就是说实现我们用相同的调用方式调出不同结果或者是功能的情况,这种情况就叫做多态. 举个非常经典的例子,比如说猫.狗和人都是哺乳动物.这三个类都有一个say方法,大家都知道猫.狗以及人类的say是不一样的,猫

  • 浅谈Go语言中的结构体struct & 接口Interface & 反射

    结构体struct struct 用来自定义复杂数据结构,可以包含多个字段(属性),可以嵌套: go中的struct类型理解为类,可以定义方法,和函数定义有些许区别: struct类型是值类型. struct定义 type User struct { Name string Age int32 mess string } var user User var user1 *User = &User{} var user2 *User = new(User) struct使用 下面示例中user1和

  • go语言中的interface使用实例

    go语言中的interface是一组未实现的方法的集合,如果某个对象实现了接口中的所有方法,那么此对象就实现了此接口.与其它面向对象语言不同的是,go中无需显示声明调用了哪个接口. 复制代码 代码如下: package main   import (  "fmt" )   type I interface {  Get() int  Put(int) }   type S struct{ i int }   func (p *S) Get() int  { return p.i } f

  • Go语言中interface语法与使用详解

    目录 初识interface 基本语法 其他注意事项 interface底层实现 iface eface 侵入式与非侵入式的理解 interface的应用场景 类型转换 实现多态功能 补充:interface 与 nil 的比较 总结 初识interface Go语言的面向对象的知识点时,发现它的面向对象能力全靠 interface 撑着,而且它的 interface 还与我们以前知道的 interface 完全不同.故而整个过程不断的思考为什么要如此设计?这样设计给我们带来了什么影响? int

  • C语言中 “_at()” 特殊地址定位详解

    C语言中 "_at()" 特殊地址定位详解 在keil里面,有一个特殊地址定位的指令,就是将一个变量或常量定位到一个指定的地址上面 指令为 __at ,使用方法如下 int variable __at(0x8000) = 100; 意为将variable变量定位到0x8000这个地址. 指令的目的是告诉链接器将指定地址定位到某个地址里面,在使用该功能的时候需要注意一点的是,地址的范围需要符合单片机的datasheet给出的地址映射表, 注意,如果地址超出了flash的最大范围,程序将无

  • C语言中memcpy 函数的用法详解

    C语言中memcpy 函数的用法详解 memcpy(内存拷贝函数) c和c++使用的内存拷贝函数,memcpy函数的功能是从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中. void* memcpy(void* destination, const void* source, size_t num); void* dest 目标内存 const void* src 源内存 size_t num 字节个数 库中实现的memcpy函数 struct { ch

  • C语言中fgets和fscanf区别详解

    C语言中fgets和fscanf区别详解 一.作用上的大概区别: ①fgets:从文件中读取一行数据存入缓冲区(fgets遇到回车才会结束,不对空格和回车做任何转换就录入到缓冲区,结束后再往缓冲区写多一个\0,所以它是读一行数据) ②fscanf:从文件中读取一段数据存入缓冲区(fscanf遇到空格或回车就结束,它会把空格或回车转换为\0,所以它是读一小段数据) 二.举个例子:把a.txt文件中的内容复制到b.txt. a.txt中的内容(第一行中"我爱你小白"和"开玩笑&q

  • C语言中scanf与scnaf_s函数详解

    目录 scanf_s 使用scanf_s scanf 使用scanf 总结 scanf_s scanf_s()函数是Microsoft公司VS开发工具提供的一个功能相同的安全标准输入函数,从vc++2005开始,VS系统提供了scanf_s().在调用该函数时,可以提供一个数字以表明最多读取多少位字符. MSDN上scanf_s的简单模型:int scanf_s( const char *format [, argument]...);一般我们常用的格式:scanf_s(输入格式,输入流 [,输

  • C语言中static和auto用法详解

    目录 static的第一种用法:定义为静态变量 static的第二种用法:有理说不清,直接代码见真知 auto的用法:直接代码见真知 总结 static的第一种用法:定义为静态变量 何为静态变量?存储在静态数据区的变量会在程序刚开始运行时就完成初始化,也是唯一的一次初始化.就是只进行一次初始化.不理解?看代码! 代码见真知: #include<stdio.h> int main() { void fun(); //定义一个空函数 for(int i=0;i<3;i++) { fun();

  • C语言中的sscanf()函数使用详解

    sscanf() - 从一个字符串中读进与指定格式相符的数据. 函数原型: Int sscanf( string str, string fmt, mixed var1, mixed var2 ... ); int scanf( const char *format [,argument]... ); 说明: sscanf与scanf类似,都是用于输入的,只是后者以屏幕(stdin)为输入源,前者以固定字符串为输入源. 其中的format可以是一个或多个 {%[*] [width] [{h |

  • C语言中free函数的使用详解

    free函数是我们再写C语言程序时常用的函数,但是使用时需要注意,一不小心很肯能会引起吐核. 注意:free函数与malloc()函数配对使用,释放malloc函数申请的动态内存.对于free(p)这句语句,如果p 是NULL 指针,那么free 对p 无论操作多少次都不会出问题.如果p 不是NULL 指针,那么free 对p连续操作两次就会导致程序运行错误. 看一个程序 #include <stdio.h> #include <stdlib.h> int main() { cha

  • sql语言中delete删除命令语句详解

    Table:用于标示删除的数据表的名称. 1:该表必须是一个事实存在的表,对于该处的表必须是一个实际存在于数据库中的表格,必能是由于select等语句创造出来的中间表. 2:该方式可以通过联合的方式同时在两个表格中满足一定关联条件的数据. Top(*)用于指定删除的数据的数量 1:Top(N)表示在该表中删除表格中最靠前的N条数据. 2:在delete中不能和order连用,所以也不能通过top和order by连用来删除按照某一条件排序的全部的靠前的几条记录. 3:改语句不能用于sql2000

  • C语言中的rand()和rand_r()详解

    目录 背景 rand()和rand_r()的区别 rand() rand_r() 总结 背景 最近在学<并行程序设计导论>这门课,在做使用Pthreads并行化蒙特卡洛法估计 π \pi π的实验时遇到了一个问题,使用多线程反而要比单线程要慢很多,输出如下所示 可以看到,使用一个线程时程序运行只需要2.89031秒,但是使用两个线程时运行时间竟然达到了9.14698秒. 最终发现了问题所在:每个线程在执行下面的函数时,生成随机数使用了rand()函数,就是这个函数的使用才导致多线程运行时所需要

随机推荐