复杂模块的计算器扩展方案及动态绑定

本篇文章向大家介绍《复杂模块的计算器扩展方案及动态绑定》，主要包括，具有一定的参考价值，需要的朋友可以参考一下。

我已经制作了可以计算整数和实数的计算器（我用 go 制作的）。 然后我想通过添加这些模块来计算复数和有理数。 （当类型混合时也可以计算） 如果我每次（运行时）检查操作数的类型并处理每种情况，这会很容易，但我想用动态绑定来解决它。伙计们，你能告诉我如何解决这个问题吗

正确答案

我认为通过动态类型，您可能指的是在 c++ 和 java 中，动态绑定本质上是引用可以指向派生类的基类（因为派生类“是一个“基类）。

有人可能会说基类定义了派生类变形的接口。如果派生类替换了基类的方法，对基类的引用仍然可以访问派生类中的这些方法。

基类可以定义一些方法来为其派生类提供一些“基本”功能。如果这些类没有重新定义方法，则可以调用基类的方法。

在 go 中，这两个概念都存在，但它们有很大不同。

go 有一个显式的 interface 关键字，它定义了方法签名，但没有定义方法。如果任何值具有相同名称和相同签名的方法，则任何值都隐式满足该接口。

type livingbeing interface {
    takeinenergy()
    expelwaste()
}

接口类型成为代码中的有效类型。我们可以将接口传递给函数，并且在不知道满足该接口的类型的情况下，可以调用其方法：

func dolife(being livingbeing) {
   being.takeinenergy()
   being.expelwaste()
}

这是有效的代码，但不是完整的代码。与其他语言中的基类不同，接口不能定义函数，只能定义它们的签名。它纯粹是一个接口定义。 我们必须独立于接口本身来定义满足接口的类型。

type organism struct{}

func (o *organism) takeinenergy() {}

func (o *organism) expelwaste() {}

我们现在有一个满足 livingbeing 的类型 organism。它类似于基类，但如果我们想在它的基础上构建，我们就不能使用子类化，因为 go 没有实现它。但 go 确实提供了类似的东西，称为 embedding types。

在此示例中，我将定义一个新生物体 animal，它从 livingbeing 中提取 expelwaste()，但定义其自己的 takeinenergy()：

type animal struct {
    organism  // the syntax for an embedded type: type but no field name
}

func (a *animal) takeinenergy() {
    fmt.printf("i am an animal")
}

从该代码中不明显的是，由于 animal 的 organism 不是命名字段，因此可以直接从 animal 访问其字段和方法。 几乎就好像 animal “是一个n”有机体。

然而它*不是*一个有机体。它是一种不同的类型，将对象嵌入视为语法糖来自动将 organism 的字段和方法提升为 animal 会更准确。

由于 go 是静态且显式类型的，因此 dolife 无法采用 organism 然后传递 animal：它没有相同的类型：

/* this does not work.  animal embeds organism, but *is not* an organism */
func dolife(being *organism) {
   being.takeinenergy()
   being.expelwaste()
}
func main() {
    var a = &animal{organism{}}
    dolife(&animal{})
}

cannot use &animal{} (type *animal) as type *organism in argument to dolife

这就是 interface 存在的原因 - 这样 organism 和 animal （事实上，甚至 plant 或 chemotropicbacteria）都可以作为 livingbeingzqben 传递。 dczqb。

package main

import "fmt"

type livingbeing interface {
    takeinenergy()
    expelwaste()
}

type organism struct{}

func (o *organism) takeinenergy() {
}

func (o *organism) expelwaste() {}

type animal struct {
    organism
}

func dolife(being livingbeing) {
    being.takeinenergy()
    being.expelwaste()
}

func (a *animal) takeinenergy() {
    fmt.printf("i am an animal")
}

func main() {
    var a = &animal{organism{}}
    dolife(a)
}

1. 从语法上讲，如果要声明嵌入文字，则必须显式提供其类型。在我的示例中，organism 没有字段，因此无需声明任何内容，但我仍然保留了显式类型，以便为您指明正确的方向。

2. dolife 可以在 livingbeing 上调用正确的 takeinenergy，但 organism 的方法不能。他们只能看到嵌入的 organism。

func (o *organism) expelwaste() {
    o.getwaste() //this will always be organism's getwaste, never animal's
}

func (o *organism)getwaste() {}

func (a *animal)getwaste() {
    fmt.println("animal waste")
}

同样，如果您仅传递嵌入部分，那么它将调用自己的 takeinenergy()，而不是 animal 的 animal ； animal 已经没有了！

func main() {
    var a = &Animal{Organism{}}
    DoLife(&a.Organism)
}

总而言之，

• 定义显式 interface 并在需要“多态”行为的任何地方使用该类型

• 定义基本类型并将其嵌入其他类型以共享基本功能。

• 不要期望“基”类型能够“绑定”到“派生”类型的函数。

今天关于《复杂模块的计算器扩展方案及动态绑定》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！