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) | ^ | | | +----------------+
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.
/* * call-seq: * Class.new(super_class=Object) => a_class * * Creates a new anonymous (unnamed) class with the given superclass * (or <code>Object</code> if no parameter is given). You can give a * class a name by assigning the class object to a constant. * */ static VALUE rb_class_initialize(argc, argv, klass) int argc; VALUE *argv; VALUE klass; { VALUE super; if (RCLASS(klass)->super != 0) { rb_raise(rb_eTypeError, "already initialized class"); } if (rb_scan_args(argc, argv, "01", &super) == 0) { super = rb_cObject; } else { rb_check_inheritable(super); } RCLASS(klass)->super = super; rb_make_metaclass(klass, RBASIC(super)->klass); rb_mod_initialize(klass); rb_class_inherited(super, klass); return klass; }
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 end klass.allocate.initialized? #=> false
/* * call-seq: * class.allocate() => obj * * Allocates space for a new object of <i>class</i>'s class and does not * call initialize on the new instance. The returned object must be an * instance of <i>class</i>. * * klass = Class.new do * def initialize(*args) * @initialized = true * end * * def initialized? * @initialized || false * end * end * * klass.allocate.initialized? #=> false * */ VALUE rb_obj_alloc(klass) VALUE klass; { VALUE obj; if (RCLASS(klass)->super == 0) { rb_raise(rb_eTypeError, "can't instantiate uninitialized class"); } if (FL_TEST(klass, FL_SINGLETON)) { rb_raise(rb_eTypeError, "can't create instance of virtual class"); } obj = rb_funcall(klass, ID_ALLOCATOR, 0, 0); if (rb_obj_class(obj) != rb_class_real(klass)) { rb_raise(rb_eTypeError, "wrong instance allocation"); } return obj; }
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
/* * Not documented */ static VALUE rb_obj_dummy() { return Qnil; }
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.
/* * call-seq: * class.new(args, ...) => obj * * Calls <code>allocate</code> to create a new object of * <i>class</i>'s class, then invokes that object's * <code>initialize</code> method, passing it <i>args</i>. * This is the method that ends up getting called whenever * an object is constructed using .new. * */ VALUE rb_class_new_instance(argc, argv, klass) int argc; VALUE *argv; VALUE klass; { VALUE obj; obj = rb_obj_alloc(klass); rb_obj_call_init(obj, argc, argv); return obj; }
Returns the superclass of class, or nil.
File.superclass #=> IO IO.superclass #=> Object Object.superclass #=> nil
/* * call-seq: * class.superclass -> a_super_class or nil * * Returns the superclass of <i>class</i>, or <code>nil</code>. * * File.superclass #=> IO * IO.superclass #=> Object * Object.superclass #=> nil * */ static VALUE rb_class_superclass(klass) VALUE klass; { VALUE super = RCLASS(klass)->super; if (!super) { rb_raise(rb_eTypeError, "uninitialized class"); } if (FL_TEST(klass, FL_SINGLETON)) { super = RBASIC(klass)->klass; } while (TYPE(super) == T_ICLASS) { super = RCLASS(super)->super; } if (!super) { return Qnil; } return super; }