¿Cómo funcionan las clases y los objetos en Ruby?

Question

Accepted Answer

Ruby es **puro orientado a objetos** — defines **clases** (planos) y creas **objetos** (instancias). Las clases usan `initialize` como constructor, `@variables` para el estado de la instancia, y modificadores de acceso para encapsulación. La sintaxis de clases en Ruby es limpia y expresiva.

## Por qué es importante

Las clases y los objetos son fundamentales en Ruby, que es un lenguaje puro orientado a objetos, por lo que comprenderlos es esencial para cualquier desarrollo en Ruby — prácticamente todo el código Ruby (y marcos como Rails) está organizado en clases.

Saber cómo definir clases con el constructor **`initialize`**, usar **`@instance` variables** para estado por objeto (y que son privadas por defecto, requiriendo métodos accessor para exponerlas), definir métodos de instancia y **métodos de clase** (`def self.method`), y aplicar control de acceso (`private`/`protected`) es conocimiento fundamental del día a día.

Una conveniencia especialmente importante de Ruby es **`attr_accessor`/`attr_reader`/`attr_writer`**, que generan automáticamente métodos getter/setter para variables de instancia — eliminando código repetitivo y reflejando la elegancia de Ruby (en lugar de escribir getters/setters explícitos como en muchos lenguajes, los declaras en una línea).

Comprender la sintaxis limpia de clases de Ruby, el modelo de constructor y variable de instancia, métodos accessor, y métodos de clase es material fundamental y obligatorio para orientación a objetos en Ruby.

Dado que las clases son cómo modelas datos y comportamiento en todas las aplicaciones Ruby, y dado que las características de clases de Ruby (la convención `initialize`, las variables de instancia `@`, los accessores `attr_*`, control público/privado) son cómo se escribe Ruby orientado a objetos, dominarlas es conocimiento esencial y fundamental que respalda todo desarrollo en Ruby y es un punto de partida frecuente para entender la naturaleza orientada a objetos del lenguaje.

```ruby
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"
```

El método `initialize` es el constructor (llamado automáticamente por `.new`), y las variables de instancia `@name` mantienen estado por objeto. Los métodos se definen con `def`.

## Accediendo a variables de instancia (se necesitan métodos accessor)

```ruby
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
```

Las variables de instancia (`@name`) son privadas por defecto — las expones con métodos accessor. **`attr_accessor`**/`attr_reader`/`attr_writer` generan estos métodos getter/setter automáticamente (una conveniencia de Ruby).

## Control de acceso y métodos de clase

```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
```

Los métodos son públicos por defecto; `private`/`protected` restringen el acceso. `def self.method` define un **método de clase** (llamado en la clase misma).