Programación Orientada a Objetos en Ruby | Conjunto-2

Prerrequisito: Programación Orientada a Objetos en Ruby | Serie 1

Herencia

La herencia es una de las características fundamentales sólidas de la programación orientada a objetos. a veces podemos necesitar que ciertas características de una clase se repliquen en otra clase. En lugar de volver a crear ese atributo, podemos heredar el atributo de la otra clase. La clase de la que se hereda se denomina clase base y la clase que se hereda de la clase base se denomina clase derivada.

Sintaxis:

class base
# internal data and methods
end
class derived < base
# internal data and methods
end

Usamos el símbolo < para heredar. Entonces, todos los datos y métodos en la clase base se pasan a la clase derivada. sin embargo, esta es solo una forma. Es decir, la información de la clase derivada no se hereda a la clase base. Esto se entiende mejor con un ejemplo, así que considere nuestro ejemplo principal Vehículo
. Tomemos la clase Vehículo como la clase base y hagamos dos clases derivadas: automóvil y autobús. .

Ejemplo:

# Ruby program of Inheritance
class Vehicle
    def initialize(vehicle_name, vehicle_color)
        @vehicle_name = vehicle_name
        @vehicle_color = vehicle_color
    end
    def description
        puts 'This is a vehicle'
    end
end
  
class Car < Vehicle
    def description
        puts 'This is a car'
    end
  
end 
  
class Bus < Vehicle
    def display_this
        puts 'This is a bus'
    end
  
end  
  
# Creating objects
object1 = Car.new('Nissan', 'red')
object2 = Bus.new('Volvo', 'white')
  
object1.description
object2.description
object2.display_this

Producción:

This is a car
This is a vehicle
This is a bus

En el ejemplo anterior, tenemos una clase base: Vehículo y dos clases derivadas: Automóvil y Autobús. Coche y Autobús heredan los atributos y métodos de la clase Vehículo. Considere el método ‘Descripción’ que es común tanto para Vehículo como para Coche, sin embargo, su funcionalidad es diferente. Entonces, cuando Car hereda los métodos de Vehicle, tiene dos métodos llamados Description; sin embargo, estos dos métodos no son iguales, uno es Car.Description mientras que el otro es Vehicle.Description.

Sin embargo, para un objeto de tipo Car, si llamamos al método Descripción, entonces se ejecuta el método Car.Description
. Por lo tanto, podemos decir que Car.Description anula Vehicle.Description. En la clase Bus, solo tenemos un método de descripción que heredamos de la clase Vehicle, por lo que no hay anulación en este escenario. Las clases derivadas pueden tener sus propios datos y variables y un ejemplo de ello es el método ‘display_this’. Recuerde, la herencia no es al revés. Entonces, si tuviéramos un objeto de tipo Vehículo, es decir object3 = Vehicle.new(), entonces no podemos escribir object3.display_esta herencia es solo de una manera.

Ahora considere el caso de los dos métodos de descripción, Car.description y Vehicle.Description. decimos que para un objeto de tipo Car, el método Car.Description se ejecutará, pero ¿y si quisiéramos que se ejecutara el otro método-Vehicle.Description? para ello utilizamos la palabra clave super .

# Ruby program of inheritance
class Vehicle
    def initialize(vehicle_name, vehicle_color)
        @vehicle_name = vehicle_name
        @vehicle_color = vehicle_color
    end
    def description
        puts 'This is a vehicle'
    end
end
   
# Using inheritance
class Car < Vehicle
    def description
        puts 'This is a car'
            super
    end
   
end
   
# Using inheritance
class Bus < Vehicle
    def display_this
        puts 'This is a bus'
    end
   
end
  
# creating object
object1 = Car.new('Nissan', 'red')
object2 = Bus.new('Volvo', 'white')
   
# Calling object
object1.description
object2.description
object2.display_this

Producción:

This is a car
This is a vehicle
This is a vehicle
This is a bus

La diferencia de este ejemplo con respecto al anterior es que usamos super en el método Car.Description. cuando usamos super, el control vuelve a la clase base y luego ejecuta el método de la clase base, es decir, Vehicle.Description en lugar de Car.Description.
Así es como podemos anular nuestro método de clase derivado para usar nuestro método de clase base en su lugar.

Atributos de clase derivados

Ahora supongamos que queremos que nuestra clase derivada tenga atributos propios. Todavía tendríamos que pasar las variables para la clase base así como para la clase derivada. luego usamos super para llamar al constructor de la clase base y luego inicializamos los atributos de la clase derivada.
Ejemplo :

# Ruby program of showing Derived class attributes
class Vehicle
    attr_accessor :vehicle_name
    attr_accessor :vehicle_color
    def initialize(vehicle_name, vehicle_color)
        @vehicle_name = vehicle_name
        @vehicle_color = vehicle_color
    end
end
   
class Car < Vehicle
     attr_accessor :car_model
  def initialize(vehicle_name, vehicle_color, car_model)
  
        # Using super keyword
        super(vehicle_name, vehicle_color)
        @car_model = car_model
    end
end
   
# creating object 
object = Car.new('Nissan', 'white', 'xyz')
  
# calling object
puts object.vehicle_name
puts object.vehicle_color
puts object.car_model

Producción:

Nissan
white
xyz

Introdujimos un atributo car_model en la clase derivada Car mientras creamos el objeto, pasamos valores para la clase base y derivada (Car) ya que la clase derivada también tiene los atributos de la clase base (Vehicle).

De la declaración a continuación, object = Car.new('Nissan', 'white', 'xyz')el control va al método de inicialización de Car, desde allí usamos super para pasar los atributos del vehículo al método de inicialización de Vehicle, es decir super(vehicle_name, vehicle_color). Luego, el control pasó al método de inicialización del vehículo y luego regresa al lugar al que se llamó. entonces los atributos derivados se inicializan, es decir@car_model = car_model

La herencia múltiple no es compatible con Ruby, ya que a menudo se vuelve desordenada y muy complicada. por herencia múltiple, queremos decir que una clase se deriva de muchas clases base. esto es compatible con lenguajes como C++, pero a menudo se considera una complicación excesiva. Sin embargo, tenemos una solución para esto. Los mixins suelen ayudar a frenar esta deficiencia.

Pública y privada

Por defecto, todos nuestros atributos y métodos son públicos si describimos todos nuestros métodos como públicos, permite acceder a nuestros métodos fuera de la clase que usamos privados cuando tenemos métodos a los que no queremos dar acceso fuera de la clase, solo el objeto es dado acceso para usar los métodos internamente desde otros métodos públicos.

# Ruby program of Public and Private method
class Vehicle
    def initialize(vehicle_name, vehicle_color)
        @vehicle_name = vehicle_name
        @vehicle_color = vehicle_color
    end
    
  # Using public method
    public
    def display
        greeting
        puts 'Your car details are: '
        puts @vehicle_name
        puts @vehicle_color
    end
    
   # Using Private method
    private
    def greeting
        puts 'Hello, user'
    end
end
  
# Creating object
object = Vehicle.new('Nissan', 'white')
  
# Calling object
object.display

Producción:

Hello, user
Your car details are: 
Nissan
white

De forma predeterminada, todos nuestros métodos son públicos, por lo que si queremos que uno de nuestros métodos sea privado, debemos mencionarlo con la palabra clave privado . Del mismo modo, podemos mencionar un método como público usando la palabra clave como público . Si usamos una de las palabras clave privado o público . , luego hasta que los mencionemos nuevamente, permanecerá en público o privado hasta el final de la definición de clase.

Módulos

Los módulos son como bloques de código que contienen métodos e incluso constantes durante la codificación, es posible que tengamos muchas herramientas que deseemos usar, sin embargo, esto podría saturar todo el programa. Entonces los colocamos en módulos y solo usamos los módulos cuando deseamos usar los métodos y constantes dentro de ellos, son similares a las clases con la excepción de que no podemos crear objetos a partir de módulos.

Sintaxis del módulo:

module ModuleName
    #methods and constants
end

Los módulos se escriben con CapitalizedCamelCase, que solo escribe en mayúscula la primera letra de cada palabra en el nombre del módulo sin espacios.

Ejemplo de módulo

module ConstantsAndMethods
    CONST_ONE = 10
    CONST_TWO = 20
    
    def method1
         puts ‘This belongs to ConstantsAndMethods’
    end
end

Creamos un módulo llamado ConstantsAndMethods, tenemos dos constantes. Las constantes deben escribirse en mayúsculas y guiones bajos entre palabras y tenemos un método llamado método1. para usar los datos y métodos dentro de un módulo usamos la palabra clave require . y luego podemos usar el operador de resolución de alcance para acceder a las constantes y métodos.

require ‘ConstantsAndMethods’

puts ConstantsAndMethods::CONST_ONE

Continuando con nuestra introducción a los módulos, ahora aprenderemos sobre los mixins.

mezclas

Los mixins son nuestro cruce entre módulos y clases y es la forma en que solucionamos el problema de que Ruby no permite la herencia múltiple. podemos tener nuestros módulos constantes y métodos incluidos en nuestras clases con la palabra clave include .

Ejemplo :

# Ruby program of using mixins
module Greeting
    def display
        puts 'Hello'
    end
end
    
class Greetuser
    include Greeting
      attr_reader :name
    def initialize(name)
        @name = name
    end
end
    
# Creating object
object = Greetuser.new('User_name')
  
# Calling object
object.display
puts object.name

Producción:

Hello
User_name

Tenemos un módulo Saludo y una clase Saludousuario. como podemos ver en esta línea object.display, estamos usando el objeto de la clase Greetuser para usar la visualización del método del módulo. Podemos hacer esto debido a la inclusión que hicimos dentro de la clase, es decir, incluir Saludo.

Extender mezclas

Podemos usar extender en lugar de en su lugar, la diferencia es que extend incorpora el módulo en el nivel de clase,
por lo que la clase en sí puede usar los métodos del módulo en lugar de los objetos.

Ejemplo:

# Ruby program of extending mixins
module Greeting
    def display
        puts 'Hello'
    end
end
  
# Using extend keyword  
class Greetuser
    extend Greeting
  attr_reader :name
    def initialize(name)
        @name = name
    end
end
    
# Creating object
object = Greetuser.new('User_name')
  
# Calling object
Greetuser.display
puts object.name

Producción:

Hello
User_name

En el ejemplo anterior, reemplazamos include con extend. Así que ahora es en realidad parte de la clase. por lo tanto, podemos usar el método del módulo usando el nombre de la claseGreetuser.display