golang interface指针实现
在 Go 语言中,接口(interface)是一种类型,它定义了一组方法的集合。任何实现了接口中所有方法的类型都会自动满足该接口。当涉及到指针接收者时,情况会稍微复杂一些,因为需要考虑到值接收者和指针接收者之间的区别。
下面是一个简单的例子,说明了如何使用指针来实现一个接口:
package main
import "fmt"
// 定义一个接口,包含一个方法 SayHello
type Greeter interface {
SayHello() string
}
// 定义一个结构体 Person
type Person struct {
name string
}
// 使用指针接收者实现接口中的 SayHello 方法
func (p *Person) SayHello() string {
return fmt.Sprintf("Hello, my name is %s", p.name)
}
func main() {
// 创建一个 Person 实例,并通过指针赋值给一个变量
p := &Person{"John Doe"}
// 将 Person 的指针赋给 Greeter 接口类型的变量
var g Greeter = p
// 调用接口方法
fmt.Println(g.SayHello())
}
在这个例子中,Person
结构体有一个字段 name
和一个方法 SayHello()
。这个方法使用了一个指针接收者,这意味着它可以在方法内部修改 Person
的状态(如果需要的话)。Greeter
接口定义了一个方法 SayHello()
,Person
类型通过其指针实现了这个接口。
当你创建一个 Person
类型的对象并将其地址赋给 Greeter
接口变量时,你可以通过接口调用 SayHello()
方法,Go 会自动调用正确的实现。
需要注意的是,如果你的方法使用了值接收者,那么它不能改变接收者的状态,因此可能无法满足某些接口的要求,尤其是当接口预期可以修改对象状态时。
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
在 Go 语言中,接口(interface)是一种定义行为的方式,它允许不同的类型实现一组特定的方法。当一个类型实现了接口中的所有方法时,这个类型就自动实现了该接口,不需要显式声明。
如果接口中的方法接收者是类型 T
的指针,那么任何实现了相同签名方法的 T
类型的指针都将实现该接口。下面是一个简单的示例来说明这一点:
package main
import "fmt"
// 定义一个接口,其方法接收者为 MyType 的指针
type MyInterface interface {
DoSomething()
}
// 定义一个结构体
type MyType struct {
Value int
}
// 实现接口中的方法
func (m *MyType) DoSomething() {
fmt.Println("Doing something with value:", m.Value)
}
func main() {
// 创建 MyType 的实例,并使用其指针
myInstance := &MyType{Value: 42}
// 因为 *MyType 实现了 MyInterface,所以可以将 *MyType 赋值给 MyInterface 类型的变量
var inter MyInterface = myInstance
// 调用接口中的方法
inter.DoSomething()
}
在这个例子中,MyInterface
接口包含一个名为 DoSomething
的方法,其接收者是 MyType
的指针。MyType
结构体通过提供一个名为 DoSomething
的方法(以它的指针接收者)实现了 MyInterface
接口。因此,你可以创建一个 MyType
的指针,并将其赋值给 MyInterface
类型的变量,然后调用接口中的方法。
注意,如果 DoSomething
方法的接收者是值类型的 MyType
而不是指针类型的 *MyType
,则你只能使用 MyType
的值类型来实现该接口,而不能使用其指针类型。反之亦然。
上一篇: 3款自己电脑就可以运行AI LLM的项目-LocalGPT
下一篇: 多周期路径的约束与设置原则
推荐阅读
-
使用Golang实现WebSocket心跳功能的包
-
OpenIM自创指南:C/C++如何调用并实现Golang函数的双向通信
-
在 Golang 中实现 AK/SK 认证:基础入门与概念解读
-
在 Golang 中,使用 os.OpenFile 实现文件的追加写入操作:fileName, O_APPEND | O_WRONLY, ModeAppend 的应用示解
-
探索JPDA架构第六部分:Agent通过环境指针在VM中实现线程管理操作
-
Golang | Leetcode Golang 问题解决 #232 使用堆栈实现队列 - 问题解决:
-
异步编程RxJava-介绍-前言 前段时间写了一篇对协程的一些理解,里面提到了不管是协程还是callback,本质上其实提供的是一种异步无阻塞的编程模式;并且介绍了java中对异步无阻赛这种编程模式的支持,主要提到了Future和CompletableFuture;之后有同学在下面留言提到了RxJava,刚好最近在看微服务设计这本书,里面提到了响应式扩展(Reactive extensions,Rx),而RxJava是Rx在JVM上的实现,所有打算对RxJava进一步了解。 RxJava简介 RxJava的官网地址:https://github.com/ReactiveX/RxJava, 其中对RxJava进行了一句话描述:RxJava – Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java VM. 大意就是:一个在Java VM上使用可观测的序列来组成异步的、基于事件的程序的库。 更详细的说明在Netflix技术博客的一篇文章中描述了RxJava的主要特点: 1.易于并发从而更好的利用服务器的能力。 2.易于有条件的异步执行。 3.一种更好的方式来避免回调地狱。 4.一种响应式方法。 与CompletableFuture对比 之前提到CompletableFuture真正的实现了异步的编程模式,一个比较常见的使用场景: CompletableFuture<Integer> future = CompletableFuture.supplyAsync(耗时函数); Future<Integer> f = future.whenComplete((v, e) -> { System.out.println(v); System.out.println(e); }); System.out.println("other..."); 下面用一个简单的例子来看一下RxJava是如何实现异步的编程模式: Observable<Long> observable = Observable.just(1, 2) .subscribeOn(Schedulers.io).map(new Func1<Integer, Long> { @Override public Long call(Integer t) { try { Thread.sleep(1000); //耗时的操作 } catch (InterruptedException e) { e.printStackTrace; } return (long) (t * 2); } }); observable.subscribe(new Subscriber<Long> { @Override public void onCompleted { System.out.println("onCompleted"); } @Override public void onError(Throwable e) { System.out.println("error" + e); } @Override public void onNext(Long result) { System.out.println("result = " + result); } }); System.out.println("other..."); Func1中以异步的方式执行了一个耗时的操作,Subscriber(观察者)被订阅到Observable(被观察者)中,当耗时操作执行完会回调Subscriber中的onNext方法。 其中的异步方式是在subscribeOn(Schedulers.io)中指定的,Schedulers.io可以理解为每次执行耗时操作都启动一个新的线程。 结构上其实和CompletableFuture很像,都是异步的执行一个耗时的操作,然后在有结果的时候主动告诉我结果。那我们还需要RxJava干嘛,不知道你有没有注意,上面的例子中其实提供2条数据流[1,2],并且处理完任何一个都会主动告诉我,当然这只是它其中的一项功能,RxJava还有很多好用的功能,在下面的内容会进行介绍。 异步观察者模式 上面这段代码有没有发现特别像设计模式中的:观察者模式;首先提供一个被观察者Observable,然后把观察者Subscriber添加到了被观察者列表中; RxJava中一共提供了四种角色:Observable、Observer、Subscriber、Subjects Observables和Subjects是两个被观察者,Observers和Subscribers是观察者; 当然我们也可以查看一下源码,看一下jdk中的Observer和RxJava的Observer jdk中的Observer: public interface Observer { void update(Observable o, Object arg); } RxJava的Observer: public interface Observer<T> { void onCompleted; void onError(Throwable e); void onNext(T t); } 同时可以发现Subscriber是implements Observer的: public abstract class Subscriber<T> implements Observer<T>, Subscription 可以发现RxJava中在Observer中引入了2个新的方法:onCompleted和onError onCompleted:即通知观察者Observable没有更多的数据,事件队列完结 onError:在事件处理过程中出异常时,onError会被触发,同时队列自动终止,不允许再有事件发出。 正是因为RxJava提供了同步和异步两种方式进行事件的处理,个人觉得异步的方式更能体现RxJava的价值,所以这里给他命名为异步观察者模式。 好了,下面正式介绍RxJava的那些灵活的操作符,这里仅仅是简单的介绍和简单的实例,具体用在什么场景下,会在以后的文章中介绍 Maven引入
-
golang interface指针实现
-
[原创]最简单的通过C语言实现的国密SM4算法(无指针无结构,最明显易懂)--总结
-
go语言Socket编程-Socket编程 什么是Socket Socket,英文含义是插座、插孔,一般称之为套接字,用于描述IP地址和端口。可以实现不同程序间的数据通信。 Socket起源于Unix,而Unix基本哲学之一就是“一切皆文件”,都可以用“打开open –> 读写write/read –> 关闭close”模式来操作。Socket就是该模式的一个实现,网络的Socket数据传输是一种特殊的I/O,Socket也是一种文件描述符。Socket也具有一个类似于打开文件的函数调用:Socket,该函数返回一个整型的Socket描述符,随后的连接建立、数据传输等操作都是通过该Socket实现的。 套接字的内核实现较为复杂,不宜在学习初期深入学习,了解到如下结构足矣。 套接字通讯原理示意 在TCP/IP协议中,“IP地址+TCP或UDP端口号”唯一标识网络通讯中的一个进程。“IP地址+端口号”就对应一个socket。欲建立连接的两个进程各自有一个socket来标识,那么这两个socket组成的socket pair就唯一标识一个连接。因此可以用Socket来描述网络连接的一对一关系。 常用的Socket类型有两种:流式Socket(SOCK_STREAM)和数据报式Socket(SOCK_DGRAM)。流式是一种面向连接的Socket,针对于面向连接的TCP服务应用;数据报式Socket是一种无连接的Socket,对应于无连接的UDP服务应用。 网络应用程序设计模式 C/S模式 传统的网络应用设计模式,客户机(client)/服务器(server)模式。需要在通讯两端各自部署客户机和服务器来完成数据通信。 B/S模式 浏览器(Browser)/服务器(Server)模式。只需在一端部署服务器,而另外一端使用每台PC都默认配置的浏览器即可完成数据的传输。 优缺点 对于C/S模式来说,其优点明显。客户端位于目标主机上可以保证性能,将数据缓存至客户端本地,从而提高数据传输效率。且,一般来说客户端和服务器程序由一个开发团队创作,所以他们之间所采用的协议相对灵活。可以在标准协议的基础上根据需求裁剪及定制。例如,腾讯所采用的通信协议,即为ftp协议的修改剪裁版。 因此,传统的网络应用程序及较大型的网络应用程序都首选C/S模式进行开发。如,知名的网络游戏魔兽世界。3D画面,数据量庞大,使用C/S模式可以提前在本地进行大量数据的缓存处理,从而提高观感。 C/S模式的缺点也较突出。由于客户端和服务器都需要有一个开发团队来完成开发。工作量将成倍提升,开发周期较长。另外,从用户角度出发,需要将客户端安插至用户主机上,对用户主机的安全性构成威胁。这也是很多用户不愿使用C/S模式应用程序的重要原因。 B/S模式相比C/S模式而言,由于它没有独立的客户端,使用标准浏览器作为客户端,其工作开发量较小。只需开发服务器端即可。另外由于其采用浏览器显示数据,因此移植性非常好,不受平台限制。如早期的偷菜游戏,在各个平台上都可以完美运行。 B/S模式的缺点也较明显。由于使用第三方浏览器,因此网络应用支持受限。另外,没有客户端放到对方主机上,缓存数据不尽如人意,从而传输数据量受到限制。应用的观感大打折扣。第三,必须与浏览器一样,采用标准http协议进行通信,协议选择不灵活。 因此在开发过程中,模式的选择由上述各自的特点决定。根据实际需求选择应用程序设计模式。 简单的C/S模型通信 Server端:Listen函数 func Listen(network, address string) (Listener, error) network:选用的协议:TCP、UDP, 如:“tcp”或 “udp” address:IP地址+端口号, 如:“127.0.0.1:8000”或 “:8000” Listener 接口: type Listener interface { Accept (Conn, error) Close error Addr Addr } Conn 接口: type Conn interface { Read(b byte) (n int, err error) Write(b byte) (n int, err error) Close error LocalAddr Addr RemoteAddr Addr SetDeadline(t time.Time) error SetReadDeadline(t time.Time) error SetWriteDeadline(t time.Time) error } 参看 [<u>https://studygolang.com/pkgdoc</u>](https://studygolang.com/pkgdoc) 中文帮助文档中的demo: 示例代码:TCP服务器.go package main import ( "net" "fmt" ) func main { // 创建监听 listener, err:= net.Listen("tcp", ":8000") if err != nil { fmt.Println("listen err:", err) return } defer listener.Close // 主协程结束时,关闭listener fmt.Println("服务器等待客户端建立连接...") // 等待客户端连接请求 conn, err := listener.Accept if err != nil { fmt.Println("accept err:", err) return } defer conn.Close // 使用结束,断开与客户端链接 fmt.Println("客户端与服务器连接建立成功...") // 接收客户端数据 buf := make(byte, 1024) // 创建1024大小的缓冲区,用于read n, err := conn.Read(buf) if err != nil { fmt.Println("read err:", err) return } fmt.Println("服务器读到:", string(buf[:n])) // 读多少,打印多少。 }