Accessing parent methods in Ruby - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to call the parent method from the child class.

Ruby

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

class Child < Parent
  def greet
    [1]
  end
end

Child.new.greet

Drag options to blanks, or click blank then click option'

Asuper

Bself.greet

CParent.greet

Dgreet

Attempts:

3 left

💡 Hint

Common Mistakes

Using self.greet calls the method on the current object, causing recursion.

Calling Parent.greet without an instance will cause an error.

Using greet alone calls the current method, causing infinite recursion.

In Ruby, super calls the same method from the parent class.

2fill in blank

medium

Complete the code to call the parent method with arguments.

Ruby

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

class Child < Parent
  def greet(name)
    [1]
  end
end

Child.new.greet("Alice")

Drag options to blanks, or click blank then click option'

Asuper()

Bsuper(name)

Csuper

Dsuper.greet(name)

Attempts:

3 left

💡 Hint

Common Mistakes

Using super without arguments passes all arguments automatically, but here explicit passing is clearer.

Using super() calls the parent method without arguments, causing errors.

Using super.greet(name) is invalid syntax.

Use super(name) to pass the argument to the parent method.

3fill in blank

hard

Fix the error in calling the parent method inside a module included in a class.

Ruby

module Mixin
  def greet
    [1]
  end
end

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

class Child < Parent
  include Mixin
end

Child.new.greet

Drag options to blanks, or click blank then click option'

Aself.greet

BParent.greet

Csuper()

Dsuper

Attempts:

3 left

💡 Hint

Common Mistakes

Calling Parent.greet directly causes an error because it's an instance method.

Using self.greet causes infinite recursion.

Using super() without arguments is valid but same as super here.

Inside a module method, super calls the next method in the lookup chain, here the parent class method.

4fill in blank

hard

Fill the blank to call the parent method and add extra behavior.

Ruby

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

class Child < Parent
  def greet
    [1]
    puts "And hello from Child"
  end
end

Child.new.greet

Drag options to blanks, or click blank then click option'

Asuper

Bself.greet

CParent.greet

Dsuper()

Attempts:

3 left

💡 Hint

Common Mistakes

Using self.greet causes infinite recursion.

Calling Parent.greet directly is invalid without an instance.

Use super or super() to call the parent method before adding child behavior.

5fill in blank

hard

Fill the blank to override a method, call the parent method with arguments, and add extra output.

Ruby

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

class Child < Parent
  def greet(name)
    [1]
    puts "And hello from Child to #{name}"
  end
end

Child.new.greet("Bob")

Drag options to blanks, or click blank then click option'

Asuper(name)

Bself.greet(name)

Csuper()

Dsuper

Attempts:

3 left

💡 Hint

Common Mistakes

Using self.greet(name) causes infinite recursion.

Using super() without arguments causes errors here.

Use super(name) to call the parent method with argument.

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