什么是接口

在面向对象语言中,接口一般被定义为 :接口定义了一个对象的行为。它仅仅指定了一个对象应该做什么。具体怎么做(实现细节)是由对象决定的。

在 Go 中,一个接口定义为若干方法的签名。当一个类型定义了所有接口里的方法时,就说这个类型实现了这个接口。这和 OOP 很像。接口指定了一个类型应该包含什么方法,而该类型决定怎么实现这些方法。

比如 WashingMachine可以作为一个接口,并提供两个函数 Cleaning() 和 Drying()。任何提供了 Cleaning() 和 Drying() 方法定义的类型就可以说它实现了 WashingMachine 接口。

声明和实现接口

让我们通过一个程序看一下如何声明和实现一个接口

package main

import (
"fmt"
) //interface definition
type VowelsFinder interface {
FindVowels() []rune
} type MyString string //MyString implements VowelsFinder
func (ms MyString) FindVowels() []rune {
var vowels []rune
for _, rune := range ms {
if rune == 'a' || rune == 'e' || rune == 'i' || rune == 'o' || rune == 'u' {
vowels = append(vowels, rune)
}
}
return vowels
} func main() {
name := MyString("Sam Anderson")
var v VowelsFinder
v = name // possible since MyString implements VowelsFinder
fmt.Printf("Vowels are %c", v.FindVowels()) }

程序的第8行创建了一个接口类型名为 VowelsFinder,它有一个方法 FindVowels() []rune

在下一行 MyString 类型被创建。

在第15行我们添加了一个方法 FindVowels() []rune 给接受者类型 MyString。现在可以说 MyString 实现了 VowelsFinder 接口。这和其他语言大大的不同,比如在Java中,一个类必须用 implements 关键字显式的标明实现了一个接口。这在Go中是不需要的,在Go中,如果一个类型包含了一个接口声明的所有方法,那么这个类型就隐式地实现了这个接口。

在第28行,我们将 MyString 类型的变量 name 赋值给 VowelsFinder 类型的变量 v。这是合法的,因为 MyString 实现了 VowelsFinder。在下一行,v.FindVowels() 在 MyString 上调用 FindVowels 方法打印在 Sam Anderson 中所有的元音。程序的输出为:Vowels are [a e o]

恭喜!你已经创建并实现了你的第一个接口。

接口的实际用途

上面的程序告诉我们怎么创建和实现接口,但是没有展示接口的实际用途。在上面的程序中,我们可以使用 name.FindVowels()替代 v.FindVowels(),程序照样可以工作,那么我们为什么还要使用接口呢?

现在让我们来看接口的一个实际用途。

我们将编写一个简单的程序,根据员工的个人工资计算公司的总支出。为了简洁起见,我们假设所有费用都是美元。

package main

import (
"fmt"
) type SalaryCalculator interface {
CalculateSalary() int
} type Permanent struct {
empId int
basicpay int
pf int
} type Contract struct {
empId int
basicpay int
} //salary of permanent employee is sum of basic pay and pf
func (p Permanent) CalculateSalary() int {
return p.basicpay + p.pf
} //salary of contract employee is the basic pay alone
func (c Contract) CalculateSalary() int {
return c.basicpay
} /*
total expense is calculated by iterating though the SalaryCalculator slice and summing
the salaries of the individual employees
*/
func totalExpense(s []SalaryCalculator) {
expense :=
for _, v := range s {
expense = expense + v.CalculateSalary()
}
fmt.Printf("Total Expense Per Month $%d", expense)
} func main() {
pemp1 := Permanent{, , }
pemp2 := Permanent{, , }
cemp1 := Contract{, }
employees := []SalaryCalculator{pemp1, pemp2, cemp1}
totalExpense(employees) }

上面程序地第7行,定义了一个 SalaryCalculator 接口类型,该接口只声明了一个方法:CalculateSalary() int

在公司中我们有两种类型的员工:Permanent 和 Contract (第 11 和 17 行)。永久性员工的工资是 basicpay 和 pf 的总和,而合同员工的工资只是基本工资 basicpay。这分别在第23行和第28行的方法 CalculateSalary 中表示。通过声明这个方法,Permanent 和 Contract 都实现了 SalaryCalculator 接口。

第36行中, totalExpense 方法的声明展示了使用接口的好处。这个方法接收一个 SalaryCalculator 接口的切片 []SalaryCalculator 作为参数。在第49行,我们将一个包含了 Permanent 和 Contract 类型的切片给方法 totalExpensetotalExpense 方法出通过调用各自类型的 CalculateSalary 方法来计算总支。这是在第 39行完成的。

最大的优点是可以将 totalExpense 扩展到任何新的员工类型,而不必修改任何代码。假设该公司引入了第三种员工类型 Freelancer 和不同的计算工资的方法。那么 Freelancer 可以被包含在传递给 totalExpense 的切片参数中,而不需要修改任何 totalExpense 方法的接口。这个方法会做自己应该做的事情,因为 Freelancer 同样实现了 SalaryCalculator 接口:)

程序的输出为:Total Expense Per Month $14050

接口的内部表示

可以把接口想象成这样一个元组 (type, value)type 是接口包含的具体类型,value 是接口包含的具体的值。

让我们写一个程序来理解这一点。

package main

import (
"fmt"
) type Test interface {
Tester()
} type MyFloat float64 func (m MyFloat) Tester() {
fmt.Println(m)
} func describe(t Test) {
fmt.Printf("Interface type %T value %v\n", t, t)
} func main() {
var t Test
f := MyFloat(89.7)
t = f
describe(t)
t.Tester()
}

Test 接口提供了一个方法 Tester()MyFloat 类型实现了这个接口。在第 24 行,我们将 MyFloat 类型的变量 f 赋值给 Test 类型的变量 t 。现在 t 的具体类型是 MyFloat 而它的值是 89.7。在第17行, describe 函数打印接口的值和具体类型。程序的输出为:

Interface type main.MyFloat value 89.7
89.7

空接口

一个没有声明任何方法的接口称为空接口。空接口表示为 interface{}。因为空接口没有方法,因此所有类都都实现了空接口。

package main

import (
"fmt"
) func describe(i interface{}) {
fmt.Printf("Type = %T, value = %v\n", i, i)
} func main() {
s := "Hello World"
describe(s)
i :=
describe(i)
strt := struct {
name string
}{
name: "Naveen R",
}
describe(strt)
}

上面程序的第7行,describe(i interface{}) 函数接受一个空接口作为参数,因此任何值都可以传递给它。

在第13行,15行,21行,我们传递 string,int 和结构体给 describe 。程序的输出结果为:

Type = string, value = Hello World
Type = int, value =
Type = struct { name string }, value = {Naveen R}

类型断言

类型断言(type assertion)用来提取接口的实际类型的值。

i.(T)是用来获取接口 i 的实际类型 T 的值的语法。

一个程序胜过千言万语:),让我们写一个类型断言。

package main

import (
"fmt"
) func assert(i interface{}) {
s := i.(int) //get the underlying int value from i
fmt.Println(s)
}
func main() {
var s interface{} =
assert(s)
}

第12行,s 的实际类型是 int。在第8 行我们使用 i.(int) 来获取 i 的 int 值。程序的输出为:56

如果实际类型不是 int,那么上面的程序会发生什么?让我们找出来:

package main

import (
"fmt"
) func assert(i interface{}) {
s := i.(int)
fmt.Println(s)
}
func main() {
var s interface{} = "Steven Paul"
assert(s)
}

在上面的程序中,我们将实际类型为 string 的变量 s 传递给 assert 函数,assert 函数尝试从其中提取出一个 int值。该程序会触发 panic:panic: interface conversion: interface {} is string, not int

为了解决以上问题,我们可以使用下面的语法:

v, ok := i.(T)

如果 i 的具体类型是 T,则 v 将具有 i 的实际值,ok 为 true

如果 i 的具体类型不是 T,则 ok 将为 false, v 将具有 T 的 0 值,程序不会触发 panic。

package main

import (
"fmt"
) func assert(i interface{}) {
v, ok := i.(int)
fmt.Println(v, ok)
}
func main() {
var s interface{} =
assert(s)
var i interface{} = "Steven Paul"
assert(i)
}

当 Steven Paul 传递给 assert 函数,ok 将是 false 因为 i 的实际类型不是 int 并且 v 的值将是 0(int 的 0 值)。程序将输出:

 true
false

Type Switch

类型分支(type switch)用来将一个接口的具体类型与多个 case 语句指定的类型进行比较。这很像普通的 switch 语句。唯一不同的是 type switch 中 case 指定的是类型,而普通的 switch 语句中 case 指定的是值。

type switch 的语法与类型断言和很相似。在类型断言 i.(T) 中,将类型 T 替换为关键字 type 就变成了 type switch。让我们通过下面的程序看看它是如何工作的。

package main

import (
"fmt"
) func findType(i interface{}) {
switch i.(type) {
case string:
fmt.Printf("I am a string and my value is %s\n", i.(string))
case int:
fmt.Printf("I am an int and my value is %d\n", i.(int))
default:
fmt.Printf("Unknown type\n")
}
}
func main() {
findType("Naveen")
findType()
findType(89.98)
}

上面的程序中,第8行,switch i.(type) 是一个 type switch。每一个 case 语句都将 i 的实际类型和 case 指定的类型相比较。如果一个 case 匹配,则打印相应的语句。程序的输出为:

I am a string and my value is Naveen
I am an int and my value is
Unknown type

在第20行,89.98 是 flaot64 类型,并不匹配任何一个 case。因此在会后一行打印:Unknown type

也可以将类型和接口进行比较。如果我们有一个类型,并且该类型实现了一个接口,那么这个类型可以和它实现的接口进行比较。

让我们写一个程序来更清楚地了解这一点。

package main

import "fmt"

type Describer interface {
Describe()
}
type Person struct {
name string
age int
} func (p Person) Describe() {
fmt.Printf("%s is %d years old", p.name, p.age)
} func findType(i interface{}) {
switch v := i.(type) {
case Describer:
v.Describe()
default:
fmt.Printf("unknown type\n")
}
} func main() {
findType("Naveen")
p := Person{
name: "Naveen R",
age: ,
}
findType(p)
}

在上面的程序中,Person 结构体实现了 Describer 接口。在第 19 行的 case 语句,v 和 Describe 接口进行比较。由于 p 实现了 Describer 接口因此这个 case 匹配成功,在第32行 findType(p) 中 Person 的 Describe() 方法被调用。

程序的输出为:

unknown type
Naveen R is years old

Golang教程:接口的更多相关文章

  1. [golang note] 接口使用

    侵入式接口 √ 在其他一些编程语言中,接口主要是作为不同组件之间的契约存在,即规定双方交互的规约. √ 对契约的实现是强制的,即必须确保用户的确实现了该接口,而实现一个接口,需要从该接口继承. √ 如 ...

  2. golang(08)接口介绍

    原文链接 http://www.limerence2017.com/2019/09/12/golang13/#more 接口简介 golang 中接口是常用的数据结构,接口可以实现like的功能.什么 ...

  3. Golang之接口(interface)

    Golang最重要的接口,,,, package main import ( "fmt" ) //interface类型默认是指针 /* 接口的实现 Golang中的接口,不需要显 ...

  4. golang中接口interface和struct结构类的分析

    再golang中,我们要充分理解interface和struct这两种数据类型.为此,我们需要优先理解type的作用. type是golang语言中定义数据类型的唯一关键字.对于type中的匿名成员和 ...

  5. Golang教程:变量

    声明单一变量 声明一个变量的语法为:var name type,例如 package main import "fmt" func main() { var age int // ...

  6. Golang的接口

    当一只鸟走路像鸭子,游泳像鸭子,叫起来也像鸭子,那么我们就认为它就是鸭子. Duck typing 的理念因此比喻得名. Golang 通过 interface 实现 duck typing. Eff ...

  7. 七、golang中接口、反射

    一.接口定义 1.定义 interface类型可以定义一组方法,但是这些不需要实现,并且interface不能包含任何变量 package main import ( "fmt" ...

  8. Golang | 既是接口又是类型,interface是什么神仙用法?

    本文始发于个人公众号:TechFlow,原创不易,求个关注 今天是golang专题的第12篇文章,我们来继续聊聊interface的使用. 在上一篇文章当中我们介绍了面向对象的一些基本概念,以及gol ...

  9. 深入学习golang(5)—接口

    接口 概述 如果说goroutine和channel是Go并发的两大基石,那么接口是Go语言编程中数据类型的关键.在Go语言的实际编程中,几乎所有的数据结构都围绕接口展开,接口是Go语言中所有数据结构 ...

随机推荐

  1. django+echarts

    思路: 统一返回数据类型为json,然后前端发起Ajax请求后台数据接口 views.py def count_blog(request): # 下面等价于:select distinct auth, ...

  2. 小修改,让mvc的验证锦上添点花(1)

    首先,mvc的客户端验证用的是jquery.validate.js, jquery.validate本身已经提供了很好的扩展功能,通过简单点配置就可以做得更好看些. 而Microsoft通过jquer ...

  3. Nginx自定义扩展模块

    1. 概述 参考 Nginx开发HTTP模块入门 2. 扩展模块(假设根目录名称为nginx) nginx/configure文件中可以修改配置文件路径(编译时使用): 例如像把配置文件从默认的ngi ...

  4. VS 2015 IDE 不支持 MS SQL 2000 生成 dbml

    解决办法: 通过命令手动生成 然后把生成的ERendering.dbml 文件,通过工程项目-添加-现有项,加入项目.

  5. Mysql 索引原理《一》索引原理与慢查询1

    为何要有索引? 一般的应用系统,读写比例在10:1左右,而且插入操作和一般的更新操作很少出现性能问题,在生产环境中,我们遇到最多的,也是最容易出问题的,还是一些复杂的查询操作,因此对查询语句的优化显然 ...

  6. 在Java中如何优雅地判空

    判空灾难 ​ 作为搬砖党的一族们,我们对判空一定再熟悉不过了,不要跟我说你很少进行判空,除非你喜欢NullPointerException. 不过NullPointerException对于很多猿们来 ...

  7. “全栈2019”Java第五十四章:多态详解

    难度 初级 学习时间 10分钟 适合人群 零基础 开发语言 Java 开发环境 JDK v11 IntelliJ IDEA v2018.3 文章原文链接 "全栈2019"Java第 ...

  8. 快速启动工具Rulers 3.6

    云盘下载:https://yunpan.cn/cq7mumZ5uzzgw (提取码:b16a) 能根据已经安装的所有软件的名称快速查询到并回车迅速打开1.Alt+空格无特效或者Alt键有特效控制显示和 ...

  9. [ActionScript 3.0] 用TextField的方法getCharIndexAtPoint(x:Number, y:Number):int实现文字在固定范围内显示

    有时候我们遇到一行文字过多时必须固定文字的显示范围,但由于中英文所占字节数不一样,所以不能很好的用截取字符的方式去统一显示范围的大小,用TextField的getCharIndexAtPoint(x: ...

  10. js的常用方法和对象学习

    js的常用方法和对象学习String对象:操作字符的. 使用:字符串.函数名. 大小写转换: toUpperCase() 转换大写 toLowerCase() 转换小写 function testSt ...