Class: Class
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 class 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 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)-----------...
Instance Method Summary collapse
-
#allocate ⇒ Object
Allocates space for a new object of class’s class and does not call initialize on the new instance.
-
#inherited ⇒ Object
private
Not documented.
-
#initialize ⇒ Object
constructor
Creates a new anonymous (unnamed) class with the given superclass (or
Object
if no parameter is given). -
#new(args, ...) ⇒ Object
Calls
allocate
to create a new object of class’s class, then invokes that object’sinitialize
method, passing it args. -
#superclass ⇒ nil
Returns the superclass of class, or
nil
.
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, constants, #constants, #define_method, #extend_object, #extended, #freeze, #include, #include?, #included, #included_modules, #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, #singleton_class?, #to_s, #undef_method, #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 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.
1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 |
# File 'object.c', line 1734
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;
}
|
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
1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 |
# File 'object.c', line 1782
VALUE
rb_obj_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_raise(rb_eTypeError, "allocator undefined for %"PRIsVALUE,
klass);
}
#if !defined(DTRACE_PROBES_DISABLED) || !DTRACE_PROBES_DISABLED
if (RUBY_DTRACE_OBJECT_CREATE_ENABLED()) {
const char * file = rb_sourcefile();
RUBY_DTRACE_OBJECT_CREATE(rb_class2name(klass),
file ? file : "",
rb_sourceline());
}
#endif
obj = (*allocator)(klass);
if (rb_obj_class(obj) != rb_class_real(klass)) {
rb_raise(rb_eTypeError, "wrong instance allocation");
}
return obj;
}
|
#inherited ⇒ Object (private)
Not documented
907 908 909 910 911 |
# File 'object.c', line 907
static VALUE
rb_obj_dummy(void)
{
return Qnil;
}
|
#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.
1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 |
# File 'object.c', line 1836
VALUE
rb_class_new_instance(int argc, VALUE *argv, VALUE klass)
{
VALUE obj;
obj = rb_obj_alloc(klass);
rb_obj_call_init(obj, argc, argv);
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 hasn’t a parent class:
BasicObject.superclass #=> nil
1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 |
# File 'object.c', line 1866
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;
}
|