理解 Golang interface

提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档

文章目录

  • 前言
  • 一、Golang interface 是什么?
  • 二、为什么有 interface?
    • 1.编写泛型算法
    • 2.隐藏具体实现
    • 3.提供拦截点(providing interception points)
    • 4.多态(polymorphism)
  • 三、非入侵式
  • 四、类型断言
  • 总结
  • 参考


前言

interface 是GO语言的基础特性之一。可以理解为一种类型的规范或者约定。它跟java,C# 不太一样,不需要显示说明实现了某个接口,它没有继承或子类或“implements”关键字,只是通过约定的形式,隐式的实现interface 中的方法即可。因此,Golang 中的 interface 让编码更灵活、易扩展。


一、Golang interface 是什么?

在 Golang 中,interface 是一种抽象的数据类型,相对于抽象类型的是具体类型(int, string 等)。interface 是一组 method 的集合,是鸭子类型(duck-type programming)的一种体现。不关心属性,只关心行为。
具体使用中可以自定义自己的 struct,并提供特定的 interface 里面的 method 就可以把它当做 interface 来使用。下面给出一种 interface 的使用示例。

// 定义接口
type MyInterface interface{
    Print()
}

func TestFunc(x MyInterface) {}
// 定义结构体
type MyStruct struct {}
// 实现接口方法
func (me MyStruct) Print() {}

func main() {
    var me MyStruct
    TestFunc(me)
}

注,鸭子类型:所谓鸭子类型说的是:只要走起路来像鸭子、叫起来也像鸭子,那么就可以把它当做鸭子。

二、为什么有 interface?

1.编写泛型算法

Go官方重磅发布了Go 1.18 beta 1版本,正式支持泛型。

那么在 Go 1.18 beta 1版本之前,可以通过使用 interface 来实现 “泛型编程”,如何实现?因为 interface 是一种抽象类型,任何具体类型(int, string)和抽象类型(user defined)都可以封装成 interface。以标准库的 sort 为例。

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:generate go run genzfunc.go

// Package sort provides primitives for sorting slices and user-defined collections.
package sort

// An implementation of Interface can be sorted by the routines in this package.
// The methods refer to elements of the underlying collection by integer index.
type Interface interface {
	// Len is the number of elements in the collection.
	Len() int

	// Less reports whether the element with index i
	// must sort before the element with index j.
	//
	// If both Less(i, j) and Less(j, i) are false,
	// then the elements at index i and j are considered equal.
	// Sort may place equal elements in any order in the final result,
	// while Stable preserves the original input order of equal elements.
	//
	// Less must describe a transitive ordering:
	//  - if both Less(i, j) and Less(j, k) are true, then Less(i, k) must be true as well.
	//  - if both Less(i, j) and Less(j, k) are false, then Less(i, k) must be false as well.
	//
	// Note that floating-point comparison (the < operator on float32 or float64 values)
	// is not a transitive ordering when not-a-number (NaN) values are involved.
	// See Float64Slice.Less for a correct implementation for floating-point values.
	Less(i, j int) bool

	// Swap swaps the elements with indexes i and j.
	Swap(i, j int)
}

...

// Sort sorts data in ascending order as determined by the Less method.
// It makes one call to data.Len to determine n and O(n*log(n)) calls to
// data.Less and data.Swap. The sort is not guaranteed to be stable.
func Sort(data Interface) {
	n := data.Len()
	quickSort(data, 0, n, maxDepth(n))
}

Sort 函数的形参是一个 interface,包含了 Len()、Less(i, j int)、Swap(i, j int) 三个方法。使用的时候不管数组的元素类型是什么(int, string …),只要实现了这三个方法就可以使用 Sort 函数,这样就实现了 “泛型编程”。
下面给出一个示例(来源)。

package main

import (
	"fmt"
	"sort"
)

type Person struct {
	Name string
	Age  int
}

func (p Person) String() string {
	return fmt.Sprintf("%s: %d", p.Name, p.Age)
}

// ByAge implements sort.Interface for []Person based on
// the Age field.
type ByAge []Person

func (a ByAge) Len() int           { return len(a) }
func (a ByAge) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a ByAge) Less(i, j int) bool { return a[i].Age < a[j].Age }

func main() {
	people := []Person{
		{"Bob", 31},
		{"John", 42},
		{"Michael", 17},
		{"Jenny", 26},
	}

	fmt.Println(people)
	// There are two ways to sort a slice. First, one can define
	// a set of methods for the slice type, as with ByAge, and
	// call sort.Sort. In this first example we use that technique.
	sort.Sort(ByAge(people))
	fmt.Println(people)

	// The other way is to use sort.Slice with a custom Less
	// function, which can be provided as a closure. In this
	// case no methods are needed. (And if they exist, they
	// are ignored.) Here we re-sort in reverse order: compare
	// the closure with ByAge.Less.
	sort.Slice(people, func(i, j int) bool {
		return people[i].Age > people[j].Age
	})
	fmt.Println(people)

}

Output:

Output:

[Bob: 31 John: 42 Michael: 17 Jenny: 26]
[Michael: 17 Jenny: 26 Bob: 31 John: 42]
[John: 42 Bob: 31 Jenny: 26 Michael: 17]

2.隐藏具体实现

比如设计一个函数给你返回一个 interface,那么你只能通过 interface 里面的方法来做一些操作,但是内部的具体实现是完全不知道的。关于 context package,参考这篇文章。

3.提供拦截点(providing interception points)

参考的文章作者说理解是装饰器,给出了下面的示例,不过没看明白…

type header struct {
    rt  http.RoundTripper
    v   map[string]string
}

func (h header) RoundTrip(r *http.Request) *http.Response {
    for k, v := range h.v {
        r.Header.Set(k,v)
    }
    return h.rt.RoundTrip(r)
}

上面代码中 http.RoundTripper 是 net/http 包里面定义的 interface。通过 interface,我们可以通过类似这种方式实现 dynamic dispatch。

4.多态(polymorphism)

同一种操作会基于多态类型表现出不同的行为。根因是多态类型可以赋值成不同的类型。在 Golang 中,interface 类比于父类,实现了 interface 就相当于子类。举个具体的例子:要实现多态,我们只需要定义一个方法或者函数可以接受不同类型的参数,然后执行各自的操作就可以了。那么代码如下。其中 PolyFunc 可以同时接受 C1 和 C2 不同类型的参数,也就相当于多态了。

type Legendtkl interface {
    Foo
}
type C1 struct{...}
func (c *C1) Foo() {...}

type C2 struct {...}
func (c *C2) Foo() {...}

// polymorphic method
func PolyFunc(x Legendtkl) {...}

三、非入侵式

比如 java 的 interface 实现,需要显式的声明,这种方式属于侵入式。

public class MyWriter implements io.Writer {}

但是在 Golang 中,interface 具有非侵入式的特性。代码示例如下:

type MyIO struct {}

func (io *MyIO) Read(p []byte) (n int, err error) {...}
func (io *MyIO) Write(p []byte) (n int, err error) {...}

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

type Writer interface {
    Write(p []byte) (n int, err error)
}

type ReadWriter interface {
    Reader
    Writer
}

四、类型断言

interface 转换为其它类型,一般称之为断言,举例:

func do(v interface{}) {
    n := v.(int)    // might panic
}

这样写的坏处在于:一旦断言失败,程序将会 panic。一种避免 panic 的写法是使用 type assertion。

func do(v interface{}) {
    n, ok := v.(int)
    if !ok {
        // 断言失败处理
    }
}

总结

interface 是 Golang 语言类型系统的基石,学习好 Golang,interface 是必要学习知识,以下再提供一些关于 interface 的学习资料。
1、6、面向对象的编程思维理解interface。
2、真的理解go interface了吗?

参考

1、深入理解 Go Interface

你可能感兴趣的:(golang,golang)