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 end class Name end n = Name.new 

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

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 like class_eval .

fred = Class.new do def meth1 "hello" end def meth2 "bye" end end a = fred.new #=> #: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.

static VALUE rb_class_initialize(int argc, VALUE *argv, VALUE klass) < VALUE super; if (RCLASS_SUPER(klass) != 0 || klass == rb_cBasicObject) < rb_raise(rb_eTypeError, "already initialized class"); >if (argc == 0) < super = rb_cObject; >else < rb_scan_args(argc, argv, "01", &super); rb_check_inheritable(super); if (super != rb_cBasicObject && !RCLASS_SUPER(super)) < rb_raise(rb_eTypeError, "can't inherit uninitialized class"); >> RCLASS_SET_SUPER(klass, super); rb_make_metaclass(klass, RBASIC(super)->klass); rb_class_inherited(super, klass); rb_mod_initialize(klass); return klass; >

Public Instance Methods

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 

static VALUE rb_class_alloc(VALUE klass) < VALUE obj; rb_alloc_func_t allocator; if (RCLASS_SUPER(klass) == 0 && klass != rb_cBasicObject) < rb_raise(rb_eTypeError, "can't instantiate uninitialized class"); >if (FL_TEST(klass, FL_SINGLETON)) < rb_raise(rb_eTypeError, "can't create instance of singleton class"); >allocator = rb_get_alloc_func(klass); if (!allocator) < rb_undefined_alloc(klass); >RUBY_DTRACE_CREATE_HOOK(OBJECT, rb_class2name(klass)); obj = (*allocator)(klass); if (rb_obj_class(obj) != rb_class_real(klass)) < rb_raise(rb_eTypeError, "wrong instance allocation"); >return 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.

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 

VALUE rb_class_superclass(VALUE klass) < VALUE super = RCLASS_SUPER(klass); if (!super) < if (klass == rb_cBasicObject) return Qnil; rb_raise(rb_eTypeError, "uninitialized class"); >while (RB_TYPE_P(super, T_ICLASS)) < super = RCLASS_SUPER(super); >if (!super) < return Qnil; >return super; >

Private Instance Methods

Callback invoked whenever a subclass of the current class is created.

class Foo def self.inherited(subclass) puts "New subclass: #" end end class Bar  Foo end class Baz  Bar end 

New subclass: Bar New subclass: Baz