Accessing parent methods in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of calling super in overridden method

What is the output of this Ruby code when Child.new.greet is called?

Ruby

class Parent
  def greet
    "Hello from Parent"
  end
end

class Child < Parent
  def greet
    super + " and Child"
  end
end

puts Child.new.greet

A "Hello from Parent"

B "Hello from Child"

C "Hello from Parent and Child"

D NoMethodError

💡 Hint

Remember that super calls the parent method with the same name.

The greet method in Child calls super, which runs Parent#greet returning "Hello from Parent". Then it adds " and Child" to that string.

❓ Predict Output

intermediate

Calling parent method with arguments

What will be printed when this Ruby code runs?

Ruby

class Parent
  def multiply(x, y)
    x * y
  end
end

class Child < Parent
  def multiply(x, y)
    super(x, y) + 10
  end
end

puts Child.new.multiply(3, 4)

A 22

B 12

C 34

D ArgumentError

💡 Hint

Check how super passes arguments to the parent method.

The multiply method in Child calls super with arguments 3 and 4, which returns 12. Then it adds 10, resulting in 22.

🔧 Debug

advanced

Identify the error when calling parent method

What error will this Ruby code raise when Child.new.show is called?

Ruby

class Parent
  def show
    "Parent show"
  end
end

class Child < Parent
  def show
    super()
  end
end

Child.new.show

A NoMethodError

B TypeError

C ArgumentError

D No error, returns "Parent show"

💡 Hint

Calling super() with empty parentheses calls the parent method with no arguments.

The parent method show takes no arguments. Calling super() correctly calls it without arguments, so it returns "Parent show" without error.

❓ Predict Output

advanced

Using super with default arguments

What is the output of this Ruby code?

Ruby

class Parent
  def info(name = "Parent")
    "Hello, #{name}"
  end
end

class Child < Parent
  def info(name = "Child")
    super
  end
end

puts Child.new.info

A ArgumentError

B "Hello, Child"

C "Hello, "

D "Hello, Parent"

💡 Hint

When calling super without arguments, Ruby passes the current method's arguments to the parent.

The info method in Child has default argument "Child" and calls super without arguments, so it passes the current method's argument (which defaults to "Child") to Parent#info. Therefore, the output is "Hello, Child".

🧠 Conceptual

expert

Understanding super with blocks

Consider this Ruby code. What will be the output when Child.new.process is called?

Ruby

class Parent
  def process
    yield if block_given?
    "Parent done"
  end
end

class Child < Parent
  def process
    result = super do
      "Block from Child"
    end
    result
  end
end

puts Child.new.process

A "Parent done"

B "Block from Child"

C LocalJumpError

D nil

💡 Hint

Check what yield returns and what process returns.

The process method in Parent yields to the block, but the block's return value is ignored. The method then returns "Parent done". The Child method calls super with a block, captures the return value "Parent done", and returns it.

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