Ruby est orienté objet pur — vous définissez des classes (plans) et créez des objets (instances). Les classes utilisent initialize comme constructeur, @variables pour l'état de l'instance, et des modificateurs d'accès pour l'encapsulation. La syntaxe des classes Ruby est propre et expressive.
class Person
def initialize(name, age) # the CONSTRUCTOR (called on .new)
@name = name # @ → instance variable (per object)
@age = age
end
def greet # an instance method
"Hi, I'm #{@name}"
end
end
person = Person.new("Ann", 30) # create an instance (calls initialize)
person.greet # "Hi, I'm Ann"
La méthode initialize est le constructeur (appelée automatiquement par .new), et les variables d'instance @name conservent l'état par objet. Les méthodes sont définies avec def.
class Person
attr_accessor :name # generates getter AND setter for @name
attr_reader :age # getter only (read-only)
def initialize(name, age)
@name = name
@age = age
end
end
person.name # "Ann" — getter
person.name = "Bob" # setter
Les variables d'instance (@name) sont privées par défaut — vous les exposez avec des méthodes accesseur. attr_accessor/attr_reader/attr_writer génèrent automatiquement ces méthodes getter/setter (une commodité de Ruby).
class Account
def deposit(amount) # public by default
update_balance(amount)
end
private # methods below are PRIVATE
def update_balance(amount)
@balance += amount
end
def self.create # CLASS method (self.) — called on the class, not an instance
new(...)
end
end
Account.create # class method
Les méthodes sont publiques par défaut ; private/protected restreignent l'accès. def self.method définit une méthode de classe (appelée sur la classe elle-même).
Les classes et les objets sont fondamentaux en Ruby, qui est un langage pur orienté objet, donc les comprendre est essentiel pour tout développement en Ruby — pratiquement tout code Ruby (et les frameworks comme Rails) est organisé en classes.
Savoir comment définir des classes avec le constructeur initialize, utiliser des variables @instance pour l'état par objet (et qu'elles sont privées par défaut, nécessitant des méthodes accesseur pour les exposer), définir des méthodes d'instance et de classe (def self.method), et appliquer un contrôle d'accès (private/protected) est une connaissance fondamentale quotidienne.
Une commodité Ruby particulièrement importante est attr_accessor/attr_reader/attr_writer, qui génèrent automatiquement des méthodes getter/setter pour les variables d'instance — éliminant le boilerplate et reflétant l'élégance de Ruby (au lieu d'écrire des getters/setters explicites comme dans de nombreux langages, vous les déclarez en une ligne).
Comprendre la syntaxe propre des classes Ruby, le modèle de constructeur et de variable d'instance, les méthodes accesseur, et les méthodes de classe est du matériel fondamental essentiel pour la Ruby orientée objet.
Comme les classes sont la façon dont vous modélisez les données et le comportement dans les applications Ruby, et que les fonctionnalités des classes Ruby (la convention initialize, les variables d'instance @, les accesseurs attr_*, le contrôle public/privé) sont la façon dont Ruby orienté objet est écrit, les maîtriser est une connaissance essentielle et fondamentale qui sous-tend tout développement Ruby et est souvent un point de départ pour comprendre la nature orientée objet du langage.