- Inheritance
- < Module
Classes in Ruby are first-class objects—each is an instance of class Class.
When a new class is created (typically using class Name … end), an object of type Class is created 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 oldNew new
def new(*args)
print "Creating a new ", self.name, "\n"
oldNew(*args)
end
end
class Name
end
n = 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 meta-classes. All metaclasses are instances of the class `Class’.
+------------------+
| |
Object---->(Object) |
^ ^ ^ ^ |
| | | | |
| | +-----+ +---------+ |
| | | | |
| +-----------+ | |
| | | | |
+------+ | Module--->(Module) |
| | ^ ^ |
OtherClass-->(OtherClass) | | |
| | |
Class---->(Class) |
^ |
| |
+----------------+
Methods
Class
| Visibility | Signature |
|---|---|
| public | new (...) |
Instance
| Visibility | Signature |
|---|---|
| public | allocate () |
| public | inherited (p1) |
| public | new (...) |
| public | superclass () |
| public | to_yaml ( opts = {} ) |
Class Method Detail
Class.new(super_class=Object) => 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.
Instance Method Detail
class.allocate() => obj
Allocates space for a new object of class‘s class. The returned object must be an instance of class.
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
end
class Bar < Foo
end
class Baz < Bar
end
produces:
New subclass: Bar New subclass: Baz
class.new(args, ...) => obj
Calls allocate to create a new object of class‘s class, then invokes that object‘s initialize method, passing it args. This is the method that ends up getting called whenever an object is constructed using .new.
class.superclass → a_super_class or nil
Returns the superclass of class, or nil.
File.superclass #=> IO IO.superclass #=> Object Object.superclass #=> nil