blocks|key|4503899|text|一个简单的解决方案是将daemon+*Daemon移到参数列表中(从而从接口中删除start(...)+)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4503900|type+Daemon+interface+{
++++//+start(time.Duration)
++++doWork()
}

func+start(daemon+Daemon,+duration+time.Duration)+{+...+}

func+main()+{
++++...
++++start(dA,+1+*+time.Second)
++++start(dB,+5+*+time.Second)
++++...
}|code-block|syntax|javascript|4503901|entityMap^0|B|E|15|A|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

An easy solution is to move <code>daemon *Daemon</code> to the argument list (thus removing <code>start(...)</code> from the interface):

<pre><code>type Daemon interface {
 // start(time.Duration)
 doWork()
}

func start(daemon Daemon, duration time.Duration) { ... }

func main() {
 ...
 start(dA, 1 * time.Second)
 start(dB, 5 * time.Second)
 ...
}
</code></pre>

blocks|key|4504018|text|其他答案为您的问题提供了替代方案，但是他们提出了不使用抽象类/结构的解决方案，我猜如果您对使用像solution这样的抽象类感兴趣，以下是对您的问题的非常精确的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4504019|Go+plaground|offset|length|4504020|package+main

import+(
++++"fmt"
++++"time"
)

type+Daemon+interface+{
++++start(time.Duration)
++++doWork()
}

type+AbstractDaemon+struct+{
++++Daemon
}

func+(a+*AbstractDaemon)+start(duration+time.Duration)+{
++++ticker+:=+time.NewTicker(duration)

++++//+this+will+call+daemon.doWork()+periodically++
++++go+func()+{
++++++++for+{
++++++++++++<-+ticker.C
++++++++++++a.doWork()
++++++++}
++++}()
}



type+ConcreteDaemonA+struct+{+
*AbstractDaemon
foo+int
}

func+newConcreteDaemonA()+*ConcreteDaemonA+{
++a:=&AbstractDaemon{}
++r:=&ConcreteDaemonA{a,+0}
++a.Daemon+=+r
++return+r
}


type+ConcreteDaemonB+struct+{+
*AbstractDaemon
bar+int
}

func+newConcreteDaemonB()+*ConcreteDaemonB+{
++a:=&AbstractDaemon{}
++r:=&ConcreteDaemonB{a,+0}
++a.Daemon+=+r
++return+r
}



func+(a+*ConcreteDaemonA)+doWork()+{
++++a.foo%2B%2B
++++fmt.Println("A:+",+a.foo)
}

func+(b+*ConcreteDaemonB)+doWork()+{
++++b.bar--
++++fmt.Println("B:+",+b.bar)
}


func+main()+{
++++var+dA++Daemon+=+newConcreteDaemonA()
++++var+dB++Daemon+=+newConcreteDaemonB()

++++dA.start(1+*+time.Second)
++++dB.start(5+*+time.Second)

++++time.Sleep(100+*+time.Second)
}|code-block|syntax|javascript|4504021|如果这还不是很明显，如何在go-lang中使用抽象类/多重继承，这里是全面详细的帖子。Abstract+Classes+In+Go|4504022|entityMap|0|LINK|mutability|MUTABLE|url|https://play.golang.org/p/ZbOeYTMTML|1|https://medium.com/@adrianwit/abstract-class-reinvented-with-go-4a7326525034^0|0|0|C|0|0|0|17|M|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@$D|Y|E|Z|1|10]]|A|$]]|$1|F|3|G|5|H|7|11|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|9|@$D|13|E|14|1|15]]|A|$]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]|U|$5|P|Q|R|A|$S|V]]]]

The other answers provide an alternative to your problem, however they proposed solution without using abstract classes/struct, and I guess if you were interested in using abstract class like solution, here is very precise solution to your problem:

<a href="https://play.golang.org/p/ZbOeYTMTML" rel="noreferrer">Go plaground</a>

<pre><code>package main

import (
 "fmt"
 "time"
)

type Daemon interface {
 start(time.Duration)
 doWork()
}

type AbstractDaemon struct {
 Daemon
}

func (a *AbstractDaemon) start(duration time.Duration) {
 ticker := time.NewTicker(duration)

 // this will call daemon.doWork() periodically 
 go func() {
 for {
 &lt;- ticker.C
 a.doWork()
 }
 }()
}



type ConcreteDaemonA struct { 
*AbstractDaemon
foo int
}

func newConcreteDaemonA() *ConcreteDaemonA {
 a:=&amp;AbstractDaemon{}
 r:=&amp;ConcreteDaemonA{a, 0}
 a.Daemon = r
 return r
}


type ConcreteDaemonB struct { 
*AbstractDaemon
bar int
}

func newConcreteDaemonB() *ConcreteDaemonB {
 a:=&amp;AbstractDaemon{}
 r:=&amp;ConcreteDaemonB{a, 0}
 a.Daemon = r
 return r
}



func (a *ConcreteDaemonA) doWork() {
 a.foo++
 fmt.Println("A: ", a.foo)
}

func (b *ConcreteDaemonB) doWork() {
 b.bar--
 fmt.Println("B: ", b.bar)
}


func main() {
 var dA Daemon = newConcreteDaemonA()
 var dB Daemon = newConcreteDaemonB()

 dA.start(1 * time.Second)
 dB.start(5 * time.Second)

 time.Sleep(100 * time.Second)
}
</code></pre>

If this is still not obvious how to use abstract classes/multi-inheritance in go-lang here is the post with comprehensive details. <a href="https://medium.com/@adrianwit/abstract-class-reinvented-with-go-4a7326525034" rel="noreferrer">Abstract Classes In Go</a>

blocks|key|4504132|text|抽象类的功能有以下要求%25+1。不能创建抽象类%25+2的直接实例。它应该提供默认字段和方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4504133|可以使用接口和结构的组合来满足上述两个需求。例如，我们可以在下面看到|4504134|package+main

import+"fmt"

//Abstract+Interface
type+iAlpha+interface+{
++++work()
++++common(iAlpha)
}

//Abstract+Concrete+Type
type+alpha+struct+{
++++name+string
}

func+(a+*alpha)+common(i+iAlpha)+{
++++fmt.Println("common+called")
++++i.work()
}

//Implementing+Type
type+beta+struct+{
++++alpha
}

func+(b+*beta)+work()+{
++++fmt.Println("work+called")
++++fmt.Printf("Name+is+%25s\n",+b.name)
}

func+main()+{
++++a+:=+alpha{name:+"test"}
++++b+:=+&beta{alpha:+a}
++++b.common(b)
}


++Output:
++++common+called
++++work+called
++++Name+is+test|code-block|syntax|javascript|4504135|这里要提到的一个要点是，所有默认方法都应该将iAlpha作为第一个参数，如果默认方法需要调用任何未实现的方法，它们将在此接口上调用。这与我们在上面的通用方法-+i.work()中所做的相同。|4504136|来源：https://golangbyexample.com/go-abstract-class/|offset|length|4504137|entityMap|0|LINK|mutability|MUTABLE|url|https://golangbyexample.com/go-abstract-class/^0|0|0|0|0|3|1A|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@$M|11|N|12|1|13]]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

The functionality of abstract class has below requirements 
 1. It should not be possible to create direct instance of abstract class
 2. It should provide default fields and methods.

A combination of interface and struct can be used to fulfill above two requirements. For example we can see below

<pre><code>package main

import "fmt"

//Abstract Interface
type iAlpha interface {
 work()
 common(iAlpha)
}

//Abstract Concrete Type
type alpha struct {
 name string
}

func (a *alpha) common(i iAlpha) {
 fmt.Println("common called")
 i.work()
}

//Implementing Type
type beta struct {
 alpha
}

func (b *beta) work() {
 fmt.Println("work called")
 fmt.Printf("Name is %s\n", b.name)
}

func main() {
 a := alpha{name: "test"}
 b := &amp;beta{alpha: a}
 b.common(b)
}


 Output:
 common called
 work called
 Name is test
</code></pre>

One important point to mention here is that all default method should have iAlpha as first argument, and if default method needs to call any unimplemented method they they will call on this interface. This is same as we did in common method above - i.work().

Source: <a href="https://golangbyexample.com/go-abstract-class/" rel="nofollow noreferrer">https://golangbyexample.com/go-abstract-class/</a>

How to implement an abstract class in Go? As Go doesn't allow us to have fields in interfaces, that would be a stateless object. So, in other words, is it possible to have some kind of default implementation for a method in Go?

Consider an example:

<pre><code>type Daemon interface {
 start(time.Duration)
 doWork()
}

func (daemon *Daemon) start(duration time.Duration) {
 ticker := time.NewTicker(duration)

 // this will call daemon.doWork() periodically 
 go func() {
 for {
 &lt;- ticker.C
 daemon.doWork()
 }
 }()
}

type ConcreteDaemonA struct { foo int }
type ConcreteDaemonB struct { bar int }

func (daemon *ConcreteDaemonA) doWork() {
 daemon.foo++
 fmt.Println("A: ", daemon.foo)
}

func (daemon *ConcreteDaemonB) doWork() {
 daemon.bar--
 fmt.Println("B: ", daemon.bar)
}

func main() {
 dA := new(ConcreteDaemonA)
 dB := new(ConcreteDaemonB)

 start(dA, 1 * time.Second)
 start(dB, 5 * time.Second)

 time.Sleep(100 * time.Second)
}
</code></pre>

This won't compile as it's not possible to use interface as a receiver. 

In fact, I have already answered my question (see the answer below). However, is it an idiomatic way to implement such logic? Are there any reasons not to have a default implementation besides language's simplicity?

How to implement an abstract class in Go?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

如何在Go中实现抽象类？因为Go不允许我们在接口中有字段，所以这将是一个无状态对象。那么，换句话说，有没有可能在Go中有某种默认的方法实现呢？考虑一个例子：type Daemon interface {    start(time.Duration)    doWork()}func (daemon *Daemon) ...

问如何在Go中实现抽象类？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Go中实现抽象类？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Go中实现抽象类？
EN