Javascript 如何从另一个父类方法调用父类方法

因此，我有以下内容。当我调用

rabbit.halfRun（）时，我如何使它在哪里它在
Animal.run（）
中运行代码，而不是
Rabbit.run（）


类动物{
建造师（姓名）{
这个速度=0；
this.name=名称；
}
跑步（速度）{
这个。速度+=速度；
log（`${this.name}以${this.speed}的速度运行）；
}
半成品（）{
var newSpeed=this.speed/2；
//希望从Animal类而不是Rabbit类运行（）
这个。运行（新闻速度）
}
}
兔类动物{
跑步（速度）{
var速度=速度*2；
超级跑（速度）；
}
}
let rabbit=新兔子（“白兔”）；
兔子。跑（5）；//期望得到10分
rabbit.halfRun（）；//预期5，但我得到20，因为它正在运行Rabbit的run（）
之所以得到20，是因为在
halfRun
函数中：

function halfRun(){
  var newSpeed = this.speed / 2;
  this.run(newSpeed);
}

function halfRun(){
  this.speed=this.speed / 2;
}

您正在调用
this.run（newSpeed）
，它引用的是rabbit类的run方法，而不是animal方法，因为您正在调用
rabbit.halfRun（）
。因此，它将调用兔子类的
run（）
实现，因为它已被重写

此外，我认为您的halfRun（）函数设置错误，因为尽管将速度减半，但仍将其添加到当前速度值上

要解决您的问题，您只需在半跑功能中设置速度：

function halfRun(){
  var newSpeed = this.speed / 2;
  this.run(newSpeed);
}

function halfRun(){
  this.speed=this.speed / 2;
}

因为halfrun正在调用这两个方法，rabbit类的“run”方法将其乘以2，然后rabbit类的“run”正在运行animal类的超级run。因此，两种run方法都在运行。
问题类似于

调用rabbit.run（）时，速度变量保持值10并打印它

速度=10

调用rabbit.halfRun（）时，它会将值除以2，这意味着10/2等于5，这应该是预期的输出

在调用this.run（newSpeed）//this.run（5）方法的结尾之前

因此，它将在rabbit类中调用run方法

所以速度=速度*2//5*2

哪一个是10

最后调用super.run（速度）//super.run（10）

自之前执行rabbit.run（）以来，速度保持值10

因此，这个.speed=+speed//10=+10给出了20
类似的函数重写，其中要调用的实际方法是在运行时根据其指向的实例决定的

因此，因为
rabbit
vairable指向
classrabbit
的对象，并且
classrabbit
在其上有覆盖方法
run
，所以即使您从父类调用
halfRun
，它实际上调用
classrabbit
的
run
方法。这是因为要调用的实际函数是根据
rabbit
vairable所指向的对象在运行时决定的

所以我认为它的预期结果和它的罚款

但是是的，在Javascript中，我想没有像self这样的关键字，在继承时应该调用当前类的方法。
我添加了日志来描述代码，希望您能理解为什么得到20个。
这就是你的速度，


0->5*2->0+10->10/2->5*2->10+10->20


类动物{
建造师（姓名）{
这个速度=0；
this.name=名称；
}
跑步（速度）{
log（`Received${speed}from Rabbit class`）；
log（`Adding${speed}到${this.speed}`）；
这个。速度+=速度；
log（`当前运行速度（动物类）：${this.speed}.`）；
}
半成品（）{
log（`将当前速度${this.speed}除以2`）；
var newSpeed=this.speed/2；
log（`newSpeed传递给兔子类${newSpeed}`）的新速度；
这个。运行（新闻速度）
}
}
兔类动物{
跑步（速度）{
log（`Current speed:${this.speed}`）；
log（`将${speed}乘以2`）；
var速度=速度*2；
log（`Passing${speed}to Animal class`）；
超级跑（速度）；
}
}
let rabbit=新兔子（“白兔”）；
兔子。跑（5）；//期望10
rabbit.halfRun（）；//除了20个
之外，还有一个类似于
runImpl
的“private”方法，实际上父类和子类的
run
方法都是因为
super.run（速度）而执行的。您可以通过在rabbit的
run
方法中添加
console.log
语句来确认，该语句与问题本身无关，但对于
rabbit.halfRun（）
我想您应该期望
15
，而不是
5
。下面是顺序（假设你得到了你想要的行为）：
this.speed
设置为
10
，然后
newSpeed
设置为
5
，最后
this.speed
设置为
10+5
，给出
15
。那么，不可能从动物调用旧的run方法而不是从兔子调用被覆盖的方法吗？我开始认为这是不可能的。是的，我知道两者都被执行了，这是因为调用了
Rabbit.run（）
，它调用了
Animal.run（）
，我接受这个答案。虽然所有其他答案都很好地解释了正在发生的事情，但它们没有回答这个问题，“是否可以运行
Animal.run（）
而不是
Rabbit.run（）
”。虽然这个答案没有告诉我怎么做，但它让我知道这是不可能的。