El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Herència

Següent ►
►

Introducció

L'herència és un concepte fonamental en la programació orientada a objectes (OOP) que permet crear noves classes basades en classes existents. Això facilita la reutilització del codi i la creació de jerarquies de classes més organitzades i mantenibles.

En Ruby, l'herència es defineix utilitzant la paraula clau <. La classe que hereta es coneix com a "subclasse" o "classe derivada", mentre que la classe de la qual hereta es coneix com a "superclasse" o "classe base".

Conceptes Clau

  • Superclasse: La classe base de la qual una altra classe hereta.
  • Subclasse: La classe que hereta d'una altra classe.
  • Herència Simple: Ruby només suporta herència simple, és a dir, una classe només pot heretar d'una altra classe.

Exemples Pràctics

Definició d'una Superclasse

class Vehicle
  def initialize(make, model)
    @make = make
    @model = model
  end

  def start_engine
    puts "El motor del #{@make} #{@model} està en marxa!"
  end
end

Creació d'una Subclasse

class Car < Vehicle
  def initialize(make, model, num_doors)
    super(make, model)  # Crida al constructor de la superclasse
    @num_doors = num_doors
  end

  def display_details
    puts "Aquest és un #{@make} #{@model} amb #{@num_doors} portes."
  end
end

Utilització de la Subclasse

my_car = Car.new("Toyota", "Corolla", 4)
my_car.start_engine
my_car.display_details

Sortida:

El motor del Toyota Corolla està en marxa!
Aquest és un Toyota Corolla amb 4 portes.

Explicació del Codi

  1. Definició de la Superclasse Vehicle:

    • El mètode initialize defineix els atributs @make i @model.
    • El mètode start_engine imprimeix un missatge indicant que el motor està en marxa.

  2. Definició de la Subclasse Car:

    • La subclasse Car hereta de Vehicle utilitzant <.
    • El mètode initialize de Car crida al mètode initialize de Vehicle utilitzant super, i després defineix l'atribut addicional @num_doors.
    • El mètode display_details imprimeix els detalls del cotxe.

  3. Utilització de la Subclasse:

    • Es crea una instància de Car amb els paràmetres "Toyota", "Corolla" i 4.
    • Es criden els mètodes start_engine i display_details de la instància my_car.

Exercicis Pràctics

Exercici 1: Creació d'una Subclasse

Crea una subclasse Motorcycle que hereti de Vehicle. Afegeix un atribut type (per exemple, "sport" o "cruiser") i un mètode display_type que imprimeixi el tipus de motocicleta.

# Solució
class Motorcycle < Vehicle
  def initialize(make, model, type)
    super(make, model)
    @type = type
  end

  def display_type
    puts "Aquesta és una motocicleta de tipus #{@type}."
  end
end

my_motorcycle = Motorcycle.new("Harley-Davidson", "Street 750", "cruiser")
my_motorcycle.start_engine
my_motorcycle.display_type

Sortida Esperada:

El motor del Harley-Davidson Street 750 està en marxa!
Aquesta és una motocicleta de tipus cruiser.

Exercici 2: Sobreescriptura de Mètodes

Crea una subclasse ElectricCar que hereti de Car. Sobreescriu el mètode start_engine per imprimir un missatge diferent, indicant que el cotxe elèctric està en marxa.

# Solució
class ElectricCar < Car
  def start_engine
    puts "El motor elèctric del #{@make} #{@model} està en marxa silenciosament!"
  end
end

my_electric_car = ElectricCar.new("Tesla", "Model S", 4)
my_electric_car.start_engine
my_electric_car.display_details

Sortida Esperada:

El motor elèctric del Tesla Model S està en marxa silenciosament!
Aquest és un Tesla Model S amb 4 portes.

Errors Comuns i Consells

  • Oblidar cridar super en el mètode initialize de la subclasse: Això pot provocar que els atributs de la superclasse no s'inicialitzin correctament.
  • No utilitzar < per definir l'herència: Assegura't d'utilitzar la sintaxi correcta per establir la relació d'herència.
  • Sobreescriptura incorrecta de mètodes: Quan sobreescrius un mètode, assegura't de mantenir la signatura del mètode (nom i paràmetres) consistent amb la superclasse.

Conclusió

L'herència és una eina poderosa en Ruby que permet crear jerarquies de classes més organitzades i reutilitzables. Mitjançant l'herència, les subclasses poden heretar comportaments i atributs de les superclasses, alhora que poden afegir o modificar funcionalitats específiques. Practicar amb exemples i exercicis t'ajudarà a comprendre millor com utilitzar l'herència de manera efectiva en els teus projectes Ruby.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats