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 Classis created and assigned to a global constant ( Namein this case). When Name.newis called to create a new object, the newmethod in Classis run by default. This can be demonstrated by overriding newin 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
A
N
S
T
Class Public methods
Class.new(super_class=Object) => a_class

Creates a new anonymous (unnamed) class with the given superclass (or Objectif 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;
}
Instance Public methods
class.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
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;
}
class.new(args, ...) => obj

Calls allocateto 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.

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;
}
class.superclass → a_super_class or nil

Returns the superclass of class, or nil.

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;
}
to_yaml( opts = {} )
# File lib/yaml/rubytypes.rb, line 5
def to_yaml( opts = {} )
        raise TypeError, "can't dump anonymous class %s" % self.class
end