El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Polimorfismo

Siguiente ►
►

El polimorfismo es uno de los pilares fundamentales de la Programación Orientada a Objetos (POO). En términos simples, el polimorfismo permite que una entidad, como una función o un objeto, tome múltiples formas. En Objective-C, el polimorfismo se logra principalmente a través de la herencia y la implementación de protocolos.

Conceptos Clave

  1. Polimorfismo en Tiempo de Compilación (Sobrecarga de Métodos):

    • No es común en Objective-C, ya que no soporta la sobrecarga de métodos de la misma manera que otros lenguajes como C++ o Java.

  2. Polimorfismo en Tiempo de Ejecución:

    • Se refiere a la capacidad de una clase derivada de ser tratada como una instancia de su clase base. Esto se logra mediante la herencia y la implementación de métodos en las clases derivadas.

  3. Protocolos:

    • Los protocolos en Objective-C son similares a las interfaces en otros lenguajes. Permiten definir un conjunto de métodos que pueden ser implementados por cualquier clase.

Ejemplo Práctico

Definición de Clases y Herencia

Primero, definamos una clase base Animal y dos clases derivadas Dog y Cat.

// Animal.h
#import <Foundation/Foundation.h>

@interface Animal : NSObject
- (void)speak;
@end

// Animal.m
#import "Animal.h"

@implementation Animal
- (void)speak {
    NSLog(@"Animal makes a sound");
}
@end

// Dog.h
#import "Animal.h"

@interface Dog : Animal
@end

// Dog.m
#import "Dog.h"

@implementation Dog
- (void)speak {
    NSLog(@"Dog barks");
}
@end

// Cat.h
#import "Animal.h"

@interface Cat : Animal
@end

// Cat.m
#import "Cat.h"

@implementation Cat
- (void)speak {
    NSLog(@"Cat meows");
}
@end

Uso del Polimorfismo

Ahora, veamos cómo podemos usar el polimorfismo para tratar diferentes objetos de tipo Animal.

#import <Foundation/Foundation.h>
#import "Animal.h"
#import "Dog.h"
#import "Cat.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Animal *myDog = [[Dog alloc] init];
        Animal *myCat = [[Cat alloc] init];
        
        NSArray *animals = @[myDog, myCat];
        
        for (Animal *animal in animals) {
            [animal speak]; // Polimorfismo en acción
        }
    }
    return 0;
}

Explicación del Código

  1. Definición de la Clase Base Animal:

    • La clase Animal tiene un método speak que imprime un mensaje genérico.

  2. Clases Derivadas Dog y Cat:

    • Ambas clases heredan de Animal y sobrescriben el método speak para proporcionar su propia implementación.

  3. Uso del Polimorfismo:

    • En el main, creamos instancias de Dog y Cat y las almacenamos en un arreglo de tipo Animal.
    • Al iterar sobre el arreglo y llamar al método speak, se invoca la implementación específica de cada clase derivada, demostrando el polimorfismo en tiempo de ejecución.

Ejercicio Práctico

Ejercicio

  1. Crea una clase base Vehicle con un método move.
  2. Crea dos clases derivadas Car y Bicycle que sobrescriban el método move.
  3. En el main, crea instancias de Car y Bicycle, almacénalas en un arreglo de tipo Vehicle y llama al método move en un bucle.

Solución

// Vehicle.h
#import <Foundation/Foundation.h>

@interface Vehicle : NSObject
- (void)move;
@end

// Vehicle.m
#import "Vehicle.h"

@implementation Vehicle
- (void)move {
    NSLog(@"Vehicle is moving");
}
@end

// Car.h
#import "Vehicle.h"

@interface Car : Vehicle
@end

// Car.m
#import "Car.h"

@implementation Car
- (void)move {
    NSLog(@"Car is driving");
}
@end

// Bicycle.h
#import "Vehicle.h"

@interface Bicycle : Vehicle
@end

// Bicycle.m
#import "Bicycle.h"

@implementation Bicycle
- (void)move {
    NSLog(@"Bicycle is pedaling");
}
@end

// main.m
#import <Foundation/Foundation.h>
#import "Vehicle.h"
#import "Car.h"
#import "Bicycle.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Vehicle *myCar = [[Car alloc] init];
        Vehicle *myBicycle = [[Bicycle alloc] init];
        
        NSArray *vehicles = @[myCar, myBicycle];
        
        for (Vehicle *vehicle in vehicles) {
            [vehicle move]; // Polimorfismo en acción
        }
    }
    return 0;
}

Conclusión

El polimorfismo es una característica poderosa de la Programación Orientada a Objetos que permite que diferentes clases derivadas sean tratadas como instancias de su clase base. Esto facilita la creación de código flexible y reutilizable. En Objective-C, el polimorfismo se logra principalmente a través de la herencia y la implementación de métodos en las clases derivadas. A medida que avances en tu aprendizaje, verás cómo el polimorfismo puede simplificar y mejorar la estructura de tu código.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados