Class.new for dynamic class creation in Ruby

Introduction

Class.new lets you create a new class on the fly without naming it right away. This helps when you want a quick, custom class without writing a full class definition.

When you need a simple class for a one-time use.

When you want to create many similar classes dynamically.

When you want to add methods or behavior to a class quickly.

When you want to avoid cluttering your code with many class names.

When experimenting or testing small pieces of code.

Syntax

Ruby

my_class = Class.new(superclass = Object) do
  # methods and definitions here
end

You can pass a superclass to inherit from, or leave it blank to inherit from Object.

The block defines methods and behavior inside the new class.

Examples

This creates a new class named MyClass with a method greet that returns "Hello!".

Ruby

MyClass = Class.new do
  def greet
    "Hello!"
  end
end

Here, Dog inherits from Animal and overrides the speak method.

Ruby

Animal = Class.new do
  def speak
    "..."
  end
end

Dog = Class.new(Animal) do
  def speak
    "Woof!"
  end
end

This creates an unnamed class, makes an object, and calls its method.

Ruby

anonymous = Class.new do
  def info
    "I am anonymous"
  end
end

obj = anonymous.new
puts obj.info

Sample Program

This program creates a Greeter class dynamically with a greet method. Then it creates an object and prints a greeting.

Ruby

Greeter = Class.new do
  def greet(name)
    "Hello, #{name}!"
  end
end

g = Greeter.new
puts g.greet("Alice")

Important Notes

You can assign the new class to a constant to use it later by name.

Classes created this way behave like normal classes.

Use this technique to keep your code flexible and DRY (Don't Repeat Yourself).

Summary

Class.new creates a new class dynamically.

You can add methods inside the block.

It helps make quick, custom classes without writing full class definitions.

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