实证与虚无,抽象和具象,Go lang1.18入门精炼教程,由白丁入鸿儒,Go lang接口(interface)的使用EP08

简介: 看到接口这两个字,我们一定会联想到面向接口编程。说白了就是接口指定执行对象的具体行为,也就是接口表示让执行对象具体应该做什么,所以,普遍意义上讲,接口是抽象的,而实际执行行为,则是具象的。

看到接口这两个字,我们一定会联想到面向接口编程。说白了就是接口指定执行对象的具体行为,也就是接口表示让执行对象具体应该做什么,所以,普遍意义上讲,接口是抽象的,而实际执行行为,则是具象的。

接口(interface)的定义

在Go lang中,接口是一组方法签名,当类型为接口中的所有方法提供定义时,它被称为实现接口。和面向接口的思想非常类似,接口指定了类型应该具有的方法,类型决定了到底该怎么实现这些方法:

/* 定义接口 */  
type interface_name interface {  
   method_name1 [return_type]  
   method_name2 [return_type]  
   method_name3 [return_type]  
   ...  
   method_namen [return_type]  
}  
  
/* 定义结构体 */  
type struct_name struct {  
   /* variables */  
}  
  
/* 实现接口方法 */  
func (struct_name_variable struct_name) method_name1() [return_type] {  
   /* 方法实现 */  
}  
...  
func (struct_name_variable struct_name) method_namen() [return_type] {  
   /* 方法实现*/  
}

具体实现方式:

package main  
  
import (  
    "fmt"  
)  
  
type Phone interface {  
    call()  
}  
  
type Android struct {  
}  
  
func (android Android) call() {  
    fmt.Println("I am Android")  
}  
  
type Ios struct {  
}  
  
func (ios Ios) call() {  
    fmt.Println("I am Ios")  
}  
  
func main() {  
    var phone Phone  
  
    phone = new(Android)  
    phone.call()  
  
    phone = new(Ios)  
    phone.call()  
  
}

程序返回:

I am Android  
I am Ios

是的,现在我们可以结构体、函数、以及接口三箭齐发了,这里首先定义好手机接口,并且指定call()方法,意思是我在抽象层面拥有一个手机,手机应该具有打电话的功能。

随后分别定义结构体和函数(也是方法),分别具现化的实现接口的指定行为,精神上大家是一样的,但肉体上,一个是安卓,另一个则是苹果。

Go lang中,接口可以被任意的对象实现,同样地,一个对象也可以实现任意多个接口,任意的类型都实现了空接口(interface{}),也就是包含0个method的interface。

诚然,如果单独使用结构体,我们也可以,实现类似多态的结构:



package main  
  
import "fmt"  
  
type Human struct {  
    name  string  
    age   int  
    phone string  
}  
type Student struct {  
    Human  //匿名字段  
    school string  
    loan   float32  
}  
type Employee struct {  
    Human   //匿名字段  
    company string  
    money   float32  
} //Human实现Sayhi方法  
func (h Human) SayHi() {  
    fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)  
} //Human实现Sing方法  
func (h Human) Sing(lyrics string) {  
    fmt.Println("。。。。。。。。", lyrics)  
} //Employee重写Human的SayHi方法  
func (e Employee) SayHi() {  
    fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,  
        e.company, e.phone) //Yes you can split into 2 lines here.  
}

可以单独为结构体定义方法,但如果接口参与逻辑:

type Men interface {  
    SayHi()  
    Sing(lyrics string)  
}  
  

func main() {  
    mike := Student{Human{"Mike", 10, "1"}, "MIT", 0.00}  
    paul := Student{Human{"Paul", 20, "2"}, "Harvard", 100}  
    sam := Employee{Human{"Sam", 30, "3"}, "Golang Inc.", 1000}  
    Tom := Employee{Human{"Tom", 40, "4"}, "Things Ltd.", 5000}  
    //定义Men类型的变量i  
    var i Men  
    //i能存储Student  
    i = mike  
    fmt.Println("This is Mike, a Student:")  
    i.SayHi()  
    i.Sing("song")  
    //i也能存储Employee  
    i = Tom  
    fmt.Println("This is Tom, an Employee:")  
    i.SayHi()  
    i.Sing("song")  
    //定义了slice Men  
    fmt.Println("Let's use a slice of Men and see what happens")  
    x := make([]Men, 3)  
    //T这三个都是不同类型的元素,但是他们实现了同一个接口  
    x[0], x[1], x[2] = paul, sam, mike  
    for _, value := range x {  
        value.SayHi()  
    }  
}

程序返回:



This is Mike, a Student:  
Hi, I am Mike you can call me on 1  
。。。。。。。。 song  
This is Tom, an Employee:  
Hi, I am Tom, I work at Things Ltd.. Call me on 4  
。。。。。。。。 song  
Let's use a slice of Men and see what happens  
Hi, I am Paul you can call me on 2  
Hi, I am Sam, I work at Golang Inc.. Call me on 3  
Hi, I am Mike you can call me on 1

由此可见,接口的出现,把本来不相关的结构体类型以抽象的形式结合了起来,不同的类型实现内容不同的共性方法。

也就是说,Men接口类型的变量i,那么i里面可以存Human、Student或者Employee值,所以i是抽象的,而Human、Student或者Employee就是i的具象化操作。

接口指定函数参数

接口不仅仅可以指定无参方法,也可以指定具体的参数,让函数接受各种类型的参数:

package main  
  
import "fmt"  
  
type Human interface {  
    Len()  
}  
type Student interface {  
    Human  
}  
  
type Test struct {  
}  
  
func (h *Test) Len() {  
    fmt.Println("10个")  
}  
func main() {  
    var s Student  
    s = new(Test)  
    s.Len()  
}

程序返回:

10个

这里使用接口嵌套的形式,Human接口定义了Len方法,结构体Test实现了所有的Len接口方法,当结构体s中调用Test结构体的时候,s就相当于Python中的继承,s继承了Test,因此,s可以不用重写所有的Human接口中的方法,因为父构造器已经实现了接口。

鸭子类型(ducktyping)

什么是鸭子类型?当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子,那么这只鸟就可以被称为鸭子。

所谓远看山有色,近听水无声,春去花还在,人来鸟不惊,意象上来讲,一个事物究竟是不是某一种类型,取决于它具不具备这个类型的特性,这就是鸭子类型的本质。

所以鸭子类型主要描述事物的外部行为而非内部构造,在面向对象的编程语言中,比如Python中,一个对象有效的语义,不是由继承自特定的类或实现特定的接口,而是由"当前方法和属性的集合"决定。

编写test.py文件:

class PsyDuck():  
    def gaga(self):  
        print("这是可达鸭")  
  
  
# 使用的对象和方法  
class DoningdDuck():  
    def gaga(self):  
        print("这是唐老鸭")  
  
  
# 被调用的函数  
def duckSay(func):  
    return func.gaga()  
  
  
# 限制调用方式  
if __name__ != '__main__':  
    print("must __main__")  
  
if __name__ == "__main__":  
  
    # 实例化对象  
    duck = PsyDuck()  
    person = DoningdDuck()  
    # 调用函数  
    duckSay(duck)  
    duckSay(person)

程序返回:

这是可达鸭  
这是唐老鸭

所以到底是什么鸭子不重要,重要的是调用了谁的实例。

再来看看go lang的手笔:

package main  
  
import "fmt"  
  
//定义一个鸭子接口  
//Go 接口是一组方法的集合,可以理解为抽象的类型。它提供了一种非侵入式的接口。任何类型,只要实现了该接口中方法集,那么就属于这个类型。  
type Duck interface {  
    Gaga()  
}  
  
//假设现在有一个可达鸭类型  
type PsyDuck struct{}  
  
//可达鸭声明方法-满足鸭子会嘎嘎叫的特性  
func (pd PsyDuck) Gaga() {  
    fmt.Println("this is PsyDuck")  
}  
  
//假设现在有一个唐老鸭类型  
type DonaldDuck struct{}  
  
//唐老鸭声明方法-满足鸭子会嘎嘎叫的特性  
func (dd DonaldDuck) Gaga() {  
    fmt.Println("this is DoningdDuck")  
}  
  
//要调用的函数 - 负责执行鸭子能做的事情,注意这里的参数,有类型限制为Duck接口  
func DuckSay(d Duck) {  
    d.Gaga()  
}  
  
func main() {  
    //提示开始打印  
    fmt.Println("duck typing")  
  
    //实例化对象  
    var pd PsyDuck    //可达鸭类型  
    var dd DonaldDuck //唐老鸭类型  
  
    //调用方法  
    DuckSay(pd) //因为可达鸭实现了所有鸭子的函数,所以可以这么用  
    DuckSay(dd) //因为唐老鸭实现了所有鸭子的函数,所以可以这么用  
}

程序返回:

duck typing  
this is PsyDuck  
this is DoningdDuck

这里首先定义抽象的鸭子接口,指定gaga方法,不同的结构体:可达鸭、唐老鸭分别绑定并且实现了鸭子接口的方法,然后声明一个调用函数,在执行的时候,将结构体变量传递给调用函数,动态地实现了不同类型的方法。

结语

所谓接口(interface)的抽象性,就是从表面看到本质,从片面看到整体,然后抽出那些稳定的、共有的特性。平时我们会考虑代码的重用性,组件的复用性,同一个功能对不同场景的复用性,有了复用的能力,就能够用更少的开发去满足更多场景的同类需求问题。从而能够从一个具体的需求,看到一类的需求,看到衍生的相关的需求,甚至再对需求进行分类,看到更高层面的需求。进而才能够系统性解决同类的需求而不是就事论事点对点解决问题。

所以,总的来说,接口的极致就是抽象,而抽象的极致,则是格局,接口,可以更好的帮我们扩大程序视野的格局。

相关文章
|
9天前
|
监控 算法 Go
Golang深入浅出之-Go语言中的服务熔断、降级与限流策略
【5月更文挑战第4天】本文探讨了分布式系统中保障稳定性的重要策略:服务熔断、降级和限流。服务熔断通过快速失败和暂停故障服务调用来保护系统;服务降级在压力大时提供有限功能以保持整体可用性;限流控制访问频率,防止过载。文中列举了常见问题、解决方案,并提供了Go语言实现示例。合理应用这些策略能增强系统韧性和可用性。
65 0
|
9天前
|
JavaScript 前端开发 Go
Go语言的入门学习
【4月更文挑战第7天】Go语言,通常称为Golang,是由Google设计并开发的一种编程语言,它于2009年公开发布。Go的设计团队主要包括Robert Griesemer、Rob Pike和Ken Thompson,这三位都是计算机科学和软件工程领域的杰出人物。
19 1
|
9天前
|
分布式计算 Java Go
Golang深入浅出之-Go语言中的分布式计算框架Apache Beam
【5月更文挑战第6天】Apache Beam是一个统一的编程模型,适用于批处理和流处理,主要支持Java和Python,但也提供实验性的Go SDK。Go SDK的基本概念包括`PTransform`、`PCollection`和`Pipeline`。在使用中,需注意类型转换、窗口和触发器配置、资源管理和错误处理。尽管Go SDK文档有限,生态系统尚不成熟,且性能可能不高,但它仍为分布式计算提供了可移植的解决方案。通过理解和掌握Beam模型,开发者能编写高效的数据处理程序。
142 1
|
9天前
|
缓存 测试技术 持续交付
Golang深入浅出之-Go语言中的持续集成与持续部署(CI/CD)
【5月更文挑战第5天】本文介绍了Go语言项目中的CI/CD实践,包括持续集成与持续部署的基础知识,常见问题及解决策略。测试覆盖不足、版本不一致和构建时间过长是主要问题,可通过全面测试、统一依赖管理和利用缓存优化。文中还提供了使用GitHub Actions进行自动化测试和部署的示例,强调了持续优化CI/CD流程以适应项目需求的重要性。
57 1
|
9天前
|
Kubernetes Cloud Native Go
Golang深入浅出之-Go语言中的云原生开发:Kubernetes与Docker
【5月更文挑战第5天】本文探讨了Go语言在云原生开发中的应用,特别是在Kubernetes和Docker中的使用。Docker利用Go语言的性能和跨平台能力编写Dockerfile和构建镜像。Kubernetes,主要由Go语言编写,提供了方便的客户端库与集群交互。文章列举了Dockerfile编写、Kubernetes资源定义和服务发现的常见问题及解决方案,并给出了Go语言构建Docker镜像和与Kubernetes交互的代码示例。通过掌握这些技巧,开发者能更高效地进行云原生应用开发。
63 1
|
9天前
|
负载均衡 监控 Go
Golang深入浅出之-Go语言中的服务网格(Service Mesh)原理与应用
【5月更文挑战第5天】服务网格是处理服务间通信的基础设施层,常由数据平面(代理,如Envoy)和控制平面(管理配置)组成。本文讨论了服务发现、负载均衡和追踪等常见问题及其解决方案,并展示了使用Go语言实现Envoy sidecar配置的例子,强调Go语言在构建服务网格中的优势。服务网格能提升微服务的管理和可观测性,正确应对问题能构建更健壮的分布式系统。
31 1
|
9天前
|
消息中间件 Go API
Golang深入浅出之-Go语言中的微服务架构设计与实践
【5月更文挑战第4天】本文探讨了Go语言在微服务架构中的应用,强调了单一职责、标准化API、服务自治和容错设计等原则。同时,指出了过度拆分、服务通信复杂性、数据一致性和部署复杂性等常见问题,并提出了DDD拆分、使用成熟框架、事件驱动和配置管理与CI/CD的解决方案。文中还提供了使用Gin构建HTTP服务和gRPC进行服务间通信的示例。
34 0
|
9天前
|
Prometheus 监控 Cloud Native
Golang深入浅出之-Go语言中的分布式追踪与监控系统集成
【5月更文挑战第4天】本文探讨了Go语言中分布式追踪与监控的重要性,包括追踪的三个核心组件和监控系统集成。常见问题有追踪数据丢失、性能开销和监控指标不当。解决策略涉及使用OpenTracing或OpenTelemetry协议、采样策略以及聚焦关键指标。文中提供了OpenTelemetry和Prometheus的Go代码示例,强调全面可观测性对微服务架构的意义,并提示选择合适工具和策略以确保系统稳定高效。
149 5
|
9天前
|
负载均衡 算法 Go
Golang深入浅出之-Go语言中的服务注册与发现机制
【5月更文挑战第4天】本文探讨了Go语言中服务注册与发现的关键原理和实践,包括服务注册、心跳机制、一致性问题和负载均衡策略。示例代码演示了使用Consul进行服务注册和客户端发现服务的实现。在实际应用中,需要解决心跳失效、注册信息一致性和服务负载均衡等问题,以确保微服务架构的稳定性和效率。
23 3
|
9天前
|
前端开发 Go
Golang深入浅出之-Go语言中的异步编程与Future/Promise模式
【5月更文挑战第3天】Go语言通过goroutines和channels实现异步编程,虽无内置Future/Promise,但可借助其特性模拟。本文探讨了如何使用channel实现Future模式,提供了异步获取URL内容长度的示例,并警示了Channel泄漏、错误处理和并发控制等常见问题。为避免这些问题,建议显式关闭channel、使用context.Context、并发控制机制及有效传播错误。理解并应用这些技巧能提升Go语言异步编程的效率和健壮性。
30 5
Golang深入浅出之-Go语言中的异步编程与Future/Promise模式