Class.new for dynamic class creation in Ruby - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does Class.new do in Ruby?

<p><code>Class.new</code> creates a new class dynamically at runtime instead of defining it with the <code>class</code> keyword.</p>

beginner

How can you add methods to a class created with <code>Class.new</code>?

<p>You can pass a block to <code>Class.new</code> and define methods inside that block, just like inside a normal class definition.</p>

intermediate

What is the difference between Class.new and the usual class keyword?

<p><code>Class.new</code> creates a class object dynamically and returns it, while <code>class</code> defines a class with a fixed name in the code.</p>

beginner

How do you create an instance of a class created with <code>Class.new</code>?

Assign the result of Class.new to a variable, then call .new on that variable to create an instance.

intermediate

Can <code>Class.new</code> take a superclass as an argument? If yes, how?

<p>Yes. You can pass a superclass as an argument to <code>Class.new</code> like <code>Class.new(Superclass)</code> to create a subclass dynamically.</p>

What does Class.new return in Ruby?

A A new class object

B An instance of a class

C A string with class name

D A method definition

Class.new returns a new class object that you can assign to a variable or constant.

How do you define methods inside a class created with Class.new?

A By calling <code>def</code> outside the block

B By passing a block to <code>Class.new</code> and defining methods inside it

C By using <code>module</code> keyword

D You cannot define methods dynamically

Methods can be defined inside the block passed to Class.new, just like inside a normal class.

Which of the following is a correct way to create a subclass dynamically?

A Class.new()

B Subclass.new(Superclass)

C class Subclass < Superclass end

D Class.new(Superclass)

Passing a superclass to Class.new creates a subclass dynamically.

How do you create an instance of a class created with klass = Class.new?

A klass.new

B new klass()

C Class.new.new

D klass.create()

Call .new on the class object stored in klass to create an instance.

What is a practical use of Class.new?

A Defining global variables

B Replacing all class definitions

C Creating classes on the fly when you don’t know the name beforehand

D Creating modules

Class.new is useful for dynamic class creation when class names or behavior depend on runtime data.

Explain how Class.new can be used to create a class dynamically and add methods to it.

Think about how you define a normal class and how that translates to using Class.new

Describe how inheritance works with Class.new when creating subclasses dynamically.

Consider how you normally write <code>class Subclass < Superclass</code> and how Class.new can do the same

Practice

1. What does Class.new do in Ruby?

easy

A. Defines a method inside a class

B. Deletes an existing class

C. Creates a new instance of a class

D. Creates a new class dynamically at runtime

Solution

1. Step 1: Understand the purpose of Class.new

   Class.new is used to create a new class dynamically while the program runs, without writing a full class definition.

2. Step 2: Differentiate from other options

   It does not delete classes, create instances, or define methods alone. It creates a new class object.

3. Final Answer:

   Creates a new class dynamically at runtime -> Option D

4. Quick Check:

   Class.new = dynamic class creation [OK]

Hint: Class.new always creates a new class object [OK]

Common Mistakes:

• Confusing class creation with instance creation
• Thinking it deletes or modifies existing classes
• Assuming it only defines methods

2. Which of the following is the correct syntax to create a new class with Class.new and add a method greet that returns "Hello"?

easy

A. MyClass = Class.new do def greet return "Hello" end end

B. MyClass = Class.new { greet() = "Hello" }

C. MyClass = Class.new { def greet; "Hello"; end }

D. MyClass = Class.new { def greet() puts "Hello" }

Solution

1. Step 1: Check correct block syntax for Class.new

   The block can be given with curly braces or do-end. Inside, method definitions use def method_name; ...; end.

2. Step 2: Validate method definition and return value

   MyClass = Class.new { def greet; "Hello"; end } correctly defines greet returning "Hello". MyClass = Class.new do def greet return "Hello" end end is correct syntax but missing the 'end' for the block in MyClass = Class.new do def greet return "Hello" end end, so MyClass = Class.new do def greet return "Hello" end end is invalid as given. MyClass = Class.new { greet() = "Hello" } uses invalid method syntax. MyClass = Class.new { def greet() puts "Hello" } uses puts which prints but does not return the string.

3. Final Answer:

   MyClass = Class.new { def greet; "Hello"; end } -> Option C

4. Quick Check:

   Correct method syntax inside Class.new block = MyClass = Class.new { def greet; "Hello"; end } [OK]

Hint: Use def inside Class.new block with proper syntax [OK]

Common Mistakes:

• Using puts instead of returning a string
• Incorrect block syntax for Class.new
• Invalid method definition syntax

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

MyClass = Class.new do
  def greet
    "Hi"
  end
end

obj = MyClass.new
puts obj.greet

medium

A. Hi

B. Hello

C. Error: undefined method greet

D. nil

Solution

1. Step 1: Understand class creation and method definition

   The code creates a new class with a method greet returning "Hi".

2. Step 2: Create instance and call method

   Creating an instance obj and calling obj.greet returns "Hi" which is printed.

3. Final Answer:

   Hi -> Option A

4. Quick Check:

   Method greet returns "Hi" [OK]

Hint: Method returns string; puts prints it [OK]

Common Mistakes:

• Expecting 'Hello' instead of 'Hi'
• Thinking method is undefined
• Confusing return value with nil

4. Identify the error in this code snippet:

MyClass = Class.new {
  def greet
    "Hello"
  end
end

obj = MyClass.new
puts obj.greet

medium

A. Using curly braces instead of do-end for multi-line block

B. Missing parentheses in method definition

C. Cannot call new on Class.new result

D. Method greet should use puts instead of return

Solution

1. Step 1: Check block syntax for Class.new

   Curly braces are for single-line blocks. Multi-line blocks should use do-end syntax.

2. Step 2: Confirm other parts are correct

   Method definition syntax is valid, calling new is valid, and returning string is correct.

3. Final Answer:

   Using curly braces instead of do-end for multi-line block -> Option A

4. Quick Check:

   Multi-line block needs do-end [OK]

Hint: Use do-end for multi-line Class.new blocks [OK]

Common Mistakes:

• Using curly braces for multi-line blocks
• Thinking method needs parentheses
• Confusing method return with puts

5. You want to create a dynamic class with Class.new that has an initializer accepting a name and a method greet returning "Hello, <name>". Which code correctly implements this?

hard

A. Person = Class.new {
def initialize(name)
@name = name
end
def greet
"Hello, " + name
end
}

B. Person = Class.new do
def initialize(name)
@name = name
end
def greet
"Hello, #{@name}"
end
end

C. Person = Class.new do
def initialize(name)
name = @name
end
def greet
"Hello, " + @name
end
end

D. Person = Class.new do
def initialize(name)
@name = name
end
def greet
puts "Hello, #{@name}"
end
end

Solution

1. Step 1: Check initializer assigns instance variable

   Person = Class.new do def initialize(name) @name = name end def greet "Hello, #{@name}" end end correctly assigns @name = name in initialize. Person = Class.new do def initialize(name) name = @name end def greet "Hello, " + @name end end reverses assignment incorrectly. Person = Class.new { def initialize(name) @name = name end def greet "Hello, " + name end } uses wrong block syntax. Person = Class.new do def initialize(name) @name = name end def greet puts "Hello, #{@name}" end end uses puts in greet which prints but does not return the string.

2. Step 2: Check greet method returns correct string

   Person = Class.new do def initialize(name) @name = name end def greet "Hello, #{@name}" end end returns the string with interpolation. Person = Class.new { def initialize(name) @name = name end def greet "Hello, " + name end } uses undefined variable name. Person = Class.new do def initialize(name) @name = name end def greet puts "Hello, #{@name}" end end prints instead of returning.

3. Final Answer:

   Person = Class.new do def initialize(name) @name = name end def greet "Hello, #{@name}" end end -> Option B

4. Quick Check:

   Correct initializer and return string in greet [OK]

Hint: Assign @name in initialize; return string in greet [OK]

Common Mistakes:

• Reversing assignment in initialize
• Using puts instead of returning string
• Wrong block syntax with curly braces