Ruby- Class
☞Ruby Programming for Beginners
☞Ruby on Rails for Complete Beginners
☞Beginners Ruby Programming Training — No Experience Required
☞The Professional Ruby on Rails Developer
☞Make Medium (medium.com) Clone in Ruby on Rails
☞The Complete Ruby on Rails Developer Course
Class
Classes in Ruby are first-class objects — -each is an instance of class Class.
Typically, you create a new class by using:
class Name
# some code describing the class behavior
end
When a new class is created, an object of type Class is initialized and assigned to a global constant (Name in this case).
When Name.new is called to create a new object, the new method in Class is run by default. This can be demonstrated by overriding new in Class:
class Class
alias old_new new
def new(*args)
print "Creating a new ", self.name, "\n"
old_new(*args)
end
endclass Name
endn = Name.new
produces:
Creating a new Name
Classes, modules, and objects are interrelated. In the diagram that follows, the vertical arrows represent inheritance, and the parentheses metaclasses. All metaclasses are instances of the class `Class’.
+---------+ +-...
| | |
BasicObject-----|-->(BasicObject)-------|-...
^ | ^ |
| | | |
Object---------|----->(Object)---------|-...
^ | ^ |
| | | |
+-------+ | +--------+ |
| | | | | |
| Module-|---------|--->(Module)-|-...
| ^ | | ^ |
| | | | | |
| Class-|---------|---->(Class)-|-...
| ^ | | ^ |
| +---+ | +----+
| |
obj--->OtherClass---------->(OtherClass)-----------...
Public Class Methods
new(super_class=Object) → a_class
new(super_class=Object) { |mod| … } → a_class
Creates a new anonymous (unnamed) class with the given superclass (or Object if no parameter is given). You can give a class a name by assigning the class object to a constant.
If a block is given, it is passed the class object, and the block is evaluated in the context of this class using class_eval.
fred = Class.new do
def meth1
"hello"
end
def meth2
"bye"
end
enda = fred.new #=> #<#<Class:0x100381890>:0x100376b98>
a.meth1 #=> "hello"
a.meth2 #=> "bye"
Assign the class to a constant (name starting uppercase) if you want to treat it like a regular class.
Public Instance Methods
allocate() → obj
Allocates space for a new object of class’s class and does not call initialize on the new instance. The returned object must be an instance of class.
klass = Class.new do
def initialize(*args)
@initialized = true
end def initialized?
@initialized || false
end
endklass.allocate.initialized? #=> false
new(args, …) → obj
Calls allocate to create a new object of class’s class, then invokes that object’s initializemethod, passing it args. This is the method that ends up getting called whenever an object is constructed using .new.
superclass → a_super_class or nil
Returns the superclass of class, or nil.
File.superclass #=> IO
IO.superclass #=> Object
Object.superclass #=> BasicObject
class Foo; end
class Bar < Foo; end
Bar.superclass #=> Foo
Returns nil when the given class does not have a parent class:
BasicObject.superclass #=> nil
Private Instance Methods
inherited(subclass)
Callback invoked whenever a subclass of the current class is created.
Example:
class Foo
def self.inherited(subclass)
puts "New subclass: #{subclass}"
end
endclass Bar < Foo
endclass Baz < Bar
end
produces:
New subclass: Bar
New subclass: Baz