Cómo implementar la Herencia Simple en Ruby.


La herencia simple entre clases permite reducir código duplicado en una aplicación y es uno de los conceptos básicos de la programación orientada a objetos. Se denomina herencia simple pues solo se pueden heredar las características de una sola clase base o padre.

En algunos lenguajes existe también la herencia múltiple, sobre este último concepto hay discrepancias sobre sus beneficios por lo que en Ruby no se implementa.

Antes de entrar en el tema de la herencia le haré unas modificaciones a la clase creada en el pasado artículo, pero manteniendo sus funcionalidades.

<code>class Persona
  attr_accessor :nombre
  attr_reader   :edad, :sexo

  def initialize(nombre, sexo)
    @nombre = nombre
    @sexo   = sexo
    @edad   = rand( 120 )
  end
end</code>

Luego de la refactorización aplicada a la clase Persona, esta se ha vuelto más compacta y fácil de leer. Aquí he utilizado dos accessors, el primero crea una variable de instancia (@nombre) y sus respectivos métodos de lectura y escritura. El segundo crea dos variables de instancia(@edad, @sexo) y los métodos para leer dichas variables.

Existe un tercer accesor, que al igual que los anteriores crea una variable instancia, pero en este caso genera un método que permite modificar la variable creada. Imagino que attr_writer te pasó por la mente, si es así, ¡Adivinaste!

La sintaxis es bastante simple, nombre_del_accessor símbolo o símbolos separados por coma.

Ejemplo:

<code>...
attr_accessor :sobre_nombre
attr_reader :nombre, :peso
attr_writer :nombre
...</code>

Hasta ahora todo el código ha aparecido siempre en un solo fichero, pero al irse convirtiendo en algo más grande se vuelve incómoda esta forma de trabajo. Por ello voy a refactorizar un poco nuevamente.

Crea una carpeta proyecto y dentro salva un fichero persona.rb que contenga la clase persona recien refactorizada. Además crea un fichero principal.rb que contenga lo siguiente:

<code>#!/usr/bin/env ruby

 $: << './'
require 'persona.rb'

hombre = Persona.new("Peter Parker","M")

mujer = Persona.new("Alleria","F")

puts "El hombre se llama #{hombre.nombre} y su edad es #{hombre.edad}."

puts "La mujer se llama #{mujer.nombre} y su edad es #{mujer.edad}."
</code>

De ahora en adelante cada vez que crees un fichero, hazlo dentro de la carpeta poryecto.

Si ejecutas el script principal.rb notarás que el programa se ejecuta correctamente. Estarás de acuerdo conmigo que de esta forma es un poco más elegante y práctica.

Hasta aquí las refactorizaciones, pasaré ahora a la herencia. Voy a definir otra clase, en este caso Heroe que heredará de la clase Persona.

<code>require 'persona'
class Heroe < Persona
  attr_reader :fuerza, :agilidad, :inteligencia, :vida

  def initialize(nombre, sexo)
    super(nombre, sexo)
    @edad = rand 18..120
    @fuerza = rand 10..100
    @agilidad = rand 10..100
    @inteligencia = rand 10..100
    @vida = 1000
  end

  def ataque
    3*@fuerza + 2*@agilidad + @inteligencia
  end

  def defensa
    3*@agilidad + 2*@fuerza + @inteligencia
  end
end</code>

Salva el código anterior en un fichero llamado heroe.rb.

Si te fijas en la definición de la clase Heroe notarás que aparecen un signo de menor que y el nombre de la clase de la cual se hereda. Este sería el primer paso para definir la herencia.

El siguiente paso es enviar los parámetros requeridos a la clase padre. Para ello se utiliza el método super. Esta definición de Heroe tiene nuevos atributos y métodos que no aparecen en su clase padre.

Veamos el héroe en acción. Crea un fichero llamado herencia.rb en él copia el código que aparece a continuación y salva.

<code>$: << './'

require 'heroe'

heroe = Heroe.new("Peter Parker","M")

puts "Este es #{heroe.nombre}, tiene #{heroe.ataque} puntos de ataque y #{heroe.defensa} de defensa."</code>

Al ejecutar el script se mostrarán algunas características del héroe. Como podrás apreciar, el objeto heroe está utilizando los métodos y atributos propios junto con los heredados.

Conclusiones.

Hoy aprendiste a utilizar los accessors, los cuales reducen de forma drástica el código requerido para implementar tu solución. Te mostré como apoyo un pequeño ejemplo para que veas la definición y uso de herencia simple.

En esta publicación aparecieron nuevos conceptos y operadores como los símbolos ( <<, $: y require). No he entrado en detalle en ellos pues serán el objetivo en la próxima entrega.

¡Stay tunned!