Class: Class

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’.

                           +---------+             +-...
                           |         |             |
           BasicObject-----|-->(BasicObject)-------|-...
               ^           |         ^             |
               |           |         |             |
            Object---------|----->(Object)---------|-...
               ^           |         ^             |
               |           |         |             |
               +-------+   |         +--------+    |
               |       |   |         |        |    |
               |    Module-|---------|--->(Module)-|-...
               |       ^   |         |        ^    |
               |       |   |         |        |    |
               |     Class-|---------|---->(Class)-|-...
               |       ^   |         |        ^    |
               |       +---+         |        +----+
               |                     |
  obj--->OtherClass---------->(OtherClass)-----------...

Methods

allocate inherited new new superclass

Public Class methods

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.

Public Instance 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

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        #=> BasicObject
   class Foo; end
   class Bar < Foo; end
   Bar.superclass           #=> Foo

returns nil when the given class hasn‘t a parent class:

   BasicObject.superclass   #=> nil