CODEWITHSUNDEEP
rubysuper
Thermatix
Thermatix

Reputation: 2929

Does calling super() cause further methods in the parent class to be used?

I have a question about super that I wanted confirmed. Consider the following code example:

class InFasionHello
  def hello person
    greet person.name
  end

  def greet name
   p 'Dude, hey ' + name
  end 
end

class OldFasionedHello < InFasionHello
  def hello person
    greet person.name if person.old_fashioned
    super(person) if !person.old_fashioned
  end

  def greet name
   p 'Good Day to you ' + name + '!'
  end
end

My question is, if I was using OldFasionedHello, would infasionHello use the local greet to it self or the one from the class that called it via super?

Upvotes: 1

Views: 260

Answers (2)

Phrogz
Phrogz

Reputation: 303361

The proof of the pudding is in the eating.

class Parent
  def foo; p self; bar; end        # This calls bar on the current object
  def bar; puts "parent bar"; end
end

class Child < Parent
  def foo; super; end              # Removing this line changes nothing
  def bar; puts "child bar"; end
end

Child.new.foo
#=> #<Child:0x007f980b051f40>
#=> child bar                      # NOTE! Not "parent bar"

Calling super doesn't change the self, as seen above. As such, methods you call on self (explicitly or implicitly, by not providing a receiver) still act upon the original instance, and use it for method lookup.

Calling super() is equivalent to calling:

self.class.superclass.instance_method(__method__).bind(self).call

…which helps to illustrate that you are calling the implementation of the method as though it is on the current instance. Note also that super is not the same as super(), since the former will magically pass along whatever parameters were supplied to the current method.

Upvotes: 4

BroiSatse
BroiSatse

Reputation: 44715

All the method calls inside given method are executed against self. self within an instance method is an instance itself and and it is an instance who is a receiver of this method. Hence it is initiating standard method lookup for given object so it will always execute the very top method with given name.

An extreme good example is class method:

class A
  def foo
    self.class
  end
end

class B < A
end

B.new.foo    #=> B even though foo comes from A

Upvotes: 1

Related Questions