Method overriding in Ruby - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is method overriding in Ruby?

Method overriding in Ruby is when a subclass provides its own version of a method that is already defined in its superclass. This allows the subclass to change or extend the behavior of that method.

beginner

How does Ruby decide which method to call when a method is overridden?

Ruby calls the method defined in the subclass if it exists. If not, it looks up the inheritance chain to find the method in the superclass.

intermediate

Can you override a method and still call the original method from the superclass in Ruby? How?

Yes, you can use the keyword super inside the overriding method to call the original method from the superclass.

intermediate

What happens if you call super without parentheses and arguments in an overriding method?

Ruby automatically passes all the arguments received by the overriding method to the superclass method when you call <code>super</code> without parentheses.

beginner

Show a simple example of method overriding in Ruby.

class Animal
  def speak
    "Hello"
  end
end

class Dog < Animal
  def speak
    "Woof!"
  end
end

puts Dog.new.speak  # Output: Woof!

What keyword is used in Ruby to call the superclass method from an overriding method?

A base

B parent

C super

D override

The keyword super calls the method with the same name in the superclass.

If a subclass overrides a method but does not call super, what happens?

A The superclass method is called automatically.

B The superclass method is ignored.

C An error occurs.

D Both methods run in sequence.

If super is not called, only the subclass method runs; the superclass method is ignored.

What will this code output? class A def greet "Hi" end end class B < A def greet super + ", there!" end end puts B.new.greet

A Error

B "Hi"

C ", there!"

D "Hi, there!"

The subclass method calls super which returns "Hi", then adds ", there!".

Which of these is true about method overriding?

A It allows a subclass to change the behavior of a method from its superclass.

B It creates a new method unrelated to the superclass.

C It deletes the superclass method.

D It only works with private methods.

Method overriding lets subclasses provide their own version of a method defined in the superclass.

In Ruby, if you want to pass different arguments to the superclass method when overriding, what should you do?

A Call <code>super</code> with the new arguments explicitly.

B Call <code>super</code> without arguments.

C You cannot pass different arguments.

D Use <code>super!</code> keyword.

To pass different arguments, you call super with those arguments explicitly.

Explain method overriding in Ruby and how the super keyword works.

Think about how a child class can change a parent's method but still use the parent's version.

Write a simple Ruby example showing a superclass method, a subclass overriding it, and using super to call the original method.

Start with a class Animal and subclass Dog, override speak method.

Practice

1. What does method overriding in Ruby allow a child class to do?

easy

A. Prevent the parent class from being used

B. Create a new method with a different name

C. Change the behavior of a method inherited from the parent class

D. Automatically call all parent methods

Solution

1. Step 1: Understand method overriding concept

   Method overriding means a child class uses the same method name as the parent but changes its behavior.

2. Step 2: Identify the effect on behavior

   The child class method replaces the parent's method behavior when called on the child object.

3. Final Answer:

   Change the behavior of a method inherited from the parent class -> Option C

4. Quick Check:

   Method overriding = change inherited method behavior [OK]

Hint: Same method name in child changes parent method behavior [OK]

Common Mistakes:

• Thinking overriding creates a new method with a different name
• Believing it prevents parent class usage
• Assuming it calls all parent methods automatically

2. Which of the following is the correct way to override a method named greet in a Ruby child class?

easy

A. class Child < Parent\n def greet_child\n puts 'Hello from child'\n end\nend

B. class Child < Parent\n def greet\n puts 'Hello from child'\n end\nend

C. class Child < Parent\n def greet() puts 'Hello from child' end\nend

D. class Child < Parent\n def greet: puts 'Hello from child' end\nend

Solution

1. Step 1: Check method name matches exactly

   Overriding requires the child method to have the same name as the parent method, here 'greet'.

2. Step 2: Verify Ruby method syntax

   Ruby method definitions use def method_name followed by body and end. Multi-line with indentation is standard. Parentheses are optional, but def greet() puts ... end is valid syntax if properly formatted. Colon syntax is invalid.

3. Final Answer:

   class Child < Parent\n def greet\n puts 'Hello from child'\n end\nend -> Option B

4. Quick Check:

   Same method name + correct syntax = override [OK]

Hint: Use same method name and proper def/end syntax [OK]

Common Mistakes:

• Changing method name instead of overriding
• Using incorrect method definition syntax
• Adding colon after method name

3. What will be the output of this Ruby code?

class Parent
  def greet
    puts 'Hello from Parent'
  end
end

class Child < Parent
  def greet
    puts 'Hello from Child'
  end
end

obj = Child.new
obj.greet

medium

A. Hello from Child

B. Error: undefined method greet

C. No output

D. Hello from Parent

Solution

1. Step 1: Identify class hierarchy and method overriding

   Child class overrides the greet method of Parent with its own version.

2. Step 2: Determine which method is called

   Creating an instance of Child and calling greet calls the Child's version, printing 'Hello from Child'.

3. Final Answer:

   Hello from Child -> Option A

4. Quick Check:

   Child method overrides parent = Child output [OK]

Hint: Child instance calls overridden method, not parent's [OK]

Common Mistakes:

• Expecting parent method output
• Thinking no output occurs
• Assuming method is undefined

4. Find the error in this Ruby code that tries to override a method:

class Parent
  def speak
    puts 'Parent speaks'
  end
end

class Child < Parent
  def speak()
    puts 'Child speaks'
  end

medium

A. Cannot override methods with parentheses

B. Method name should be different

C. Parent class must be declared inside Child

D. Missing end for Child class

Solution

1. Step 1: Check class and method block endings

   The Child class is missing the closing end keyword to finish the class definition.

2. Step 2: Confirm method overriding syntax

   The method speak is correctly named and defined; parentheses are allowed but optional.

3. Final Answer:

   Missing end for Child class -> Option D

4. Quick Check:

   Every class needs matching end [OK]

Hint: Count your end keywords carefully [OK]

Common Mistakes:

• Thinking method name must change
• Believing parentheses cause error
• Confusing class nesting rules

5. Given this Ruby code, what will be the output?

class Animal
  def sound
    'Some sound'
  end
end

class Dog < Animal
  def sound
    super + ' and Bark'
  end
end

class Cat < Animal
  def sound
    super + ' and Meow'
  end
end

puts Dog.new.sound
puts Cat.new.sound

hard

A. Some sound and Bark\nSome sound and Meow

B. Some sound\nSome sound

C. and Bark\nand Meow

D. Error: super called incorrectly

Solution

1. Step 1: Understand use of super in overridden methods

   Both Dog and Cat override sound and call super to get Animal's sound return value.

2. Step 2: Combine parent and child method results

   Each child adds its own string to the parent's 'Some sound', resulting in 'Some sound and Bark' and 'Some sound and Meow'.

3. Final Answer:

   Some sound and Bark\nSome sound and Meow -> Option A

4. Quick Check:

   super adds parent method result [OK]

Hint: super calls parent method result to extend behavior [OK]

Common Mistakes:

• Ignoring super and expecting only child string
• Expecting error from super usage
• Thinking output is only parent's string