4.2.- Métodos abstractos.

Un método abstracto es un método cuya implementación no se define, sino que se declara únicamente su interfaz (cabecera) para que su cuerpo sea implementado más adelante en una clase derivada.

Cuadro abstracto de Joan Miró. — ITE idITE=120523 (CC BY-NC-SA)

Un método se declara como abstracto mediante el uso del modificador abstract (como en las clases abstractas):

[modificador_acceso] abstract  <tipo> <nombreMetodo> ([parámetros]) [excepciones];

Estos métodos tendrán que ser obligatoriamente redefinidos (en realidad “definidos”, pues aún no tienen contenido) en las clases derivadas. Si en una clase derivada se deja algún método abstracto sin implementar, esa clase derivada será también una clase abstracta.

Cuando una clase contiene un método abstracto tiene que declararse como abstracta obligatoriamente.

Esquema que muestra una estructura jerárquica de herencia con una superclase (Empleado) y tres subclases (EmpleadoFijo, EmpleadoTemporal y EmpleadoComercial). — Ministerio de Educación y FP (CC BY-NC)

Imagina que tienes una clase Empleado genérica para diversos tipos de empleado y tres clases derivadas: EmpleadoFijo (tiene un salario fijo más ciertos complementos), EmpleadoTemporal (salario fijo más otros complementos diferentes) y EmpleadoComercial (una parte de salario fijo y unas comisiones por cada operación). La clase Empleado podría contener un método abstracto calcularNomina, pues sabes que se método será necesario para cualquier tipo de empleado (todo empleado cobra una nómina). Sin embargo el cálculo en sí de la nómina será diferente si se trata de un empleado fijo, un empleado temporal o un empleado comercial, y será dentro de las clases especializadas de Empleado (EmpleadoFijo¸ EmpleadoTemporal, EmpleadoComercial) donde se implementen de manera específica el cálculo de las mismas.

Debes tener en cuenta al trabajar con métodos abstractos:

Un método abstracto implica que la clase a la que pertenece tiene que ser abstracta, pero eso no significa que todos los métodos de esa clase tengan que ser abstractos.
Un método abstracto no puede ser privado (no se podría implementar, dado que las clases derivadas no tendrían acceso a él).
Los métodos abstractos no pueden ser estáticos, pues los métodos estáticos no pueden ser redefinidos (y los métodos abstractos necesitan ser redefinidos).

Autoevaluación

Retroalimentación

Falso

Una clase abstracta puede contener métodos abstractos, pero también métodos que estén completamente definidos (no abstractos). Lo que sí es cierto es que si una clase contiene algún método abstracto, entonces tendrá que ser obligatoriamente una clase abstracta.

Ejercicio resuelto

Basándote en la jerarquía de clases Persona, Alumno, Profesor, crea un método abstracto llamado mostrar para la clase Persona. Dependiendo del tipo de persona (alumno o profesor) el método mostrar tendrá que mostrar unos u otros datos personales (habrá que hacer implementaciones específicas en cada clase derivada).

Una vez hecho esto, implementa completamente las tres clases (con todos sus atributos y métodos) y utilízalas en un pequeño programa de ejemplo que cree un objeto de tipo Alumno y otro de tipo Profesor, los rellene con información y muestre esa información en la pantalla a través del método mostrar.

Retroalimentación

Dado que el método mostrar no va a ser implementado en la clase Persona, será declarado como abstracto y no se incluirá su implementación:

protected abstract void mostrar ();

Recuerda que el simple hecho de que la clase Persona contenga un método abstracto hace que sea clase sea abstracta (y deberá indicarse como tal en su declaración): public abstract class Persona.

En el caso de la clase Alumno habrá que hacer una implementación específica del método mostrar y lo mismo para el caso de la clase Profesor.

Método mostrar para la clase Alumno.

// Redefinición del método abstracto mostrar en la clase Alumno

public void mostrar () {

    SimpleDateFormat formatoFecha = new SimpleDateFormat("dd/MM/yyyy");

    String Stringfecha= formatoFecha.format(this.fechaNacim.getTime());

    System.out.printf ("Nombre: %s\n", this.nombre);

    System.out.printf ("Apellidos: %s\n", this.apellidos);

    System.out.printf ("Fecha de nacimiento: %s\n", Stringfecha);

    System.out.printf ("Grupo: %s\n", this.grupo);

    System.out.printf ("Grupo: %5.2f\n", this.notaMedia);            

}

Método mostrar para la clase Profesor.

// Redefinición del método abstracto mostrar en la clase Profesor

public void mostrar () {

    SimpleDateFormat formatoFecha = new SimpleDateFormat("dd/MM/yyyy");

    String Stringfecha= formatoFecha.format(this.fechaNacim.getTime());

    System.out.printf ("Nombre: %s\n", this.nombre);

    System.out.printf ("Apellidos: %s\n", this.apellidos);

    System.out.printf ("Fecha de nacimiento: %s\n", Stringfecha);

    System.out.printf ("Especialidad: %s\n", this.especialidad);

    System.out.printf ("Salario: %7.2f euros\n", this.salario);                   

}

Programa de ejemplo de uso.

Un pequeño programa de ejemplo de uso del método mostrar en estas dos clases podría ser:

// Declaración de objetos

        Alumno alumno;

        Profesor profe;

        // Creación de objetos (llamada a constructores)

        alumno= new Alumno ("Juan", "Torres", new GregorianCalendar (1990, 10, 6), "1DAM-B", 7.5);

        profe= new Profesor ("Antonio", "Campos", new GregorianCalendar (1970, 8, 15), "Mates", 2000);

        // Utilización del método mostrar

        alumno.mostrar();

        profesor.mostrar();

Puedes descargar del siguiente enlace un ejemplo completo en el que se declara la clase Persona como abstracta y con el método abstracto mostrar. Sus subclases Alumno y Profesor redefinen ese método especializándolo para cada una de ellas.

Proyecto EjemploClaseAbstractaPersona. (21 KB)

Para saber más

Observa en la siguiente imagen cómo se pueden añadir los métodos abstractos heredados en una clase derivada de forma automática. Nuestro trabajo únicamente sería darles implementación porque de añadirlos ya se encarga Netbeans.

Ilustración que muestra cómo añadir en una clase derivada los métodos abstractos heredados, de forma automática en Netbeans. — Ministerio de Educación y FP (CC BY-NC)

Observa cómo Netbeans sugiere varias opciones, entre ellas, declarar la clase Nino también abstracta.

Pregunta 1

Retroalimentación

Retroalimentación