Programación Orientada a Objetos: Ejemplo de Aves

Ejemplo de Herencia y Polimorfismo en Java: Clasificación de Aves

1. Introducción

Este código Java ilustra los principios de la Programación Orientada a Objetos (POO) utilizando el ejemplo de la clasificación de aves. Se definen clases para diferentes tipos de aves, cada una con sus propios comportamientos, demostrando conceptos como herencia, interfaces y polimorfismo.

2. Estructura del Código

2.1. Clase Ave

La clase Ave es la clase base que define las características comunes a todas las aves:

• Atributos: especie (protegido), pais (protegido), tienePlumas (final booleano), poneHuevos (final booleano).
• Constructor: Inicializa la especie y el país del ave.
• Métodos: toString() (sobreescrito), getEspecie(), setEspecie().

package aves;

public class Ave {
    protected String especie;
    protected String pais;
    final boolean tienePlumas = true;
    final boolean poneHuevos = true;

    public Ave(String especie, String pais) {
        this.especie = especie;
        this.pais = pais;
    }

    @Override
    public String toString() {
        return "Tipo de ave: " + especie + " Pais de origen: " + pais + " Tiene plumas: " + tienePlumas + " Pone huevos: " + poneHuevos;
    }

    public String getEspecie() {
        return especie;
    }

    public void setEspecie(String especie) {
        this.especie = especie;
    }
}

2.2. Interfaces

Se definen tres interfaces para representar diferentes comportamientos de las aves:

• Nadador: Con el método nadar().
• Volador: Con el método volar().
• Corredor: Con el método correr().

public interface Nadador {
    public void nadar();
}

public interface Volador {
    public void volar();
}

public interface Corredor {
    public void correr();
}

2.3. Clases Derivadas

Se crean clases específicas para cada tipo de ave, heredando de la clase Ave e implementando las interfaces correspondientes:

• Aguila: Implementa Volador.
• Avestruz: Implementa Corredor.
• Cormoran: Implementa Nadador y Volador.
• Kiwi: Implementa Corredor.
• Pinguino: Implementa Nadador.

public class Aguila extends Ave implements Volador {
    public Aguila(String pais) {
        super("Aguila", pais);
    }

    @Override
    public void volar() {
        System.out.println("Soy un " + especie + " y estoy volando. ");
    }
}

public class Avestruz extends Ave implements Corredor {
    public Avestruz(String pais) {
        super("Avestruz", pais);
    }

    @Override
    public void correr() {
        System.out.println("Soy un " + especie + " y estoy corriendo. ");
    }
}

public class Cormoran extends Ave implements Nadador, Volador {
    public Cormoran(String pais) {
        super("Cormoran", pais);
    }

    @Override
    public void nadar() {
        System.out.println("Soy un " + especie + " y estoy nadando ");
    }

    @Override
    public void volar() {
        System.out.println("Soy un " + especie + " y estoy volando ");
    }
}

public class Kiwi extends Ave implements Corredor {
    public Kiwi(String pais) {
        super("Kiwi", pais);
    }

    @Override
    public void correr() {
        System.out.println("Soy un " + especie + " y estoy corriendo. ");
    }
}

public class Pinguino extends Ave implements Nadador {
    public Pinguino(String pais) {
        super("Pingüino", pais);
    }

    @Override
    public void nadar() {
        System.out.println("Soy un " + especie + " y estoy nadando ");
    }
}

2.4. Clases de Entrada y Salida

La clase EntradaSalida maneja la interacción con el usuario, mientras que la clase Principal contiene el método main que inicia la ejecución del programa.

import java.util.Scanner;

public class EntradaSalida {
    public static Scanner teclado = new Scanner(System.in);

    public static String leeString(String mensaje) {
        System.out.println(mensaje);
        return teclado.nextLine();
    }

    public static int leeInt(String mensaje, int min, int max) {
        System.out.println(mensaje);
        int numero = 0;
        boolean error;
        do {
            try {
                numero = teclado.nextInt();
                if (numero < min || numero > max) {
                    error = true;
                    System.out.println("Error: introduce un entero entre " + min + " y " + max);
                } else {
                    error = false;
                }
            } catch (Exception e) {
                System.out.println("Error: introduce un entero entre " + min + " y " + max);
                error = true;
            }
            teclado.nextLine();
        } while (error == true);
        return numero;
    }

    public static Ave leeAve() {
        Ave ave = null;
        System.out.println("Introduzca el tipo de ave que quiera crear: ");
        int tipo = EntradaSalida.leeInt("0) Avestruz\n1) Cormoran\n2) Kiwi\n3) Pingüino\n4) Aguila", 0, 4);
        String pais = EntradaSalida.leeString("Introduce el país del ave: ");
        switch (tipo) {
            case 0:
                ave = new Avestruz(pais);
                break;
            case 1:
                ave = new Cormoran(pais);
                break;
            case 2:
                ave = new Kiwi(pais);
                break;
            case 3:
                ave = new Pinguino(pais);
                break;
            case 4:
                ave = new Aguila(pais);
                break;
        }
        return ave;
    }
}

public class Principal {
    public static void main(String[] args) {
        boolean repite = true;
        final int N = 100;
        Volador[] voladoras = new Volador[N];
        Corredor[] corredoras = new Corredor[N];
        Nadador[] nadadoras = new Nadador[N];
        int cuentaCorr = 0;
        int cuentaNada = 0;
        int cuentaVola = 0;
        do {
            Ave ave = EntradaSalida.leeAve();
            if (ave instanceof Corredor) {
                corredoras[cuentaCorr] = (Corredor) ave;
                cuentaCorr++;
            }
            if (ave instanceof Nadador) {
                nadadoras[cuentaNada] = (Nadador) ave;
                cuentaNada++;
            }
            if (ave instanceof Volador) {
                voladoras[cuentaVola] = (Volador) ave;
                cuentaVola++;
            }
            switch (EntradaSalida.leeInt("1) Añadir nueva ave\n2) Mostrar resultado", 1, 2)) {
                case 1:
                    repite = true;
                    break;
                case 2:
                    repite = false;
                    break;
            }
        } while (repite == true);
        System.out.println("AVES CORREDORAS: ");
        for (int i = 0; i < cuentaCorr; i++) {
            corredoras[i].correr();
            System.out.println(corredoras[i]);
        }
        System.out.println("AVES NADADORAS: ");
        for (int i = 0; i < cuentaNada; i++) {
            nadadoras[i].nadar();
            System.out.println(nadadoras[i]);
        }
        System.out.println("AVES VOLADORAS: ");
        for (int i = 0; i < cuentaVola; i++) {
            voladoras[i].volar();
            System.out.println(voladoras[i]);
        }
    }
}

3. Conclusión

Este ejemplo demuestra cómo la POO permite modelar entidades del mundo real en un programa. La herencia permite la reutilización de código y la creación de jerarquías de clases, mientras que las interfaces y el polimorfismo proporcionan flexibilidad y extensibilidad al código.