Class: Class

Inherits:
Module show all
Defined in:
object.c,
class.c,
object.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)-----------...

Instance Method Summary collapse

Methods inherited from Module

#<, #<=, #<=>, #==, #===, #>, #>=, #alias_method, #ancestors, #append_features, #attr, #attr_accessor, #attr_reader, #attr_writer, #autoload, #autoload?, #class_eval, #class_exec, #class_variable_defined?, #class_variable_get, #class_variable_set, #class_variables, #const_defined?, #const_get, #const_missing, #const_set, #const_source_location, constants, #constants, #define_method, #deprecate_constant, #extend_object, #extended, #freeze, #include, #include?, #included, #included_modules, #initialize_clone, #initialize_copy, #instance_method, #instance_methods, #method_added, #method_defined?, #method_removed, #method_undefined, #module_eval, #module_exec, #module_function, #name, nesting, #prepend, #prepend_features, #prepended, #private, #private_class_method, #private_constant, #private_instance_methods, #private_method_defined?, #protected, #protected_instance_methods, #protected_method_defined?, #public, #public_class_method, #public_constant, #public_instance_method, #public_instance_methods, #public_method_defined?, #refine, #remove_class_variable, #remove_const, #remove_method, #ruby2_keywords, #singleton_class?, #to_s, #undef_method, used_modules, #using

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

Overloads:

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

    Yields:

    • (mod) 


1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
 
# File 'object.c', line 1997

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 (rb_check_arity(argc, 0, 1) == 0) {
  super = rb_cObject;
    }
    else {
        super = argv[0];
  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;
}

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

Returns:



2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
 
# File 'object.c', line 2056

static VALUE
rb_class_alloc_m(VALUE klass)
{
    rb_alloc_func_t allocator = class_get_alloc_func(klass);
    if (!rb_obj_respond_to(klass, rb_intern("allocate"), 1)) {
        rb_raise(rb_eTypeError, "calling %"PRIsVALUE".allocate is prohibited",
                 klass);
    }
    return class_call_alloc_func(allocator, klass);
}

#inherited(_y) ⇒ Object (private)

call-seq:

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



1155
1156
1157
1158
1159
 
# File 'object.c', line 1155

static VALUE
rb_obj_dummy1(VALUE _x, VALUE _y)
{
    return rb_obj_dummy();
}

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

Returns:



2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
 
# File 'object.c', line 2146

static VALUE
rb_class_s_new(int argc, const VALUE *argv, VALUE klass)
{
    VALUE obj;

    obj = rb_class_alloc(klass);
    rb_obj_call_init_kw(obj, argc, argv, RB_PASS_CALLED_KEYWORDS);

    return obj;
}

#superclass ⇒ 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 does not have a parent class:

BasicObject.superclass   #=> nil

Returns:

  • (nil) 


2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
 
# File 'object.c', line 2220

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;
}