Class: Class

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain: self, ::Module
Instance Chain: self, ::Module
Inherits:	Module ::Object Module Class
Defined in:	object.c, class.c

Overview

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

produces:

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

Class Method Summary

.new(super_class = Object) ⇒ Class constructor

Creates a new anonymous (unnamed) class with the given superclass (or ::Object if no parameter is given).

::Module - Inherited

.constants	In the first form, returns an array of the names of all constants accessible from the point of call.
.nesting	Returns the list of `Modules` nested at the point of call.
.new	Creates a new anonymous module.

Instance Attribute Summary

::Module - Inherited

#singleton_class?

Returns true if mod is a singleton class or false if it is an ordinary class or module.

Instance Method Summary

#allocate ⇒ Object

Allocates space for a new object of class's class and does not call initialize on the new instance.
#new(args, ...) ⇒ Object

Calls #allocate to create a new object of class's class, then invokes that object's initialize method, passing it args.
#superclass ⇒ Class^?

Returns the superclass of class, or nil.
#inherited(subclass) private

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

::Module - Inherited

#<	Returns true if mod is a subclass of other.
#<=	Returns true if mod is a subclass of other or is the same as other.
#<=>	Comparison—Returns -1, 0, +1 or nil depending on whether `module` includes `other_module`, they are the same, or if `module` is included by `other_module`.
#==	Alias for Object#eql?.
#===	Case Equality—Returns `true` if obj is an instance of mod or and instance of one of mod's descendants.
#>	Returns true if mod is an ancestor of other.
#>=	Returns true if mod is an ancestor of other, or the two modules are the same.
#ancestors	Returns a list of modules included/prepended in mod (including mod itself).
#autoload	Registers filename to be loaded (using Kernel.require) the first time that module (which may be a ::String or a symbol) is accessed in the namespace of mod.
#autoload?	Returns filename to be loaded if name is registered as `autoload` in the namespace of mod.
#class_eval	Evaluates the string or block in the context of mod, except that when a block is given, constant/class variable lookup is not affected.
#class_exec	Evaluates the given block in the context of the class/module.
#class_variable_defined?	Returns `true` if the given class variable is defined in obj.
#class_variable_get	Returns the value of the given class variable (or throws a ::NameError exception).
#class_variable_set	Sets the class variable named by symbol to the given object.
#class_variables	Returns an array of the names of class variables in mod.
#const_defined?	Says whether mod or its ancestors have a constant with the given name:
#const_get	Checks for a constant with the given name in mod.
#const_missing	Invoked when a reference is made to an undefined constant in mod.
#const_set	Sets the named constant to the given object, returning that object.
#constants	Returns an array of the names of the constants accessible in mod.
#deprecate_constant,
#freeze	Prevents further modifications to mod.
#include	Invokes Module#append_features on each parameter in reverse order.
#include?	Returns `true` if module is included in mod or one of mod's ancestors.
#included_modules	Returns the list of modules included in mod.
#inspect	Alias for Module#to_s.
#instance_method	Returns an ::UnboundMethod representing the given instance method in mod.
#instance_methods	Returns an array containing the names of the public and protected instance methods in the receiver.
#method_defined?	Returns `true` if the named method is defined by mod (or its included modules and, if mod is a class, its ancestors).
#module_eval	Alias for Module#class_eval.
#module_exec	Alias for Module#class_exec.
#name	Returns the name of the module mod.
#prepend	Invokes Module#prepend_features on each parameter in reverse order.
#private_class_method	Makes existing class methods private.
#private_constant	Makes a list of existing constants private.
#private_instance_methods	Returns a list of the private instance methods defined in mod.
#private_method_defined?	Returns `true` if the named private method is defined by _ mod_ (or its included modules and, if mod is a class, its ancestors).
#protected_instance_methods	Returns a list of the protected instance methods defined in mod.
#protected_method_defined?	Returns `true` if the named protected method is defined by mod (or its included modules and, if mod is a class, its ancestors).
#public_class_method	Makes a list of existing class methods public.
#public_constant	Makes a list of existing constants public.
#public_instance_method	Similar to instance_method, searches public method only.
#public_instance_methods	Returns a list of the public instance methods defined in mod.
#public_method_defined?	Returns `true` if the named public method is defined by mod (or its included modules and, if mod is a class, its ancestors).
#remove_class_variable	Removes the definition of the sym, returning that constant's value.
#to_s	Returns a string representing this module or class.
#alias_method	Makes new_name a new copy of the method old_name.
#append_features	When this module is included in another, Ruby calls `append_features` in this module, passing it the receiving module in mod.
#attr,
#attr_accessor	Defines a named attribute for this module, where the name is symbol.`id2name`, creating an instance variable (`@name`) and a corresponding access method to read it.
#attr_reader	Creates instance variables and corresponding methods that return the value of each instance variable.
#attr_writer	Creates an accessor method to allow assignment to the attribute symbol`.id2name`.
#define_method	Defines an instance method in the receiver.
#extend_object	Extends the specified object by adding this module's constants and methods (which are added as singleton methods).
#extended	The equivalent of `included`, but for extended modules.
#included	Callback invoked whenever the receiver is included in another module or class.
#method_added	Invoked as a callback whenever an instance method is added to the receiver.
#method_removed	Invoked as a callback whenever an instance method is removed from the receiver.
#method_undefined,
#module_function	Creates module functions for the named methods.
#prepend_features	When this module is prepended in another, Ruby calls `prepend_features` in this module, passing it the receiving module in mod.
#prepended	The equivalent of `included`, but for prepended modules.
#private	With no arguments, sets the default visibility for subsequently defined methods to private.
#protected	With no arguments, sets the default visibility for subsequently defined methods to protected.
#public	With no arguments, sets the default visibility for subsequently defined methods to public.
#refine	Refine klass in the receiver.
#remove_const	Removes the definition of the given constant, returning that constant's previous value.
#remove_method	Removes the method identified by symbol from the current class.
#undef_method	Prevents the current class from responding to calls to the named method.
#using	Import class refinements from module into the current class or module definition.

Constructor Details

.new(super_class = Object) ⇒ `Class` .new(super_class = Object) {|mod| ... } ⇒ `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.

If a block is given, it is passed the class object, and the block is evaluated in the context of this class using class_eval.

fred = Class.new do
  def meth1
    "hello"
  end
  def meth2
    "bye"
  end
end

a = fred.new     #=> #<#<Class:0x100381890>: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.

Instance Method Details

#allocate ⇒ Object

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) (private)

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

#new(args, ...) ⇒ Object

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.

#superclass ⇒ `Class`^?

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

Class: Class

Overview

Class Method Summary

::Module - Inherited

Instance Attribute Summary

::Module - Inherited

Instance Method Summary

::Module - Inherited

Constructor Details

.new(super_class = Object) ⇒ Class .new(super_class = Object) {|mod| ... } ⇒ Class

Instance Method Details

#allocate ⇒ Object

#inherited(subclass) (private)

#new(args, ...) ⇒ Object

#superclass ⇒ Class?

.new(super_class = Object) ⇒ `Class` .new(super_class = Object) {|mod| ... } ⇒ `Class`

#superclass ⇒ `Class`^?