Object golang中的实现接口

我想实现如下所示的接口。我不知道如何开始。有人能告诉我应该如何实现这些功能吗

package interval
package main

type Interval interface {
    contains(r float64) bool // if r is in x, then true
    average(Y Intervall) (Intervall, error)
    String() string                    //cast interval"[a,b]" to [a,b]
    completecontains(Y Intervall) bool //if y is completely in x, give true
    New(a, b float64) Intervall
    //var a int
}
type Complex struct {
    first int
}

func (c Complex) contains(r float64) bool {
    if a <= r <= b {
        return true
    } else {
        return false
    }
}

func (c Complex) String() string {
    return "a"
}

func (c Complex) length() float64 {
    return 2.3
}

func main() {
}

包间隔
包干管
类型间隔接口{
包含（r float64）bool//如果r在x中，则为true
平均值（Y间隔）（间隔，误差）
String（）String//cast间隔“[a，b]”到[a，b]
completecontains（Y Intervall）bool//如果Y完全在x中，则给出true
新（a，b）间隔
//变量a int
}
类型复杂结构{
第一整数
}
func（c复数）包含（r）bool{
如果a我真的不知道您在这里实际想做什么，但是代码有几个问题

a和b没有定义，我将它们添加到complex中以使其进行编译
a不确定为什么具体间隔被称为“复杂”或两个间隔的平均值可能是多少，但这是我能得到的最接近的结果。此外，不确定使用接口的好处是什么


主程序包
输入“fmt”
类型间隔接口{
包含（r）bool
平均值（y间隔）（间隔、误差）
String（）字符串
完全包含（y间隔）布尔
完全由（y间隔）布尔控制
}
类型复杂结构{
a、 b浮动64
}
func（c复数）包含（r）bool{
返回c.a如果希望
复杂
成为
间隔
，它需要实现接口定义中描述的所有函数。您遇到了什么问题？Okan，欢迎使用堆栈溢出。此链接提供了有关如何提出一个好问题的帮助：。不接受对您的问题进行污损。好的。有什么问题吗我的回答是有帮助的还是令人困惑的？我找不到任何关于以区间表示的两个平均区间的参考。你的意思是，给定[1,3]和[6,9]，你想要[4,5]？你关心开放区间和封闭区间吗？从技术上讲，[1,3]和[6,9]之间是（3,6）。给定[3,6]答案很简单，但是你可以创建一组表示开、闭、半开等的类型。间隔使其更精确。我想实现x和y的平均值。我应该如何实现它
package main

//import "fmt"

type Intervall interface {
    contains(r float64) bool // if r is in x, then true
    average(Y Intervall) (Intervall, error)
    String() string                    //cast interval"[a,b]" to [a,b]
    completecontains(Y Intervall) bool //if y is completely in x, give true
    New(a, b float64) Intervall
}

type Complex struct {
    first int
    a     float64
    b     float64
}

func (c Complex) contains(r float64) bool {

    if c.a <= r && r <= c.b {
        return true
    } else {
        return false
    }
}

func (c Complex) String() string {
    return "a"

}
func (c Complex) length() float64 {
    return 2.3
}

func main() {

}

package main

import "fmt"

type Interval interface {
    Contains(r float64) bool
    Average(y Interval) (Interval, error)
    String() string
    CompletelyContains(y Interval) bool
    CompletelyContainedBy(y Interval) bool
}

type Complex struct {
    a, b float64
}

func (c Complex) Contains(r float64) bool {
    return c.a <= r && r <= c.b
}

func (c Complex) Average(y Interval) (Interval, error) {
    return nil, fmt.Errorf("What the heck is the average of two intervals?")
}

func (c Complex) CompletelyContains(y Interval) bool {
    return y.CompletelyContainedBy(c)
}

func (c Complex) CompletelyContainedBy(y Interval) bool {
    return y.Contains(c.a) && y.Contains(c.b)
}

func (c Complex) String() string {
    return fmt.Sprintf("[%v,%v]", c.a, c.b)
}

func main() {
    var x Interval = Complex{a: 1, b: 5.1}
    var y Interval = Complex{a: 1.3, b: 5}
    fmt.Println("x contains 3:", x.Contains(3))
    fmt.Println("x completely contains y:", x.CompletelyContains(y))

    avg, err := x.Average(y)
    fmt.Println("Average of x and y:", avg, "with error:", err)

    fmt.Println("x:", x)

}