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, se comporte de diferentes maneras en diferentes contextos. En Groovy, el polimorfismo se puede lograr principalmente a través de la herencia y la implementación de interfaces.

Conceptos Clave

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

    • Permite definir múltiples métodos con el mismo nombre pero con diferentes parámetros.
    • La decisión de qué método invocar se toma en tiempo de compilación.

  2. Polimorfismo en Tiempo de Ejecución (Sobrescritura de Métodos):

    • Permite que una subclase proporcione una implementación específica de un método que ya está definido en su superclase.
    • La decisión de qué método invocar se toma en tiempo de ejecución.

Ejemplo Práctico

Sobrecarga de Métodos

class Calculadora {
    int sumar(int a, int b) {
        return a + b
    }

    double sumar(double a, double b) {
        return a + b
    }

    int sumar(int a, int b, int c) {
        return a + b + c
    }
}

def calc = new Calculadora()
println calc.sumar(2, 3)          // Salida: 5
println calc.sumar(2.5, 3.5)      // Salida: 6.0
println calc.sumar(1, 2, 3)       // Salida: 6

Sobrescritura de Métodos

class Animal {
    void hacerSonido() {
        println "El animal hace un sonido"
    }
}

class Perro extends Animal {
    @Override
    void hacerSonido() {
        println "El perro ladra"
    }
}

class Gato extends Animal {
    @Override
    void hacerSonido() {
        println "El gato maúlla"
    }
}

def animales = [new Perro(), new Gato(), new Animal()]

animales.each { animal ->
    animal.hacerSonido()
}

// Salida:
// El perro ladra
// El gato maúlla
// El animal hace un sonido

Ejercicio Práctico

Ejercicio 1: Sobrecarga de Métodos

  1. Crea una clase Matematica con métodos sobrecargados para calcular el área de diferentes formas geométricas:
    • Un método para calcular el área de un círculo (areaCirculo(double radio)).
    • Un método para calcular el área de un rectángulo (areaRectangulo(double largo, double ancho)).
    • Un método para calcular el área de un triángulo (areaTriangulo(double base, double altura)).

Ejercicio 2: Sobrescritura de Métodos

  1. Crea una clase Vehiculo con un método mover().
  2. Crea dos subclases Coche y Bicicleta que sobrescriban el método mover() con implementaciones específicas.
  3. Crea una lista de objetos Vehiculo que contenga instancias de Coche y Bicicleta, y llama al método mover() en un bucle para demostrar el polimorfismo.

Soluciones

Solución Ejercicio 1

class Matematica {
    double areaCirculo(double radio) {
        return Math.PI * radio * radio
    }

    double areaRectangulo(double largo, double ancho) {
        return largo * ancho
    }

    double areaTriangulo(double base, double altura) {
        return 0.5 * base * altura
    }
}

def mat = new Matematica()
println mat.areaCirculo(5)          // Salida: 78.53981633974483
println mat.areaRectangulo(4, 5)    // Salida: 20.0
println mat.areaTriangulo(3, 4)     // Salida: 6.0

Solución Ejercicio 2

class Vehiculo {
    void mover() {
        println "El vehículo se está moviendo"
    }
}

class Coche extends Vehiculo {
    @Override
    void mover() {
        println "El coche está conduciendo"
    }
}

class Bicicleta extends Vehiculo {
    @Override
    void mover() {
        println "La bicicleta está pedaleando"
    }
}

def vehiculos = [new Coche(), new Bicicleta(), new Vehiculo()]

vehiculos.each { vehiculo ->
    vehiculo.mover()
}

// Salida:
// El coche está conduciendo
// La bicicleta está pedaleando
// El vehículo se está moviendo

Resumen

En esta sección, hemos explorado el concepto de polimorfismo en Groovy, tanto en tiempo de compilación como en tiempo de ejecución. Hemos visto cómo la sobrecarga y la sobrescritura de métodos permiten que las clases y los objetos se comporten de diferentes maneras en diferentes contextos. Los ejercicios prácticos proporcionan una oportunidad para aplicar estos conceptos y reforzar el aprendizaje. En el próximo módulo, profundizaremos en la encapsulación y cómo proteger los datos dentro de nuestras clases.

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