声明接口类型
接口是一种抽象类型。
接口描述方法集的所有方法，并为每个方法提供签名。
若要创建接口，请使用interface关键字，后跟包含方法名称列表的大括号，以及方法应具有的任何参数或返回值。
// Declare an Interface Type and methods does not have a body
type Employee interface {
PrintName() string // Method with string return type
PrintAddress(id int) // Method with int parameter
PrintSalary(b int, t int) float64 // Method with parameters and return type
}接口充当方法集的蓝图，它们必须在使用之前实现。满足接口的类型即实现该接口。
定义满足接口的类型
使用两种方法定义名为Employee的接口类型。然后，它定义一个名为Emp的类型，该类型满足员工。
我们在Emp上定义了满足员工所需的所有方法
package main
import "fmt"
// 声明接口
type Employee interface {
PrintName(name string)
PrintSalary(basic int, tax int) int
}
// Emp用户自定义类型
type Emp int
// 实现接口方法
func (e Emp) PrintName(name string) {
fmt.Println("Employee Id:\t", e)
fmt.Println("Employee Name:\t", name)
}
// 实现接口方法
func (e Emp) PrintSalary(basic int, tax int) int {
var salary = (basic * tax) / 100
return basic - salary
}
func main() {
var e1 Employee
e1 = Emp(1)
e1.PrintName("John Doe")
fmt.Println("Employee Salary:", e1.PrintSalary(25000, 5))
}如果一个类型具有接口中声明的所有方法，则不需要进一步的声明来显式表示Emp满足 Employee。
声明一个以Employee作为其类型的e1变量，然后创建一个Emp值并将其分配给 e1。
定义满足多个接口的类型
接口允许任何用户定义类型同时满足多种接口类型。
使用类型断言，您可以获取具体类型的值，并且可以调用在其他接口上定义的方法，但不是满足接口的一部分。
package main
import "fmt"
type Polygons interface {
Perimeter()
}
type Object interface {
NumberOfSide()
}
type Pentagon int
func (p Pentagon) Perimeter() {
fmt.Println("Perimeter of Pentagon", 5*p)
}
func (p Pentagon) NumberOfSide() {
fmt.Println("Pentagon has 5 sides")
}
func main() {
var p Polygons = Pentagon(50)
p.Perimeter()
var o Pentagon = p.(Pentagon)
o.NumberOfSide()
var obj Object = Pentagon(50)
obj.NumberOfSide()
var pent Pentagon = obj.(Pentagon)
pent.Perimeter()
}当用户定义类型实现接口类型声明的方法集时，可以将用户定义类型的值分配给接口类型的值。此赋值将用户定义类型的值存储到接口值中。对接口值进行方法调用时，将执行存储的用户定义值的等效方法。由于任何用户定义类型都可以实现任何接口，因此针对接口值的方法调用本质上是多态的。此关系中的用户定义类型通常称为具体类型。
通用方法接口
两个或多个接口可以在方法集列表中具有一个或多个常用方法。在这里，Structure是Vehicle和Human两个界面之间的常用方法。
package main
import "fmt"
type Vehicle interface {
Structure() []string // Common Method
Speed() string
}
type Human interface {
Structure() []string // Common Method
Performance() string
}
type Car string
func (c Car) Structure() []string {
var parts = []string{"ECU", "Engine", "Air Filters", "Wipers", "Gas Task"}
return parts
}
func (c Car) Speed() string {
return "200 Km/Hrs"
}
type Man string
func (m Man) Structure() []string {
var parts = []string{"Brain", "Heart", "Nose", "Eyelashes", "Stomach"}
return parts
}
func (m Man) Performance() string {
return "8 Hrs/Day"
}
func main() {
var bmw Vehicle
bmw = Car("World Top Brand")
var labour Human
labour = Man("Software Developer")
for i, j := range bmw.Structure() {
fmt.Printf("%-15s <=====> %15s\n", j, labour.Structure()[i])
}
}输出
ECU <=====> Brain
Engine <=====> Heart
Air Filters <=====> Nose
Wipers <=====> Eyelashes
Gas Task <=====> Stomach接受变量地址的接口
Print()方法接受接收器指针。因此，接口还必须接受接收器指针。
如果方法接受类型值，则接口必须接收类型值;如果方法具有指针接收器，则接口必须接收相应类型的变量的地址。
package main
import "fmt"
type Book struct {
author, title string
}
type Magazine struct {
title string
issue int
}
func (b *Book) Assign(n, t string) {
b.author = n
b.title = t
}
func (b *Book) Print() {
fmt.Printf("Author: %s, Title: %s\n", b.author, b.title)
}
func (m *Magazine) Assign(t string, i int) {
m.title = t
m.issue = i
}
func (m *Magazine) Print() {
fmt.Printf("Title: %s, Issue: %d\n", m.title, m.issue)
}
type Printer interface {
Print()
}
func main() {
var b Book
var m Magazine
b.Assign("Jack Rabbit", "Book of Rabbits")
m.Assign("Rabbit Weekly", 26)
var i Printer
fmt.Println("Call interface")
i = &b
i.Print()
i = &m
i.Print()
}空接口类型
类型接口{}称为空接口，它用于接受任何类型的值。空接口没有任何满足它所需的方法，因此每种类型都满足它。
package main
import "fmt"
func printType(i interface{}) {
fmt.Println(i)
}
func main() {
var manyType interface{}
manyType = 100
fmt.Println(manyType)
manyType = 200.50
fmt.Println(manyType)
manyType = "Germany"
fmt.Println(manyType)
printType("Go programming language")
var countries = []string{"india", "japan", "canada", "australia", "russia"}
printType(countries)
var employee = map[string]int{"Mark": 10, "Sandy": 20}
printType(employee)
country := [3]string{"Japan", "Australia", "Germany"}
printType(country)
}manyType变量被声明为类型接口 {}，并且能够为其分配不同类型的值。printType()函数采用类型接口{}的参数，因此该函数可以采用任何有效类型的值。
输出
100
200.5
Germany
Go programming language
[india japan canada australia russia]
map[Mark:10 Sandy:20]
[Japan Australia Germany]多态性
多态性是编写代码的能力，这些代码可以通过类型实现来承担不同的行为。
我们声明了一个名为五边形、六边形、八边形和十边形的结构，其中包含Geometry接口的实现。
package main
import (
"fmt"
)
type Geometry interface {
Edges() int
}
type Pentagon struct{}
type Hexagon struct{}
type Octagon struct{}
type Decagon struct{}
func (p Pentagon) Edges() int { return 5 }
func (h Hexagon) Edges() int { return 6 }
func (o Octagon) Edges() int { return 8 }
func (d Decagon) Edges() int { return 10 }
func Parameter(geo Geometry, value int) int {
num := geo.Edges()
calculation := num * value
return calculation
}
func main() {
p := new(Pentagon)
h := new(Hexagon)
o := new(Octagon)
d := new(Decagon)
g := [...]Geometry{p, h, o, d}
for _, i := range g {
fmt.Println(Parameter(i, 5))
}
}
输出
25
30
40
50我们有多态Edges()函数，它接受实现Geometry接口的值。使用多态方法，Parameter()使用传入的每个具体类型值。
接口嵌入
接口可以嵌入其他接口，此行为是接口多态性的一个方面，称为临时多态性。
package main
import "fmt"
type Geometry interface {
Edges() int
}
type Polygons interface {
Geometry // 嵌入接口
}
type Pentagon int
type Hexagon int
type Octagon int
type Decagon int
func (p Pentagon) Edges() int { return 5 }
func (h Hexagon) Edges() int { return 6 }
func (o Octagon) Edges() int { return 8 }
func (d Decagon) Edges() int { return 10 }
func main() {
p := new(Pentagon)
h := new(Hexagon)
o := new(Octagon)
d := new(Decagon)
polygons := [...]Polygons{p, h, o, d}
for i := range polygons {
fmt.Println(polygons[i].Edges())
}
}当一种类型嵌入到另一种类型中时，嵌入类型的方法可用于嵌入类型。嵌入式接口的方法可供嵌入接口访问。