La machine à jus de Johannes

Les classes sont un concept central en programmation orientée objet. En Crystal, tout est un objet, chaque objet possède un type et peut répondre à certaines méthodes. Les classes sont des plans qui servent à créer des objets : elles fournissent des valeurs initiales pour l'état, comme les variables, et des implémentations de comportement, comme les méthodes. Les objets sont des instances de classe qui contiennent toutes les variables d'instance et les états.

Définition d'une classe

Une classe se définit à l'aide du mot-clé class, suivi du nom de la classe écrit en UpperCamelCase.

class Account
end

Crée une instance

Pour créer une instance d'une classe, appelle le nom de la classe à l'aide de la méthode new.

class Account
end

account = Account.new

Dans l'exemple ci-dessus, la variable account est une instance de la classe Account.

Lors de la création d'une instance, une méthode spéciale appelée initialize joue le rôle de constructeur. Elle est appelée lorsqu'une instance est créée. Le constructeur permet de définir l'état initial de l'instance. La méthode initialize peut prendre des arguments, qui sont passés lors de la création d'une instance.

class Account
  def initialize(number)
    5 + number # => 9
  end
end

Account.new(4)

class Account
  def initialize(number)
    5 + number
  end
end

Account.new(4)
# => #<Account:0x7f5dc33dcea0>

Méthodes d'instance

Une méthode d'instance est une méthode disponible pour une instance d'une classe, et qui peut être appelée sur cette instance. Les méthodes d'instance se définissent à l'aide du mot-clé def, suivi du nom de la méthode. Elles sont définies à l'intérieur de la définition de la classe.

class Account
  def balance
    100
  end
end

account = Account.new
account.balance # => 100

Variables d'instance

Les variables d'instance sont des variables disponibles dans toutes les méthodes de l'instance. Pour accéder à une variable d'instance, tu dois définir une méthode d'instance. Elles peuvent être initialisées dans la méthode initialize. Elles se définissent à l'aide du préfixe @.

class Account
  def initialize
    @balance = 100
  end

  def balance
    @balance
  end
end

account = Account.new
account.balance
# => 100

Les variables d'instance peuvent aussi être définies directement dans la définition de la classe.

class Account
  @age = 0
end

Variables d'instance avec initialisation

Les variables d'instance peuvent être initialisées avec un argument passé à la méthode initialize. Comme Crystal ne peut pas déduire le type de l'argument utilisé lors de l'initialisation, il faut le préciser. Si tu veux en savoir plus à ce sujet, tu peux lire : l'inférence de type. Pour préciser le type de la variable, tu peux utiliser le symbole :, suivi du type. Par exemple, si tu veux créer une variable d'instance appelée balance de type Int32, tu peux faire comme ceci : @balance : Int32. Ou bien, si tu veux créer une variable d'instance appelée raining de type Bool, tu peux faire comme ceci : @raining : Bool.

Il y a plusieurs façons de faire : soit déclarer l'argument avec son type dans la méthode initialize, puis affecter l'argument à la variable d'instance, comme dans l'exemple suivant :

class Account
  def initialize(balance : Int32)
    @balance = balance
  end

  def balance
    @balance
  end
end

account = Account.new(1)
account_2 = Account.new(5)

account.balance
# => 1

account_2.balance
# => 5

Une autre façon consiste à déclarer le type de la variable d'instance dans la définition de la classe, sous la forme @<variable> : <Type>, comme dans l'exemple suivant :

class Weather

  @raining : Bool

  def initialize(raining)
    @raining = raining
  end

  def raining
    @raining
  end
end

weather = Weather.new(true)
weather.raining
# => true

Modifie les variables d'instance

Les méthodes peuvent modifier les variables d'instance. Ces méthodes peuvent être appelées sur l'instance de la classe. Lorsqu'une méthode modifie une variable d'instance, ce changement n'est visible que dans l'instance de la classe sur laquelle tu l'as appelée.

class Account
  def initialize(balance : Int32)
    @balance = balance
  end

  def withdraw(amount)
    @balance -= amount
  end

  def balance
    @balance
  end
end

account = Account.new(10)
account_2 = Account.new(10)
account.balance
# => 10

account_2.balance
# => 10

account.withdraw(5)
account.balance
# => 5

account_2.balance
# => 10

Méthodes de classe

Les méthodes de classe sont des méthodes définies pour une classe, mais pas pour ses instances. Elles offrent un moyen de créer des méthodes qui ne dépendent pas de l'état de l'instance. Elles se définissent à l'aide du mot-clé def, suivi de self.<method name>. self est une référence à l'espace de noms depuis lequel self est appelé. Ici, il désigne la classe Account. Cela reviendrait au même que d'écrire Account., mais self. est la façon privilégiée.

class Account
  def self.balance
    100
  end
end

Account.balance
# => 100