Class Definition

The definition of a class by the user is done with the "class" statement, followed by a block of statements containing the class body, with the class definitions. The class name is a constant, and must begin with an uppercase letter. The "class" statement is an expression and returns the last evaluated statement, usually a "def", returning: "nil".

When the statements defining the class are executed by the Ruby interpreter, the receiver, pointed by the keyword: "self" is the class itself, as an instance of "Class", but into the definition of instance methods "self" is the instance being created.

class  Classname < Superclasse        # class definition (inherits Superclasse)

      include Modulename,Othername         # the class includes these modules

      attr_accessor :x,:y         # creation of accessor methods
      attr_reader   :u,:w
      attr_reader   "v","z"

      @@n=0                       # a class variable

      def initialize(x,y=3)       # class constructor

         @x,@y=x,y                # instance variables
                                  # must initialized in the constructor

         super( a, b, c )         # calls the constructor of the parent

      def self.classmethodname    # definition of a class method
      class << self               # block containing class methods
         def nome(..)

      def metodo                  # definition of an instance method

      to_s                        # override of a function of a parent class
        "description class"

      protected                   # section for protected methods

         here protected methods

      private                     # section for private methods

         here private methods


The method named: "initialize" is the instance constructor; it is a special method, called in an automated way at the instance creation. In this method the variables needed by the instance are initialized.

In the example above the method "super" is used by "initialize" to call the constructor of the parent class, which is not automatically called at the instance creation.


The "<" symbol is for inheritance. Ruby has only single inheritance, but classes can include in their namespace functions and classes from modules (mixins). Each class inherits the class Object in an automated way, there is no need to specify this dependency.

The method: "super" can be used into a class function, to call the method of the parent with the same name of the function.

There are some methods to look at the structure of a class hierarchy:

Classname.superclass   # show the inherited class
Classname.ancestors    # show all the inherited classes (ancestors)
Classname.methods      # show all the methods
Classname.constants    # show the constants defined in the class

Classname.included_modules      # list of the included modules
Classname.include?(Nomemodulo)  # tests if a module is included

Classname.respond_to?("string")  # tests if a method exists
Classname.respond_to?(:symbol)   # tests if a method exists, using a symbol

Class Instances

To instantiate a class the "new" method must be called; the "new" method has arguments that are passed to the class constructor: the "initialize" function., arg, arg2)

instancename.instance_of? Classname     # to test if instance of a class
instancename.kind_of? Classname         # to test if a class is among ancestors

each instance has an unique identifier, which can be obtained by the method: ".object_id".

Class Methods and Instance Methods

In Ruby there are class methods and instance methods: class methods can only be called on classes and instance methods can only be called on an instance of a class.

But indeed, class methods also are instance methods: instance methods of that instance of Class which is the class definition.

The syntax for calling class and instance methods is:

Classname.classmethodname(..) # for class methods

instance.methodname(..)    # for instance methods

By default the methods are instance methods; in the class definition, class methods are prefixed with the keyword "self", or by the class name, but can also be defined in the class block, into a special block delimited by: "class << self ... end"

class Classe

     def Classe.func
        print("class method")
     def self.func2
        print("class method")

     def func3
        print("Instance method")

class Classe2

    class << self       # other way to specify class methods
       def func
           class method

Accessor Functions and Instance Variables

The rule is that all variables defined in a class are private to the class and are not visible outside.

To make an instance variable accessible outside the class there are special function, (accessor functions) defined in a way similar to:

class A
   def var_a           # read access ids done with: *A.var_a*
     return @var_a     # using the function as the var_a name
   def var_a=(v)       # write access is done with: *A.var_a=123*
     @var_a=v          # using the function as the var_a name,
   end                 # with omitted parenthesis

The accessor statements automatically make these functions for the specified variables, allowing for a syntax like: "instancename.variable" , where "variable" is an accessor function which mimic the use of a instance attribute; but only functions and constants are visible outside a class instance, all variables are hidden.

Example of the accessor statement:

class Nomeclasse
    attr_accessor :x,:y   # makes accessors for @x,@y
    attr_reader   :z      # makes a read accessor for @z

    def initialize(x,y)   # constructor, called at object creation
       @y=y               # initialization of instance variables

    def to_s             # used by print functions to obtain a
      "#@x,#@y"          # string representing the instance
 end # of class

Instance variables should be initialized in the constructor. The class itself (the class definition) is an instance of the object Class, and variables defined out of the constructor are instance variables of the class as an instance of the Class object.

To print an instance of a class one have to define a to_s method, that returns a textual representation of the instance. There are also a modules (PP, PrettyPrint) to print a class instance:


require 'pp'
pp instancename  # => 1,2

Adding Methods to a Class

Methods can be added to a class outside the class block; to define a class method outside the class block the method has to be prefixed with the class name:

def Classname.classmethodname(..)

Singleton Methods

A method belonging to a single instance of a class is named "singleton method, "numeric" and "symbols" can't have singleton methods. A singleton method can be added to a specific instance in the following way:
def oggetto.funzione(..)

Also the following syntax can be used:

class << oggetto

    def func1(..)

    def func2( ..)

In the following a simple example of definition and usage of a singleton method:

def a.nome
   print "uno"

a.nome => uno

The term singleton class is used in Ruby for class instances with singleton methods, which is not the same as the singleton classes of languages like C++, which are classes with a single instance ... here the term "singleton" is a bit confusing.

In Ruby, classes with a single instance are built with the "singleton" module, which, mixed into a class, changes the class method "new", which become private and impossible to call; the methods "instance" is used, instead of "new", to make, or refer to, the single instance of the class.