Accessing parent methods in Ruby - Cheat Sheet & Quick Revision

Recall & Review

beginner

What keyword in Ruby is used to call a method from the parent class?

The <code>super</code> keyword is used to call a method from the parent class in Ruby.

intermediate

How does super behave when called without arguments inside a method?

When super is called without arguments, it passes all the arguments received by the current method to the parent method.

intermediate

What happens if you call super() with empty parentheses in a method?

Calling super() with empty parentheses calls the parent method without passing any arguments, even if the current method received some.

advanced

Can super be used to access parent methods with different names?

No, super calls the parent method with the same name as the current method. To call a differently named parent method, you must call it explicitly with ParentClassName.method_name.

beginner

Example: How to override a method and still use the parent method's behavior in Ruby?

You override the method in the child class and inside it call <code>super</code> to reuse the parent method's code. For example:<br><pre>class Parent
  def greet
    "Hello"
  end
end

class Child < Parent
  def greet
    super + ", world!"
  end
end

Child.new.greet # =&gt; "Hello, world!"</pre>

In Ruby, what does super do inside a method?

A Calls the parent class's method with the same name

B Calls any method from the parent class

C Calls a method from a sibling class

D Calls the current method recursively

super calls the parent class's method that has the same name as the current method.

What happens if you call super() with empty parentheses in a Ruby method?

A Passes no arguments to the parent method

B Causes an error

C Passes all current method arguments to the parent method

D Calls a different method in the parent class

super() calls the parent method without passing any arguments.

If a child method receives arguments but calls super without parentheses, what happens?

A Parent method is called with no arguments

B Parent method is called with the same arguments

C Parent method is not called

D An error is raised

Calling super without parentheses passes the current method's arguments to the parent method.

How can you call a parent method with a different name than the current method?

A It is not possible

B Using <code>super</code> with the method name

C Using <code>super()</code> with arguments

D Using <code>ParentClassName.method_name</code>

You must call the parent method explicitly by its class and method name.

What is the purpose of using super in a child class method?

A To call a method from another unrelated class

B To completely replace the parent method

C To extend or reuse the parent method's behavior

D To call the child method recursively

super helps reuse or extend the parent method's code inside the child method.

Explain how the super keyword works in Ruby when overriding methods.

Think about how you can reuse code from the parent method inside the child method.

Describe how to call a parent class method that has a different name than the current method in Ruby.

Remember that super only calls methods with the same name.

Practice

1. In Ruby, how do you call a method from a parent class inside a child class method?

easy

A. Use parent.method_name

B. Call the parent method by its name directly

C. Use this.parent.method_name

D. Use super inside the child method

Solution

1. Step 1: Understand method inheritance in Ruby

   Child classes inherit methods from parent classes but to call the parent's version inside an overridden method, you use super.

2. Step 2: Identify the correct syntax for calling parent method

   Using super inside the child method calls the parent method with the same name.

3. Final Answer:

   Use super inside the child method -> Option D

4. Quick Check:

   Calling parent method = super [OK]

Hint: Use super to call parent method inside child [OK]

Common Mistakes:

• Trying to call parent method by name directly
• Using non-existent syntax like parent.method_name
• Confusing this with Ruby's self

2. Which of the following is the correct syntax to call a parent class method with arguments in Ruby?

easy

A. super arg1, arg2

B. super(arg1 arg2)

C. super[arg1, arg2]

D. super{arg1, arg2}

Solution

1. Step 1: Recall Ruby method call syntax

   In Ruby, method arguments are passed separated by commas without brackets unless parentheses are used.

2. Step 2: Identify correct super usage with arguments

   The correct way is super arg1, arg2 or super(arg1, arg2). super arg1, arg2 uses the correct syntax without parentheses.

3. Final Answer:

   super arg1, arg2 -> Option A

4. Quick Check:

   Pass args to super with commas [OK]

Hint: Pass arguments to super separated by commas [OK]

Common Mistakes:

• Using brackets [] or braces {} instead of parentheses or commas
• Omitting commas between arguments
• Using incorrect syntax like super(arg1 arg2)

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

class Parent
  def greet(name)
    "Hello, #{name} from Parent"
  end
end

class Child < Parent
  def greet(name)
    super(name) + " and Child"
  end
end

puts Child.new.greet("Alice")

medium

A. "Hello, Alice from Child"

B. "Hello, Alice from Parent and Child"

C. "Hello, Alice from Parent"

D. Error: wrong number of arguments

Solution

1. Step 1: Understand method overriding and super call

   The Child#greet method calls super(name), which calls Parent#greet(name) and returns "Hello, Alice from Parent".

2. Step 2: Concatenate the returned string

   The child method adds " and Child" to the parent's returned string, resulting in "Hello, Alice from Parent and Child".

3. Final Answer:

   "Hello, Alice from Parent and Child" -> Option B

4. Quick Check:

   super returns parent's string + child's addition [OK]

Hint: super returns parent's result; child adds more [OK]

Common Mistakes:

• Thinking super calls child's method again causing recursion
• Ignoring the concatenation after super call
• Assuming super without arguments forwards none

4. Identify the error in this Ruby code snippet:

class Parent
  def info
    "Parent info"
  end
end

class Child < Parent
  def info
    super()
    puts "Child info"
  end
end

Child.new.info

medium

A. super() returns value but is ignored; only child info prints

B. Runtime error: super() called without arguments

C. Syntax error: super() should not have parentheses

D. No error; outputs both parent and child info

Solution

1. Step 1: Analyze the super call with parentheses

   Calling super() calls the parent method with no arguments and returns "Parent info" but does not print it.

2. Step 2: Check what is printed

   The child method prints only "Child info" because the parent's return value is ignored.

3. Final Answer:

   super() returns value but is ignored; only child info prints -> Option A

4. Quick Check:

   super() returns but doesn't print [OK]

Hint: super() returns value; print it to see output [OK]

Common Mistakes:

• Assuming super() prints parent's return value automatically
• Thinking super() without args causes error
• Confusing syntax error with runtime behavior

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

class A
  def message
    "A"
  end
end

class B < A
  def message
    "B" + super
  end
end

class C < B
  def message
    super + "C"
  end
end

puts C.new.message

hard

A. "ABC"

B. "BCA"

C. "BAC"

D. "CAB"

Solution

1. Step 1: Trace method calls from C to A

   C#message calls super which is B#message. B#message returns "B" + super which calls A#message returning "A".

2. Step 2: Combine returned strings step-by-step

   B#message returns "B" + "A" = "BA". Then C#message returns "BA" + "C" = "BAC".

3. Final Answer:

   "BAC" -> Option C

4. Quick Check:

   super chains add strings in order [OK]

Hint: super calls chain up; combine results in call order [OK]

Common Mistakes:

• Mixing order of concatenation
• Assuming super calls only immediate parent
• Ignoring that super returns parent's result