[golang note] 接口使用

时间 2019-11-11

标签 golang note 接口使用栏目 Go 繁體版

原文原文链接

侵入式接口

√ 在其余一些编程语言中，接口主要是做为不一样组件之间的契约存在，即规定双方交互的规约。java

√ 对契约的实现是强制的，即必须确保用户的确实现了该接口，而实现一个接口，须要从该接口继承。ios

√ 若是一个类实现了接口A，即使另外一个接口B与A的方法列表相同，甚至链接口名都相同，但位于不一样的命名空间下，那么编译器并不认为这两个接口是同样的。c++

√ 所谓侵入的主要表如今于实现继承接口的类须要明确声明本身实现自某个接口。golang

√ 侵入式接口常纠结的问题是：应该提供哪些接口好呢？若是两个类实现了相同的接口，应该把接口放到哪一个包好呢？编程

• c++接口示例

#include <string>
#include <iostream>
using namespace std;

class IPerson
{
public:
    IPerson() {}
    virtual ~IPerson() {}

public:
    virtual void          SetName(const string &name) = 0;
    virtual const string &GetName()                   = 0;
    virtual void          Work()                      = 0;
};

class Teacher : public IPerson
{
private:
    string m_Name;

public:
    Teacher() : m_Name("") {}
    virtual ~Teacher() {}

public:
    virtual void SetName(const string &name)
    {
        m_Name = name;
    }

    virtual const string &GetName()
    {
        return m_Name;
    }

    virtual void Work()
    {
        cout << "I'm a teacher" << endl;
    }
};

int main()
{
    IPerson *p = ::new Teacher;
    p->SetName("chris");
    p->Work();
    cout << p->GetName() << endl;
    delete p;
    return 1;
}

• java接口示例

非侵入式接口

√ 在golang中，一个类只须要实现了某个接口中的全部函数，咱们就说这个类实现了该接口。编程语言

√ 在golang中，一个类不须要继承于接口，也不须要知道有哪些接口的存在。函数

√ 在golang中，接口和类之间再也不有所谓的契约关系，所以实现类的时候，只须要关心本身应该提供哪些方法，不用再纠结接口须要拆得多细才合理。接口由使用方按需定义，而不用事前规划，也不须要绘制类库的继承树图。spa

√ 在golang中，不用为了实现一个接口而导入一个包，由于多引用一个外部的包，就意味着更多的耦合。接口由使用方按自身需求来定义，使用方无需关心是否有其余模块定义过相似的接口。code

• 接口赋值

▶ 对象实例赋值给接口

▪ 语法以下

// 接口定义
type IMyInterface1 interface {
    Func1(参数列表) (返回值列表)
    Func2(参数列表) (返回值列表)
    Func3(参数列表) (返回值列表)
}

type IMyInterface2 interface {
    Func1(参数列表) (返回值列表)
}

// 类定义
type MyClass struct {
    // 成员变量
}

func (p *MyClass) Func1(参数列表) (返回值列表) {
    // 函数体
}

func (p *MyClass) Func2(参数列表) (返回值列表) {
    // 函数体
}

func (p *MyClass) Func3(参数列表) (返回值列表) {
    // 函数体
}

func (p *MyClass) Func4(参数列表) (返回值列表) {
    // 函数体
}

// 接口赋值
var myInterface1 IMyInterface1 = new(MyClass)
var myInterface2 IMyInterface2 = new(MyClass)

// 接口调用
myInterface1.Func1(参数列表)
myInterface1.Func2(参数列表)
myInterface1.Func3(参数列表)

myInterface2.Func1(参数列表)

▪ 示例以下

package main

import "fmt" type IMyInterface1 interface {
    Func1() bool
    Func2() bool
    Func3() bool
}

type IMyInterface2 interface {
    Func1() bool
}

type MyClass struct {
}

func (p *MyClass) Func1() bool {
    fmt.Println("MyClass.Func1()")
    return true
}

func (p *MyClass) Func2() bool {
    fmt.Println("MyClass.Func2()")
    return true
}

func (p *MyClass) Func3() bool {
    fmt.Println("MyClass.Func3()")
    return true
}

func (p *MyClass) Func4() bool {
    fmt.Println("MyClass.Func4()")
    return true
}

func main() {
    var myInterface1 IMyInterface1 = new(MyClass) var myInterface2 IMyInterface2 = new(MyClass)

    myInterface1.Func1() // MyClass.Func1()
    myInterface1.Func2() // MyClass.Func2()
    myInterface1.Func3() // MyClass.Func3()

    myInterface2.Func1() // MyClass.Func1()
}

▶ 接口之间赋值

√ 在golang中，只要两个接口拥有相同的方法列表，那么它们就是等同的，能够相互赋值。对象

√ 在golang中，等同的接口能够分布在不一样的包中，包并非判断接口是否等同的条件之一。

√ 在golang中，接口赋值并不要求两个接口必须等价。若是接口A的方法列表是接口B的方法列表的子集，那么接口B是能够赋值给接口A，可是反过来不成立。

▪ 语法以下

// 接口定义
type IMyInterface1 interface {
    Func1(参数列表) (返回值列表)
    Func2(参数列表) (返回值列表)
}

type IMyInterface2 interface {
    Func1(参数列表) (返回值列表)
    Func2(参数列表) (返回值列表)
}

// 类定义
type MyClass struct {
    // 成员变量
}

func (p *MyClass) Func1(参数列表) (返回值列表) {
    // 函数体
}

func (p *MyClass) Func2(参数列表) (返回值列表) {
    // 函数体
}

func (p *MyClass) Func3(参数列表) (返回值列表) {
    // 函数体
}

// 接口赋值
var myInterface1 IMyInterface1 = new(MyClass)
var myInterface2 IMyInterface2 = myInterface1

// 接口调用
myInterface1.Func1(参数列表)
myInterface1.Func2(参数列表)

myInterface2.Func1(参数列表)
myInterface2.Func2(参数列表)

▪ 示例以下

package main

import "fmt" type IMyInterface1 interface {
    Func1() bool
    Func2() bool
}

type IMyInterface2 interface {
    Func1() bool
    Func2() bool
}

type IMyInterface3 interface {
    Func1() bool
}

type MyClass struct {
}

func (p *MyClass) Func1() bool {
    fmt.Println("MyClass.Func1()")
    return true
}

func (p *MyClass) Func2() bool {
    fmt.Println("MyClass.Func2()")
    return true
}

func (p *MyClass) Func3() bool {
    fmt.Println("MyClass.Func3()")
    return true
}

func main() {
    var myInterface1 IMyInterface1 = new(MyClass)
    var myInterface2 IMyInterface2 = myInterface1 // 等同接口
    var myInterface3 IMyInterface3 = myInterface2 // 子集接口

    myInterface1.Func1() // MyClass.Func1()
    myInterface1.Func2() // MyClass.Func2()

    myInterface2.Func1() // MyClass.Func1()
    myInterface2.Func2() // MyClass.Func2()

    myInterface3.Func1() // MyClass.Func1()
}

• 接口查询

▶ 接口查询

√ 接口查询功能一：检查接口A指向的对象实例O是否实现了接口B，若是是则执行特定的代码。

√ 接口查询功能二：检查接口A指向的对象实例O是不是类型T，若是是则执行特定的代码。

√ 接口查询是运行期行为，编译器编译期不能肯定。

▪ 语法以下

// 接口定义
type IMyInterface1 interface {
    // 函数列表
}

type IMyInterface2 interface {
    // 函数列表
}

// 类定义
type MyClass struct {
    // 成员变量
}

// 接口赋值
var myInterface1 IMyInterface1 = new(MyClass)

// 查询myInterface1指向的对象实例是否实现了IMyInterface2类型接口，若是实现，返回的myInterface2是指向对象的IMyInterface2类型接口实例
if myInterface2, ok := myInterface1.(IMyInterface2); ok {
    // 查询成功，myInterface2为IMyInterface2类型接口实例
}

// 查询myInterface1指向的对象是不是MyClass类型实例，若是是，返回的myInstance是指向该对象的实例
if myInstance, ok := myInterface1.(*MyClass); ok{
    // 查询成功，myInstance为myInterface1指向的对象实例
}

▪ 示例以下

package main

import (
    "fmt"
)

type IMyInterface1 interface {
    Func1() bool Func2() bool
}

type IMyInterface2 interface {
    Func1() bool
}

type MyClass struct {
    Width, Height float64
}

func (p *MyClass) Func1() bool {
    fmt.Println("MyClass.Func1() - Width =", p.Width)
    return true
}

func (p *MyClass) Func2() bool {
    fmt.Println("MyClass.Func2() - Height =", p.Height)
    return true
}

func main() {
    var myInterface1 IMyInterface1 = &MyClass{100, 200}

    if myInterface2, ok := myInterface1.(IMyInterface2); ok {
        myInterface2.Func1() // MyClass.Func1() - Width = 100
    }

    if myInstance, ok := myInterface1.(*MyClass); ok {
        myInstance.Func1()             // MyClass.Func1() - Width = 100
        myInstance.Func2()             // MyClass.Func2() - Height = 200
        fmt.Println(myInstance.Width)  // 100
        fmt.Println(myInstance.Height) // 200
    }
}

▶ 类型查询

▪ 空接口：Any类型

√ golang中空接口interface{}能够指向任何对象实例。

√ golang中空接口interface{}看起来像是能够指向任何对象的Any类型，相似于COM中的IUnknown。

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var v1 interface{} = 1
    var v2 interface{} = "abc"
    var v3 interface{} = &v2
    var v4 interface{} = struct{ X int }{1}
    var v5 interface{} = &struct{ X int }{1}

    fmt.Println(reflect.TypeOf(v1)) // int
    fmt.Println(reflect.TypeOf(v2)) // string
    fmt.Println(reflect.TypeOf(v3)) // *interface {}
    fmt.Println(reflect.TypeOf(v4)) // struct { X int }
    fmt.Println(reflect.TypeOf(v5)) // *struct { X int }
}

▪ 类型查询语法

√ golang中使用type switch语句能够查询接口指向对象的真实数据类型。

var v interface{} = obj
switch instance := v.(type) { // 返回的instance是指向接口v指向的对象 case int:
        ...
    case string:
        ...
    ...
    default:
}

▪ 类型查询示例

package main

import (
    "fmt"
)

type Stringer interface {
    String() string
}

type MyString struct {
    content string
}

func (str *MyString) String() string {
    return str.content
}

func PrintString(args ...interface{}) {
    for _, arg := range args {
        switch instance := arg.(type) {
        case string:
            fmt.Println(instance)
        default:
            if v, ok := arg.(Stringer); ok { // 若是对象具备Stringer接口
                fmt.Println(v.String())
            } else { // 不能打印的非字符串类型
                fmt.Println("unexpected string type")
            }
        }
    }
}

func main() {
    PrintString("abc")              // abc
    PrintString(&MyString{"hello"}) // hello
    PrintString(123)                // unexpected string type
}

• 接口组合

√ 相似struct的匿名组合，golang也为接口提供了继承机制，即接口也能够匿名组合，只不过接口只包含方法，而不包含任何成员变量。

√ 接口组合与其余高级编程语言中的表现一致，即接口A能够被另外一个接口B继承，造成接口继承体系。

▶ 基本语法

type MyInterface1 interface {
    // 函数列表
}

type MyInterface2 interface {
    MyInterface1 // 函数列表
}

▶ 继承规则

√ 匿名组合的接口不可拥有同名函数，不然将给出错误：duplicate method XXXX

▪ 示例以下

package main

import (
    "fmt"
)

type MyInterface1 interface {
    Func1() bool
}

type MyInterface2 interface {
    //Func1() bool // duplicate method Func1
    Func2() bool
}

type MyInterface3 interface {
    MyInterface1
    MyInterface2 //Func1() bool // duplicate method Func1
    Func3() bool
}

type MyClass struct {
}

func (p *MyClass) Func1() bool {
    fmt.Println("MyClass.Func1()")
    return true
}

func (p *MyClass) Func2() bool {
    fmt.Println("MyClass.Func2()")
    return true
}

func (p *MyClass) Func3() bool {
    fmt.Println("MyClass.Func3()")
    return true
}

func main() {
    var myInterface3 MyInterface3 = new(MyClass)
    myInterface3.Func1() // MyClass.Func1()
    myInterface3.Func2() // MyClass.Func2()
    myInterface3.Func3() // MyClass.Func3()
}