Programación Orientada a Objetos en Ruby Comenzando la creación de nuestra clase

Clase 14 de 39 • Curso de Ruby

Contenido del curso

Introducción

Bases del lenguaje

Proyecto

Tomar examen

Comentarios

Oscar Téllez

student•

Reduciendo la definición de una clase:
Forma 1:

class Persona  
  def initialize(name) #Constructor
    @name = name #Variable de instancia se inicializa con el parametro en el constructor
  end

  def name #Getter
    @name
  end

  def name=(name) #Setter
     @name = name
     self
  end
end

Forma 2:

class Persona
  attr_accessor(:name)  # Genera getter y setter

  def initialize(name)
    @name = name
  end
end

Forma 3:

class Persona < Struct.new(:name) #Struct declara el constructor, getters y setters
end

Forma 4 en una linea:

Persona = Struct.new(:name)

Pablo Jaramillo

student•

Cool

Deyvi Conde

student•

Voy a enmarcar esto y lo pondré en mi sala.

Victor Manuel Franco Cañon

student•

POO en Ruby

Un objeto es un a colección de propiedades y métodos.
Las propiedades de un objeto son valores que están asociados a un objeto
En ruby generalmente las propiedades son llamadas variables de instancia,
en código estas variables se distinguen por llevar un “@” al inicializar
el nombre de la variable ej: @mi_nombre
Variables de instancia son identificadores que le pertenecen al objeto,
no a la clase por eso se llaman de “instancia”
Estas variables no están disponibles para (leer / modificar) fuera de la definición de la clase, para ello se deben utilizar métodos accesores
Los métodos accesores son de dos tipos, para leer y para escribir; aunque en ruby
no se identifican de la forma que se hace en otros programas con "SET/GET"
sino que y en ruby (geters/seters) se ven iguales al nombre de la propiedad y la
forma como se distinguen el uno del otro es que el método accesor “set” tiene el
operador igual “=”.
Hay métodos específicos para acceder a estas funcionalidades como (attr_accessor, attr_reader y attr_writer) y el método attr_accesor que realiza simultáneamente las funciones de escritura y lectura.

Conceptos extraídos de:

Eliaz Bobadilla

student•

Gracias!

Juan Carlos Ojeda Rivero

student•

Excelente aporte para complementar la clase. Gracias!

Orlando Jose Altamiranda Piñango

student•

La verdad el profesor explica como si estuviera contrarreloj, todo rápido y por encima, apenas aborda detalles de los conceptos, pero no puedo negar que si se aprende, he aprendido varias cosas, aunque la verdad, no como quisiera 😥 Nada es perfecto 😒

Gonzalo Peñaranda

student•

Piensa en que estos cursos son, como tal, un punto de partida: los proyectos y temas buscan dar una idea general de lo que se puede hacer con Ruby. Sin embargo, como los ajustes a tus necesidades o deseos ya te corresponde a ti, así como a cualquiera que esté tomando el curso.

Es mi humilde opinión.

María Sierra

student•

Creando clases

class → para declarar una clase.
def → es para definir los métodos.
initialize → es un método especial en Ruby para programación orientada a objeto que hace del constructor. Aquí se define se recibe o no recibe parámetros.
@variable → Para declarar variables de instancia se utiliza el arroba
self → esta hace referencia a la misma instancia, para que está forma podamos encadenar varios llamados.

class ClassName
    def initialize(parametros)
        @name = parametros
    end
end

En Ruby todas las instrucciones de código retornan algo, por eso no hay que utilizar la palabra return. Así que si dentro de los métodos no se específica el return, Ruby entiende que se va returnar el valor de la última instrucción dentro de ese bloque de código.

class Persona
    # Para declarar Métodos de clases
    def self.suggested_names
        ["Pepe","Pepito","Sutano"]
    end

    # constructor
    def initialize(name, age)
        @name = name
        @age = age
    end

    #métodos de instancia
    def name
        @name
    end

    def age
        @age
    end

    # persona.name = "pepe"
    def name=(name)
        @name = name
        self
    end

    def age=(age)
        @age = age
        self
    end
end

persona = Persona.new("pepe", 14)
puts "#{persona.name} tiene #{persona.age} años."

# si queremos llamar al método que creamos, llamamos a la clase
puts "Nombre sugeridos: \n#{Persona.suggested_names}"

Ruby gracias a la metaprogramación nos ofrece varios macros y varias utilidades para que no tengamos que escribir tanto código.

attr_accessor → es un macro que utilizamos para declarar propiedades de una clase.

#Class reducido primera forma
class Persona_2
    attr_accessor :name, :age

    # Para declarar Métodos de clases
    def self.suggested_names
        ["Pepe","Pepito","Sutano"]
    end

    # constructor
    def initialize(name, age)
        @name = name
        @age = age
    end
end

persona_2 = Persona_2.new("Carlos", 19)
puts "#{persona_2.name} tiene #{persona_2.age} años."

#Class reducido segunda forma
class Persona_3 < Struct.new(:name, :age)
    # Para declarar Métodos de clases
    def self.suggested_names
        ["Pepe","Pepito","Sutano"]
    end
end

persona_3 = Persona_3.new("Julian", 33)
puts "#{persona_3.name} tiene #{persona_3.age} años."

Victor Manuel Franco Cañon

student•

**POO clases y objetos **

Las clases y los objetos son los conceptos más importantes de la Programación Orientada por Objetos (POO), y están fuertemente relacionados. Los objetos se crean a partir de clases, y las clases sirven como plantillas para crear objetos. A los objetos también se les llama instancias de clase.
-En otros lenguajes el comportamiento de Initialize es comúnmente conocido como el “método constructor”, dicho método suele ejecutarse cuando creamos un objeto de una clase y mediante el cual inicializamos los valores que el objeto tendrá. En Ruby, siempre que llamemos al método new en una clase, la clase creará una nueva instancia de sí misma. Entonces, internamente, invocará el método initialize en el nuevo objeto. Esta característica nos permite pasar todos los argumentos mediante “.new” para que la clase disponga de estos.
- Debemos tener en cuenta que cuando hacemos tests deberemos simular dicho comportamiento.
- Cuando utilizamos el método “return” al interior del método “Initialize”, “return” es ignorado.

Conceptos extraídos

Alexei Teófilo Mamani Coaquira

student•

Tambien puedes ocupar attr_writters o attr_readers dependiendo del caso.

Iván Mora Mallqui

student•

Hola a todos,por favor alguien me podría explicar el uso de 'self' dentro de un metodo de instancia,gracias.

Diego Forero

Team Platzi•

hola, self hace referencia a la instancia de esa clase, si tienes atributos definidos en la clase se pueden acceder por medio de self, por ejemplo self.color, también los métodos definidos dentro de la clase se pueden llamar con self, por ejemplo self.get_color() si tienes un método dentro de la clase llamado get_color.

Alexei Teófilo Mamani Coaquira

student•

En realidad todo depende de donde utilizas self, esto se conoce como scopes si el self esta de manera directa en la clase hace re ferencia a la Clase no a la instancia, o si esta dentro de un metodo de clase, por eso si necesitas hacer un metodo de instancia no ocupas el self sino solo def method_instance, lo contrario cuando quieres hacer un metodo de clase, ocupas self por que en ese scope self hace referencia a la Clase como tal.

Esteban Salazar

student•

Jugando un poco con el código:

class Persona

#:name y :age permite generar los setter y getters automáticamente

  attr_accessor :name, :age


#Método que entrega nombre sugeridos
  def self.suggested_name
    ["Pepe", " Pedro", "Bodoque"]
  end

#creamos metodo constructor
  def initialize (name, age)
    #variables de instacia
    @name=name
    @age=age
  end
end
#método getter para name
  # def name
  #   return @name
  # end
  #
  # #method get for age
  # def age
  #   return @age
  # end
  #
  # #method for edit the name
  # def name= (name)
  #   @name=name
  #   self
  # end
  #
  # def age =(age)
  #   @age=age
  #   self

#creo una persona
persona1= Persona.new("Pedro",25)

#imprimo el nombre
puts persona1.name

puts "\nahora el nuevo nombre de la persona es: "

#edito el nombre
persona1.name="\ncarlos"

#imprimo nuevamente el nombre
puts persona1.name

persona1.age="32"
puts persona1.age

ROGER DIAZ

student•

Ok queria decir que el profesor hasta ahora ha sido muy malo, va muy rapido y no se detiene a explicar nada. pues bien me dure casi un dia entero porque al momento de correr el codigo en consola, ocurria "poo.rb:23: syntax error, unexpected `end', expecting end-of-input" este error me parecio bastante curioso porque si existia el end al final ya que el trabajo era bastante semejante a lo que habia hecho el profesor, lo hice de nuevo y realmente me quede en este punto porque no podia pasar, busque en stackoverflow y nada, realmente no encontre solucion en la web, luego me percate que

def name=(name)
        @name = name
        self

no estaba igual a

 def age = (age)
        @age = age
        self

la diferencia era que el def age(espacio)=(age) estaba ese espacio y era el que botaba el error. realmente lo que va del curso no se porque ocurre eso y el profesor eso no lo ha explicado, honestamente que mal que uno se encuentre en esa situacion, porque problemas de logica y de pronto cosas que a uno le toquen investigar vaya y venga pero un problema de sintaxis porque al profesor no se le ha dado la gana de explicar eso... creo que en platzi deberian verificar estar cosas porque los hace quedar bastante mal. Y no lo digo por rabia, he hecho mas de 30 cursos y hasta el momento este es el que he sentido con mas vacios. no se si mejore, porque igual lo seguire, pero les dejo la inquietud a ver si depronto lo mejoran.

Santiago Herrera Velásquez

student•

Cuando vi el struct derrepente pense en ruby con skin de c++😲😲😲

Ernesto Campos

student•

Clases con metodos

Camilo Castro

student•

Usando Structs:

require "pry"

# como hacer programacion orientada a objetos

class Persona < Struct.new(:name, :age)

=begin    
# he comentado este bloque de codigo po el uso de Struct en la clase, en la cual ya no se requiere el macro para la creació de las propiedades
# ir a línea 22
    # La implementación de un macro permite no usar getters y setters
    # se declaran las propiedades de esa clae, se le envían simbolos de como usar los atributos<code>
    # este genera los getters y setters de forma automática
    attr_accessor :name, :age
=end    
    
    # metodos de clase: 
    def self.suggested_names
        # retorna un arreglo con sugerencias para nombres en la clase
        ["Pepe", "Pepito", "Sutano", "Mengano", "Camilo"]
    end
=begin    
# he comentado este bloque de código por el uso de Struct, el cual ya no requiere un constructor
# sino que las propiedades le son enviadas cómo simbolos y se encarga de la creación de ellas
# y el manejo de los getters y setters para ella.
    # ----------------------------------
    # metodos de instancia: 
    # al ser una clase, se requiere un constructor, en ruby es initialize
    # será un metodo y requiere ser creado usando la palabra reservada def
    def initialize(name, age)
        # para declarar variables de instancia se utiliza el arroba
        # la variable instancia de esta clase se va a inicializar con el parametro que nos pasen en el constructor 
        @name = name
        @age = age
    end
=end
=begin
# he comentado los getter y setter ya que no son necesarios al usar un macro llamado attribute accesor (attr_accessor)     
    # crearemos algunos metodos getters para poder acceder a las propiedades de esta clase.
    # para esto se utiliza la palabra reservada def, y se retorna la propiedad de esta clase.
    #getter
    def name
        # retorno implicito, no se usa palabra return
        # en ruby todas las instrucciones de codigo retornan algo, dentro de los metodos si no se usa return, ruby entiende que se retorna el valor de la ultima instruccion
        @name
    end
    
    def age
        @age
    end
    
    #setter
    # persona.name = "pepe"
    def name=(name)   # el igual = debe ir sin espacios
        @name = name
        self  # self hace referencia a la misma instancia
    end
    
    # Al tener self podemos asignar las propiedades a los objetos de la clase de la siguiente forma:
    # (persona.name = "pepe").age = 7
    # de esta forma se crean las dos cosas en una sola linea
    
    def age=(age)   # el igual = debe ir sin espacios
        @age = age
        self # referencia al mismo objeto
    end
=end
# muchos bloques en ruby necesitan esta palabra reservada (end) para determinar hasta donde van
end


# crearemos una variable de esta clase

# persona(nombre de la variable) = Persona(Nombre de la clase) Nótese la diferencia por la mayuscula
# new es la forma de instanciar un objeto de esta clase, va a llamar al codigo dentro del constructor (initialize)
# el constructor pide que se reciban dos parametros (name, age)
persona = Persona.new("pepe", 14)

puts persona.name
puts persona.age

# si se quiere llamar al método se hace de la siguiente forma:
puts Persona.suggested_names
# persona (si, en minuscula) pertenece a una variable de instancia
# por eso se llama desde la clase usando Persona (con 'P' mayúscula)
binding.pry

Daniel De Lauretis

student•

La vertdad.. no se entiende nada. y eso que vengo de hacer el curso basico de JS. Se que es un constructor y demas. pero de repente se usan terminos que ni se explican. Que es un getter o un setter. Porque tengo que usarlos. Lo del self no se explica. que anda pasando por platzi???

Camilo Castro

student•

usando attributte accessor:

require "pry"

# como hacer programacion orientada a objetos

class Persona
    
    # La implementación de un macro permite no usar getters y setters
    # se declaran las propiedades de esa clae, se le envían simbolos de como usar los atributos
    # este genera los getters y setters de forma automática
    attr_accessor :name, :age
    
    # metodos de clase: 
    def self.suggested_names
        # retorna un arreglo con sugerencias para nombres en la clase
        ["Pepe", "Pepito", "Sutano"]
    end
    
    # ----------------------------------
    # metodos de instancia: 
    # al ser una clase, se requiere un constructor, en ruby es initialize
    # será un metodo y requiere ser creado usando la palabra reservada def
    def initialize(name, age)
        # para declarar variables de instancia se utiliza el arroba
        # la variable instancia de esta clase se va a inicializar con el parametro que nos pasen en el constructor 
        @name = name
        @age = age
    end

=begin
# he comentado los getter y setter ya que no son necesarios al usar un macro llamado attribute accesor (attr_accessor)     
    # crearemos algunos metodos getters para poder acceder a las propiedades de esta clase.
    # para esto se utiliza la palabra reservada def, y se retorna la propiedad de esta clase.
    #getter
    def name
        # retorno implicito, no se usa palabra return
        # en ruby todas las instrucciones de codigo retornan algo, dentro de los metodos si no se usa return, ruby entiende que se retorna el valor de la ultima instruccion
        @name
    end
    
    def age
        @age
    end
    
    #setter
    # persona.name = "pepe"
    def name=(name)   # el igual = debe ir sin espacios
        @name = name
        self  # self hace referencia a la misma instancia
    end
    
    # Al tener self podemos asignar las propiedades a los objetos de la clase de la siguiente forma:
    # (persona.name = "pepe").age = 7
    # de esta forma se crean las dos cosas en una sola linea
    
    def age=(age)   # el igual = debe ir sin espacios
        @age = age
        self # referencia al mismo objeto
    end
=end
# muchos bloques en ruby necesitan esta palabra reservada (end) para determinar hasta donde van
end


# crearemos una variable de esta clase

# persona(nombre de la variable) = Persona(Nombre de la clase) Nótese la diferencia por la mayuscula
# new es la forma de instanciar un objeto de esta clase, va a llamar al codigo dentro del constructor (initialize)
# el constructor pide que se reciban dos parametros (name, age)
persona = Persona.new("pepe", 14)

puts persona.name
puts persona.age

# si se quiere llamar al método se hace de la siguiente forma:
puts Persona.suggested_names
# persona (si, en minuscula) pertenece a una variable de instancia
# por eso se llama desde la clase usando Persona (con 'P' mayúscula)
binding.pry

Angel Vega

student•

En ruby, tiene que estar exactamente unido todo el código, ejemplo:

def age=(age)
        @age = age
        self
    end

No es válido:

def age = (age)

        @age = age

        self

    end

Santiago Herrera Velásquez

student•

Para los que se guíen con los archivos que dejan en el material de clase, cuidado con las clases cuyo constructor esta siendo declarado como "initializer", donde debe ser "initialize", esto les va a generar errores

Camilo Castro

student•

no entendía muchos de los comentarios así que hice los míos mucho más especificos para que los puedan entender a quién le pasó lo mismo que a mi:

require "pry"

# como hacer programacion orientada a objetos

class Persona
    
    # metodos de clase: 
    def self.suggested_names
        # retorna un arreglo con sugerencias para nombres en la clase
        ["Pepe", "Pepito", "Sutano"]
    end
    
    # ----------------------------------
    # metodos de instancia: 
    # al ser una clase, se requiere un constructor, en ruby es initialize
    # será un metodo y requiere ser creado usando la palabra reservada def
    def initialize(name, age)
        # para declarar variables de instancia se utiliza el arroba
        # la variable instancia de esta clase se va a inicializar con el parametro que nos pasen en el constructor 
        @name = name
        @age = age
    end
    
    # crearemos algunos metodos getters para poder acceder a las propiedades de esta clase.
    # para esto se utiliza la palabra reservada def, y se retorna la propiedad de esta clase.
    #getter
    def name
        # retorno implicito, no se usa palabra return
        # en ruby todas las instrucciones de codigo retornan algo, dentro de los metodos si no se usa return, ruby entiende que se retorna el valor de la ultima instruccion
        @name
    end
    
    def age
        @age
    end
    
    #setter
    # persona.name = "pepe"
    def name=(name)   # el igual = debe ir sin espacios
        @name = name
        self  # self hace referencia a la misma instancia
    end
    
    # Al tener self podemos asignar las propiedades a los objetos de la clase de la siguiente forma:
    # (persona.name = "pepe").age = 7
    # de esta forma se crean las dos cosas en una sola linea
    
    def age=(age)   # el igual = debe ir sin espacios
        @age = age
        self # referencia al mismo objeto
    end

# muchos bloques en ruby necesitan esta palabra reservada (end) para determinar hasta donde van
end


# crearemos una variable de esta clase

# persona(nombre de la variable) = Persona(Nombre de la clase) Nótese la diferencia por la mayuscula
# new es la forma de instanciar un objeto de esta clase, va a llamar al codigo dentro del constructor (initialize)
# el constructor pide que se reciban dos parametros (name, age)
persona = Persona.new("pepe", 14)

puts persona.name
puts persona.age

# si se quiere llamar al método se hace de la siguiente forma:
puts Persona.suggested_names
# persona (si, en minuscula) pertenece a una variable de instancia
# por eso se llama desde la clase usando Persona (con 'P' mayúscula)
binding.pry

Camilo Castro

student•

Usando Structs:

require "pry"

# como hacer programacion orientada a objetos

class Persona < Struct.new(:name, :age)

=begin    
# he comentado este bloque de codigo po el uso de Struct en la clase, en la cual ya no se requiere el macro para la creació de las propiedades
# ir a línea 22
    # La implementación de un macro permite no usar getters y setters
    # se declaran las propiedades de esa clae, se le envían simbolos de como usar los atributos<code>
    # este genera los getters y setters de forma automática
    attr_accessor :name, :age
=end    
    
    # metodos de clase: 
    def self.suggested_names
        # retorna un arreglo con sugerencias para nombres en la clase
        ["Pepe", "Pepito", "Sutano", "Mengano", "Camilo"]
    end
=begin    
# he comentado este bloque de código por el uso de Struct, el cual ya no requiere un constructor
# sino que las propiedades le son enviadas cómo simbolos y se encarga de la creación de ellas
# y el manejo de los getters y setters para ella.
    # ----------------------------------
    # metodos de instancia: 
    # al ser una clase, se requiere un constructor, en ruby es initialize
    # será un metodo y requiere ser creado usando la palabra reservada def
    def initialize(name, age)
        # para declarar variables de instancia se utiliza el arroba
        # la variable instancia de esta clase se va a inicializar con el parametro que nos pasen en el constructor 
        @name = name
        @age = age
    end
=end
=begin
# he comentado los getter y setter ya que no son necesarios al usar un macro llamado attribute accesor (attr_accessor)     
    # crearemos algunos metodos getters para poder acceder a las propiedades de esta clase.
    # para esto se utiliza la palabra reservada def, y se retorna la propiedad de esta clase.
    #getter
    def name
        # retorno implicito, no se usa palabra return
        # en ruby todas las instrucciones de codigo retornan algo, dentro de los metodos si no se usa return, ruby entiende que se retorna el valor de la ultima instruccion
        @name
    end
    
    def age
        @age
    end
    
    #setter
    # persona.name = "pepe"
    def name=(name)   # el igual = debe ir sin espacios
        @name = name
        self  # self hace referencia a la misma instancia
    end
    
    # Al tener self podemos asignar las propiedades a los objetos de la clase de la siguiente forma:
    # (persona.name = "pepe").age = 7
    # de esta forma se crean las dos cosas en una sola linea
    
    def age=(age)   # el igual = debe ir sin espacios
        @age = age
        self # referencia al mismo objeto
    end
=end
# muchos bloques en ruby necesitan esta palabra reservada (end) para determinar hasta donde van
end


# crearemos una variable de esta clase

# persona(nombre de la variable) = Persona(Nombre de la clase) Nótese la diferencia por la mayuscula
# new es la forma de instanciar un objeto de esta clase, va a llamar al codigo dentro del constructor (initialize)
# el constructor pide que se reciban dos parametros (name, age)
persona = Persona.new("pepe", 14)

puts persona.name
puts persona.age

# si se quiere llamar al método se hace de la siguiente forma:
puts Persona.suggested_names
# persona (si, en minuscula) pertenece a una variable de instancia
# por eso se llama desde la clase usando Persona (con 'P' mayúscula)
binding.pry

Felipe Lizcano

student•

Es buena practica declarar metodos en las clases?

Elvis Sánchez

student•

Sí. Y bueno, más allá de que sea buena práctica, es necesario.

Horacio Sanchez Corvera

student•

Si, siempre que el método sea propio de la clase, es decir, que te ayuda a abstraer la realidad del objeto. Por ejemplo, una clase cuadrado podría tener los métodos "area", "perimetro".

Jonathan Fernando Santana Quispillo

student•

Aquí les dejo mis 3 formas de declarar las clases.

class Persona #metodo de clase def self.nombres_sugeridos ["Pepe","Jonathan","Fernando","Sutano"] end #constructor def initialize(nombre, edad) @nombre = nombre @edad= edad end #getters def nombre @nombre end def edad @edad end #setters #persona.nombre ="pepe" def nombre=(nombre) @nombre = nombre self end def edad=(edad) @edad = edad self end end

#otra forma de declarar una clase y acceder a las propiedades de la clase class Persona attr_accessor :nombre, :edad #esto genera getteres y setters #metodo de clase def self.nombres_sugeridos ["Pepe","Jonathan","Fernando","Sutano"] end #constructor def initialize(nombre, edad) @nombre = nombre @edad= edad end end

#otra forma de declarar clase con metodos (con struct no se necesita el contructor) class Persona < Struct.new( :nombre, :edad) def self.nombres_sugeridos ["Pepe","Jonathan","Fernando","Sutano"] end end

class Persona  
  def initialize(name) #Constructor
    @name = name #Variable de instancia se inicializa con el parametro en el constructor
  end

  def name #Getter
    @name
  end

  def name=(name) #Setter
     @name = name
     self
  end
end

class Persona
    # Para declarar Métodos de clases
    def self.suggested_names
        ["Pepe","Pepito","Sutano"]
    end

    # constructor
    def initialize(name, age)
        @name = name
        @age = age
    end

    #métodos de instancia
    def name
        @name
    end

    def age
        @age
    end

    # persona.name = "pepe"
    def name=(name)
        @name = name
        self
    end

    def age=(age)
        @age = age
        self
    end
end

persona = Persona.new("pepe", 14)
puts "#{persona.name} tiene #{persona.age} años."

# si queremos llamar al método que creamos, llamamos a la clase
puts "Nombre sugeridos: \n#{Persona.suggested_names}"

#Class reducido primera forma
class Persona_2
    attr_accessor :name, :age

    # Para declarar Métodos de clases
    def self.suggested_names
        ["Pepe","Pepito","Sutano"]
    end

    # constructor
    def initialize(name, age)
        @name = name
        @age = age
    end
end

persona_2 = Persona_2.new("Carlos", 19)
puts "#{persona_2.name} tiene #{persona_2.age} años."

#Class reducido segunda forma
class Persona_3 < Struct.new(:name, :age)
    # Para declarar Métodos de clases
    def self.suggested_names
        ["Pepe","Pepito","Sutano"]
    end
end

persona_3 = Persona_3.new("Julian", 33)
puts "#{persona_3.name} tiene #{persona_3.age} años."

class Persona

#:name y :age permite generar los setter y getters automáticamente

  attr_accessor :name, :age


#Método que entrega nombre sugeridos
  def self.suggested_name
    ["Pepe", " Pedro", "Bodoque"]
  end

#creamos metodo constructor
  def initialize (name, age)
    #variables de instacia
    @name=name
    @age=age
  end
end
#método getter para name
  # def name
  #   return @name
  # end
  #
  # #method get for age
  # def age
  #   return @age
  # end
  #
  # #method for edit the name
  # def name= (name)
  #   @name=name
  #   self
  # end
  #
  # def age =(age)
  #   @age=age
  #   self

#creo una persona
persona1= Persona.new("Pedro",25)

#imprimo el nombre
puts persona1.name

puts "\nahora el nuevo nombre de la persona es: "

#edito el nombre
persona1.name="\ncarlos"

#imprimo nuevamente el nombre
puts persona1.name

persona1.age="32"
puts persona1.age

require "pry"

# como hacer programacion orientada a objetos

class Persona < Struct.new(:name, :age)

=begin    
# he comentado este bloque de codigo po el uso de Struct en la clase, en la cual ya no se requiere el macro para la creació de las propiedades
# ir a línea 22
    # La implementación de un macro permite no usar getters y setters
    # se declaran las propiedades de esa clae, se le envían simbolos de como usar los atributos<code>
    # este genera los getters y setters de forma automática
    attr_accessor :name, :age
=end    
    
    # metodos de clase: 
    def self.suggested_names
        # retorna un arreglo con sugerencias para nombres en la clase
        ["Pepe", "Pepito", "Sutano", "Mengano", "Camilo"]
    end
=begin    
# he comentado este bloque de código por el uso de Struct, el cual ya no requiere un constructor
# sino que las propiedades le son enviadas cómo simbolos y se encarga de la creación de ellas
# y el manejo de los getters y setters para ella.
    # ----------------------------------
    # metodos de instancia: 
    # al ser una clase, se requiere un constructor, en ruby es initialize
    # será un metodo y requiere ser creado usando la palabra reservada def
    def initialize(name, age)
        # para declarar variables de instancia se utiliza el arroba
        # la variable instancia de esta clase se va a inicializar con el parametro que nos pasen en el constructor 
        @name = name
        @age = age
    end
=end
=begin
# he comentado los getter y setter ya que no son necesarios al usar un macro llamado attribute accesor (attr_accessor)     
    # crearemos algunos metodos getters para poder acceder a las propiedades de esta clase.
    # para esto se utiliza la palabra reservada def, y se retorna la propiedad de esta clase.
    #getter
    def name
        # retorno implicito, no se usa palabra return
        # en ruby todas las instrucciones de codigo retornan algo, dentro de los metodos si no se usa return, ruby entiende que se retorna el valor de la ultima instruccion
        @name
    end
    
    def age
        @age
    end
    
    #setter
    # persona.name = "pepe"
    def name=(name)   # el igual = debe ir sin espacios
        @name = name
        self  # self hace referencia a la misma instancia
    end
    
    # Al tener self podemos asignar las propiedades a los objetos de la clase de la siguiente forma:
    # (persona.name = "pepe").age = 7
    # de esta forma se crean las dos cosas en una sola linea
    
    def age=(age)   # el igual = debe ir sin espacios
        @age = age
        self # referencia al mismo objeto
    end
=end
# muchos bloques en ruby necesitan esta palabra reservada (end) para determinar hasta donde van
end


# crearemos una variable de esta clase

# persona(nombre de la variable) = Persona(Nombre de la clase) Nótese la diferencia por la mayuscula
# new es la forma de instanciar un objeto de esta clase, va a llamar al codigo dentro del constructor (initialize)
# el constructor pide que se reciban dos parametros (name, age)
persona = Persona.new("pepe", 14)

puts persona.name
puts persona.age

# si se quiere llamar al método se hace de la siguiente forma:
puts Persona.suggested_names
# persona (si, en minuscula) pertenece a una variable de instancia
# por eso se llama desde la clase usando Persona (con 'P' mayúscula)
binding.pry

require "pry"

# como hacer programacion orientada a objetos

class Persona
    
    # La implementación de un macro permite no usar getters y setters
    # se declaran las propiedades de esa clae, se le envían simbolos de como usar los atributos
    # este genera los getters y setters de forma automática
    attr_accessor :name, :age
    
    # metodos de clase: 
    def self.suggested_names
        # retorna un arreglo con sugerencias para nombres en la clase
        ["Pepe", "Pepito", "Sutano"]
    end
    
    # ----------------------------------
    # metodos de instancia: 
    # al ser una clase, se requiere un constructor, en ruby es initialize
    # será un metodo y requiere ser creado usando la palabra reservada def
    def initialize(name, age)
        # para declarar variables de instancia se utiliza el arroba
        # la variable instancia de esta clase se va a inicializar con el parametro que nos pasen en el constructor 
        @name = name
        @age = age
    end

=begin
# he comentado los getter y setter ya que no son necesarios al usar un macro llamado attribute accesor (attr_accessor)     
    # crearemos algunos metodos getters para poder acceder a las propiedades de esta clase.
    # para esto se utiliza la palabra reservada def, y se retorna la propiedad de esta clase.
    #getter
    def name
        # retorno implicito, no se usa palabra return
        # en ruby todas las instrucciones de codigo retornan algo, dentro de los metodos si no se usa return, ruby entiende que se retorna el valor de la ultima instruccion
        @name
    end
    
    def age
        @age
    end
    
    #setter
    # persona.name = "pepe"
    def name=(name)   # el igual = debe ir sin espacios
        @name = name
        self  # self hace referencia a la misma instancia
    end
    
    # Al tener self podemos asignar las propiedades a los objetos de la clase de la siguiente forma:
    # (persona.name = "pepe").age = 7
    # de esta forma se crean las dos cosas en una sola linea
    
    def age=(age)   # el igual = debe ir sin espacios
        @age = age
        self # referencia al mismo objeto
    end
=end
# muchos bloques en ruby necesitan esta palabra reservada (end) para determinar hasta donde van
end


# crearemos una variable de esta clase

# persona(nombre de la variable) = Persona(Nombre de la clase) Nótese la diferencia por la mayuscula
# new es la forma de instanciar un objeto de esta clase, va a llamar al codigo dentro del constructor (initialize)
# el constructor pide que se reciban dos parametros (name, age)
persona = Persona.new("pepe", 14)

puts persona.name
puts persona.age

# si se quiere llamar al método se hace de la siguiente forma:
puts Persona.suggested_names
# persona (si, en minuscula) pertenece a una variable de instancia
# por eso se llama desde la clase usando Persona (con 'P' mayúscula)
binding.pry

require "pry"

# como hacer programacion orientada a objetos

class Persona
    
    # metodos de clase: 
    def self.suggested_names
        # retorna un arreglo con sugerencias para nombres en la clase
        ["Pepe", "Pepito", "Sutano"]
    end
    
    # ----------------------------------
    # metodos de instancia: 
    # al ser una clase, se requiere un constructor, en ruby es initialize
    # será un metodo y requiere ser creado usando la palabra reservada def
    def initialize(name, age)
        # para declarar variables de instancia se utiliza el arroba
        # la variable instancia de esta clase se va a inicializar con el parametro que nos pasen en el constructor 
        @name = name
        @age = age
    end
    
    # crearemos algunos metodos getters para poder acceder a las propiedades de esta clase.
    # para esto se utiliza la palabra reservada def, y se retorna la propiedad de esta clase.
    #getter
    def name
        # retorno implicito, no se usa palabra return
        # en ruby todas las instrucciones de codigo retornan algo, dentro de los metodos si no se usa return, ruby entiende que se retorna el valor de la ultima instruccion
        @name
    end
    
    def age
        @age
    end
    
    #setter
    # persona.name = "pepe"
    def name=(name)   # el igual = debe ir sin espacios
        @name = name
        self  # self hace referencia a la misma instancia
    end
    
    # Al tener self podemos asignar las propiedades a los objetos de la clase de la siguiente forma:
    # (persona.name = "pepe").age = 7
    # de esta forma se crean las dos cosas en una sola linea
    
    def age=(age)   # el igual = debe ir sin espacios
        @age = age
        self # referencia al mismo objeto
    end

# muchos bloques en ruby necesitan esta palabra reservada (end) para determinar hasta donde van
end


# crearemos una variable de esta clase

# persona(nombre de la variable) = Persona(Nombre de la clase) Nótese la diferencia por la mayuscula
# new es la forma de instanciar un objeto de esta clase, va a llamar al codigo dentro del constructor (initialize)
# el constructor pide que se reciban dos parametros (name, age)
persona = Persona.new("pepe", 14)

puts persona.name
puts persona.age

# si se quiere llamar al método se hace de la siguiente forma:
puts Persona.suggested_names
# persona (si, en minuscula) pertenece a una variable de instancia
# por eso se llama desde la clase usando Persona (con 'P' mayúscula)
binding.pry

require "pry"

# como hacer programacion orientada a objetos

class Persona < Struct.new(:name, :age)

=begin    
# he comentado este bloque de codigo po el uso de Struct en la clase, en la cual ya no se requiere el macro para la creació de las propiedades
# ir a línea 22
    # La implementación de un macro permite no usar getters y setters
    # se declaran las propiedades de esa clae, se le envían simbolos de como usar los atributos<code>
    # este genera los getters y setters de forma automática
    attr_accessor :name, :age
=end    
    
    # metodos de clase: 
    def self.suggested_names
        # retorna un arreglo con sugerencias para nombres en la clase
        ["Pepe", "Pepito", "Sutano", "Mengano", "Camilo"]
    end
=begin    
# he comentado este bloque de código por el uso de Struct, el cual ya no requiere un constructor
# sino que las propiedades le son enviadas cómo simbolos y se encarga de la creación de ellas
# y el manejo de los getters y setters para ella.
    # ----------------------------------
    # metodos de instancia: 
    # al ser una clase, se requiere un constructor, en ruby es initialize
    # será un metodo y requiere ser creado usando la palabra reservada def
    def initialize(name, age)
        # para declarar variables de instancia se utiliza el arroba
        # la variable instancia de esta clase se va a inicializar con el parametro que nos pasen en el constructor 
        @name = name
        @age = age
    end
=end
=begin
# he comentado los getter y setter ya que no son necesarios al usar un macro llamado attribute accesor (attr_accessor)     
    # crearemos algunos metodos getters para poder acceder a las propiedades de esta clase.
    # para esto se utiliza la palabra reservada def, y se retorna la propiedad de esta clase.
    #getter
    def name
        # retorno implicito, no se usa palabra return
        # en ruby todas las instrucciones de codigo retornan algo, dentro de los metodos si no se usa return, ruby entiende que se retorna el valor de la ultima instruccion
        @name
    end
    
    def age
        @age
    end
    
    #setter
    # persona.name = "pepe"
    def name=(name)   # el igual = debe ir sin espacios
        @name = name
        self  # self hace referencia a la misma instancia
    end
    
    # Al tener self podemos asignar las propiedades a los objetos de la clase de la siguiente forma:
    # (persona.name = "pepe").age = 7
    # de esta forma se crean las dos cosas en una sola linea
    
    def age=(age)   # el igual = debe ir sin espacios
        @age = age
        self # referencia al mismo objeto
    end
=end
# muchos bloques en ruby necesitan esta palabra reservada (end) para determinar hasta donde van
end


# crearemos una variable de esta clase

# persona(nombre de la variable) = Persona(Nombre de la clase) Nótese la diferencia por la mayuscula
# new es la forma de instanciar un objeto de esta clase, va a llamar al codigo dentro del constructor (initialize)
# el constructor pide que se reciban dos parametros (name, age)
persona = Persona.new("pepe", 14)

puts persona.name
puts persona.age

# si se quiere llamar al método se hace de la siguiente forma:
puts Persona.suggested_names
# persona (si, en minuscula) pertenece a una variable de instancia
# por eso se llama desde la clase usando Persona (con 'P' mayúscula)
binding.pry

Programación Orientada a Objetos en Ruby Comenzando la creación de nuestra clase

Introducción

Lo que aprenderás sobre Ruby

Qué es Ruby y para qué sirve este lenguaje

Instalación de Ruby

Bases del lenguaje

Tipos de datos I: Integer, float

Tipos de datos II: Strings

Tipos de datos III: Symbols

Tipos de datos IV: Arrays

Tipos de datos V: Hashes

Uso de condicionales

Uso de ciclos

Rangos

Uso de Regex

Procs y lambdas

Programación Orientada a Objetos en Ruby Comenzando la creación de nuestra clase

Programación Orientada a Objetos en Ruby: Módulos

Programación Orientada a Objetos: Clases y Objetos

Concurrencia vs Paralelismo: Threads en Ruby

Bundler y gemas

Testing en Ruby

Testing con MiniTest

Diferencias entre Ruby 2.5 y 3

Proyecto

Introducción al proyecto

Instalar Ruby 2D

Overview Ruby 2D

Arquitectura

Estructurando el proyecto

Vista básica

Programando la base para los movimientos

Programando el movimiento de nuestro snake

Test de nuestras acciones

Implementando el timer del movimiento

Actualizando la vista

Preparando el cambio de dirección

Recapitulación de la arquitectura

Moviendo la serpiente con el teclado

Creciendo la serpiente y programando la condición de derrota

Generando comida aleatoria: uso de rand y stub en pruebas

Condición de salida y conclusiones

Retos del curso