Ruby | Herencia

Ruby es el lenguaje orientado a objetos ideal. En un lenguaje de programación orientado a objetos, la herencia es una de las características más importantes. La herencia permite al programador heredar las características de una clase en otra clase. Ruby solo admite la herencia de una sola clase , no admite la herencia de múltiples clases, pero admite mixins . Los mixins están diseñados para implementar herencias múltiples en Ruby, pero solo heredan la parte de la interfaz. 

La herencia proporciona el concepto de «reutilización», es decir, si un programador quiere crear una nueva clase y hay una clase que ya incluye parte del código que el programador quiere, entonces puede derivar una nueva clase de la clase existente. Al hacer esto, aumenta la reutilización de los campos y métodos de la clase existente sin crear código adicional.

En la imagen de arriba, la clase A es una superclase y la clase B es una subclase o puede decir que la clase B se deriva de la clase A ( clase base ).

Términos clave en Herencia: 

• Superclase: La clase cuyas características se heredan se conoce como superclase o clase base o clase padre .
• Subclase: la clase que se deriva de otra clase se conoce como subclase , clase derivada o clase secundaria . También puede agregar sus propios objetos, métodos además de los métodos y objetos de la clase base, etc.

Nota: De manera predeterminada, cada clase en Ruby tiene una clase principal. Antes de Ruby 1.9 , la clase Object era la clase principal de todas las demás clases o se puede decir que era la raíz de la jerarquía de clases. Pero a partir de la versión Ruby 1.9 , la clase BasicObject es la superclase (clase principal) de todas las demás clases en Ruby. La clase de objeto es una clase secundaria de la clase BasicObject . 

Sintaxis:  

subclass_name < superclass_name

Ejemplo: 

# Ruby program to demonstrate
# the Inheritance
 
#!/usr/bin/ruby
 
# Super class or parent class
class GeeksforGeeks
 
    # constructor of super class
    def initialize
         
        puts "This is Superclass"
    end
     
    # method of the superclass
    def super_method
         
        puts "Method of superclass"
    end
end
 
# subclass or derived class
class Sudo_Placement < GeeksforGeeks
 
    # constructor of deriver class
    def initialize
 
       puts "This is Subclass"
    end
end
 
# creating object of superclass
GeeksforGeeks.new
 
# creating object of subclass
sub_obj = Sudo_Placement.new
 
# calling the method of super
# class using sub class object
sub_obj.super_method

Producción: 

This is Superclass
This is Subclass
Method of superclass

Anulación del método Padre o Superclase: La anulación de métodos es una característica muy eficaz de Ruby. En la anulación de métodos, la subclase y la superclase contienen el mismo nombre de método, pero realizan tareas diferentes o podemos decir que un método anula a otro método. Si la superclase contiene un método y la subclase también contiene el mismo nombre de método, se ejecutará el método de la subclase.

Ejemplo:  

# Ruby program to demonstrate
# Overriding of Parent or
# Superclass method
 
#!/usr/bin/ruby
 
# parent class
class Geeks
     
    # method of the superclass 
    def super_method
         
        puts "This is Superclass Method"
  end
     
end
 
# derived class 'Ruby' 
class Ruby < Geeks
     
    # overriding the method of the superclass 
    def super_method
         
        puts "Override by Subclass"
  end
end
    
# creating object of sub class
obj = Ruby.new
 
# calling the method
obj.super_method 

Producción: 

Override by Subclass

Uso del supermétodo en herencia: este método se usa para llamar al método de la clase principal en la clase secundaria. Si el método no contiene ningún argumento, automáticamente pasa todos sus argumentos. Un método super se define mediante la palabra clave super . Siempre que desee llamar al método de la clase principal del mismo nombre, simplemente puede escribir super o super() .

Ejemplo:  

# Ruby Program to demonstrate the
# use of super method
 
#!/usr/bin/ruby
 
# base class
class Geeks_1
    
    # method of superclass accepting
    # two parameter
    def display a = 0, b = 0
        puts "Parent class, 1st Argument: #{a}, 2nd Argument: #{b}"
    end
end
 
# derived class Geeks_2
class Geeks_2 < Geeks_1
 
    # subclass method having the same name
    # as superclass
    def display a, b
         
        # calling the superclass method
        # by default it will pass
        # both the arguments
        super
         
        # passing only one argument
        super a
         
        # passing both the argument
        super a, b
         
        # calling the superclass method
        # by default it will not pass
        # both the arguments
        super()
         
        puts "Hey! This is subclass method"
    end
end
 
# creating object of derived class
obj = Geeks_2.new
 
# calling the method of subclass
obj.display "Sudo_Placement", "GFG"

Producción: 

Parent class, 1st Argument: Sudo_Placement, 2nd Argument: GFG
Parent class, 1st Argument: Sudo_Placement, 2nd Argument: 0
Parent class, 1st Argument: Sudo_Placement, 2nd Argument: GFG
Parent class, 1st Argument: 0, 2nd Argument: 0
Hey! This is subclass method