Classes & Objects

Methods

You can define methods at the class level and the object level.

class MyClass
    def self.doSomething()
        ...
    end

    def doSomething()
        ...
    end
end

In the example above, we have defined doSomething twice. However the two methods are subtly different.

In the first case we've defined a class method. So, if we call MyClass.doSomething() then the code inside the first method will be used.

If we instantiate a MyClass object and call the same method again:

MyClass.new.doSomething()

where MyClass.new is an object instance of the MyClass class, then the second version of the method will be called.

The key is if the method has self in front of it, then it is a class method, otherwise it is an object method.

Inheritance

Inheritance is denoted with the < symbol:

class Subclass < Superclass
    ...
end

Object constructors

Object constructors are defined in the initialize method of a class:

class MyClass
    def initialize(parameter)
        @parameter = parameter
    end
end

instanceOfObject = MyClass.new("string argument")

Instance variables

Instance variables are denoted using the @ symbol before the variable. In the example above we see @parameter variable, which we set to the argument that is passed to the constructor. You can access instance variables. Taking the above example again, and assuming you have defined a getter somehow (see below), you would access parameter by calling

instanceOfObject.parameter

There is a shorthand for assigning instance variables in a constructor:

def initialize(@parameter : Type)
    ...
end

Getters

Instance variables do not have getters by default. You can either define your own, or you can use the property or getter keywords in front of the instance variable name:

class MyClass
  getter variable_one
  property variable_two
end

either of these keywords allows you to now call my_class_instance.variable_name

Class variables

Like instance variables, you can also define class variables using @@. These are like static variables in languages such as Java, and are consistent across all instances of a class.