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

Question

So I have the following below. How do I make it where when I call rabbit.halfRun(); it runs the code in Animal.run() instead of Rabbit.run()

 class Animal { constructor(name) { this.speed = 0; this.name = name; } run(speed) { this.speed += speed; console.log(`${this.name} runs with speed ${this.speed}.`); } halfRun(){ var newSpeed = this.speed / 2; // expect to be run() from Animal class, not Rabbit class this.run(newSpeed) } } class Rabbit extends Animal { run(speed) { var speed = speed * 2; super.run(speed); } } let rabbit = new Rabbit("White Rabbit"); rabbit.run(5); // expect and get 10 rabbit.halfRun(); // expect 5 but I get 20 because it is running the run() from Rabbit 

Answer 1

The reason why you are getting 20 is because in your halfRun function:

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

You are calling this.run(newSpeed) which is referring to the rabbit class' run method instead of the animal one since you are calling rabbit.halfRun() . Therefore, it will be calling the rabbit class' implementation of run() since it has been overridden

Also, I believe you are setting up your halfRun() function wrong because although you halve the speed, you are still adding it onto the current speed value.

To fix your issue, you can simply just set the speed in your half run function:

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

Answer 2

because halfrun is calling both methods.'run' method of the rabbit class to multiply it with 2 and then 'run' of rabbit class is running super run of animal class. so both run methods are in action.

Answer 3

the issue is something like

when rabbit.run() is called the speed variable holds the value of 10 and prints it

speed = 10

when rabbit.halfRun() is called it will divide the value by 2 which means 10/2 is five which should be expected output

before to the end of method you called the this.run(newSpeed)// this.run(5)

so it will call the run method in the rabbit class

so speed = speed * 2 // 5 * 2

which is 10

at last you are calling the super.run(speed) // super.run(10)

since previously rabbit.run() has been executed the speed holds the value 10

so this.speed =+ speed // 10 =+ 10 which gives 20

Answer 4

Its like function overriding where the actual method to be called is decided at the runtime based on the instance its pointing to.

so because the rabbit vairable is pointing to an object of class Rabbit and class Rabbit has overriding method run on it so even if you call the halfRun from parent class its actually calling the run method of class Rabbit . its because the actual function to be called was decided at runtime based on the object the rabbit vairable is pointing to.

So i think its expected result and its fine.

but yes then in Javascript i guess there is no such keyword like self which should call the method of current class in time of inheritance.

Answer 5

I have added logs to describe the code hope you will understand why you got 20 as the result. This is what happens to your speed,
0 -> 5*2 -> 0+10 -> 10/2 -> 5*2 -> 10+10 -> 20

 class Animal { constructor(name) { this.speed = 0; this.name = name; } run(speed) { console.log(`Received ${speed} from Rabbit class`); console.log(`Adding ${speed} to ${this.speed}`); this.speed += speed; console.log(`Current speed at run(Animal class): ${this.speed}.`); } halfRun(){ console.log(`Deviding the current speed ${this.speed} by 2`); var newSpeed = this.speed / 2; console.log(`New speed passed to Rabbit class ${newSpeed}`); this.run(newSpeed) } } class Rabbit extends Animal { run(speed) { console.log(`Current speed: ${this.speed}`); console.log(`Multiplying ${speed} by 2`); var speed = speed * 2; console.log(`Passing ${speed} to Animal class`); super.run(speed); } } let rabbit = new Rabbit("White Rabbit"); rabbit.run(5); // expect 10 rabbit.halfRun(); // expect 20