Clases y objetos
La Programación Orientada por Objetos (POO) te va a permitir escribir código más claro y fácil de mantener en el tiempo.
Los conceptos principales de la POO son las clases y los objetos.
Las clases son plantillas a partir de las cuáles se crean objetos.
Los objetos son instancias de una clase.

Sintaxis

La sintaxis que se utiliza para crear una clase es la siguiente:
1
class Person
2
end
Copied!
Las clases siempre se nombran en mayúsculas utilizando CamelCase (cada palabra comienza con mayúscula).
La sintaxis para crear un objeto es la siguiente:
1
Person.new
Copied!

Métodos

En las clases puedes definir métodos que después vas a poder invocar sobre los objetos:
1
class Person
2
def greet
3
"Hola"
4
end
5
end
Copied!
Para utilizar el método primero debemos crear una instancia (objeto) de la clase:
1
p1 = Person.new
2
puts p1.greet # imprime "Hola"
3
puts p1.greet # imprime "Hola"
Copied!

Métodos privados

Es posible crear métodos que sólo son visibles dentro de la clase. Para hacerlo debemos utilizar la palabra clave private. Todos los métodos que van debajo de esa palabra private son privados:
1
class Person
2
...
3
4
private
5
def secret_method
6
puts "Este es un método privado"
7
end
8
end
Copied!

Constructor

Las clases pueden tener un método especial llamado initialize que se llama cada vez que se crea un objeto con .new:
1
class Person
2
def initialize
3
puts "creando nueva persona ..."
4
end
5
6
...
7
end
8
9
Person.new # imprime "creando nueva persona ..."
Copied!
El constructor puede recibir argumentos:
1
class Person
2
def initialize(name)
3
puts "creando nueva persona llamada #{name}"
4
end
5
...
6
end
Copied!
1
Person.new("Pedro") # imprime "creando nueva persona llamada Pedro"
2
Person.new("Juan") # imprime "creando nueva persona llamada Juan"
Copied!

Atributos

Un objeto puede guardar información en atributos, variables que están asociadas a un objeto particular.
A los atributos también se les conoce como variables de instancia.
Los atributos se definen en la clase utilizando el caracter @ al principio. Veamos cómo se utiliza.
1
class Person
2
def initialize(name)
3
@name = name
4
end
5
6
def greet(other_person_name)
7
"Hola #{other_person_name}, me llamo #{@name}"
8
end
9
end
Copied!

Visibilidad de los atributos

Por defecto, los atributos son privados, es decir, solo son visibles dentro de la clase. Si queremos exponerlos al mundo exterior tenemos que crear métodos para leerlos y modificarlos (a estos métodos se les conoce como getters y setters).
1
class Person
2
def initialize(name)
3
@name = name
4
end
5
6
def greet(other_person_name)
7
"Hola #{other_person_name}, me llamo #{@name}"
8
end
9
10
# Método para que @name pueda ser leído desde afuera
11
def name
12
@name
13
end
14
15
# Método para que @name pueda ser modificado desde afuera
16
def name=(name)
17
@name = name
18
end
19
end
Copied!
El método para leer el atributo se debe llamar igual que el atributo y generalmente retorna el valor del atributo.
El método para escribir el atributo se debe llamar igual que el atributo pero con un = al final del atributo.
Ruby tiene un atajo para no tener que escribir siempre el getter y setter de todos los atributos, el attr_accessor. El siguiente código es equivalente al anterior:
1
class Person
2
attr_accessor :name
3
4
def initialize(name)
5
@name = name
6
end
7
8
def greet(other_person_name)
9
"Hola #{other_person_name}, me llamo #{@name}"
10
end
11
end
Copied!
Si no quieres que el atributo pueda ser modificado utiliza attr_reader en vez de attr_accessor.
Si no quieres que el atributo pueda ser leído utiliza attr_writer en vez de attr_accessor.

En Ruby (casi) todo es un objeto

Cuando haces algo como "Hola".length estás llamando el método length de una clase llamada String. De hecho podemos ser más explícitos y crear la cadena de la siguiente forma:
1
$ irb
2
> s = String.new("Hola")
3
=> "Hola"
4
> s.length
5
=> 4
Copied!
Cuando creas una cadena con comillas, Ruby lo traduce a String.new("..."). Lo mismo ocurre con los arreglos y los hashes, que se crean con las clases Array y Hash respectivamente.
Puedes consular la documentación de las clases String, Array y Hash para ver todos los métodos que puedes utilizar.
Los números también son objetos en Ruby y puedes llamar métodos sobre ellos:
1
$ irb
2
> 2.even?
3
=> true
Copied!
De hecho, cuando sumas dos números en Ruby (p.e. 1 + 2) realmente estás llamando el método + sobre el primer número y le estás pasando el segundo número como argumento!
1
$ irb
2
> 1+(2)
3
=> 3
Copied!
Para ver todos los métodos que tienen los números puedes consultar la documentación de Fixnum, la clase que representa números en Ruby (fíjate en todos los métodos que parecen operadores como +, =, etc.).

Conociendo la clase de un objeto

Todos los objetos tienen un método especial llamado class que retorna la clase que se utilizó para crearlos:
1
$ irb
2
> 2.class
3
=> Fixnum
4
> "Hola".class
5
=> "String"
Copied!

self

Por último, es muy probable que veas la palabra clave self en las clases. Veamos para qué sirve con un ejemplo:
1
class Person
2
def initialize
3
random_number = self.random_number
4
end
5
6
def random_number
7
# generates random number
8
end
9
end
Copied!
Con self podemos ser más explícitos para referirnos a un método del objeto. En este caso, estamos almacenando el resultado del método random_number en una variable random_number. Como tienen el mismo nombre utilizamos self para indicarle a Ruby que nos estamos refiriendo al método y no a la variable.
self se utiliza generalmente cuando hay colisiones de nombres entre un método y una variable.
Last modified 3yr ago