Operaciones y clases abstractas

Hasta ahora hemos venido trabajando con clases “normales”, es decir, clases que definen
objetos y tienen sus operaciones definidas allí, las cuales tienen su implementación
(método). Mediante la herencia podíamos redefinir estas implementaciones a nuestro gusto
manteniendo obviamente la firma de la operación. Además, siempre podíamos crear objetos
de cualquier clase que definiéramos. Ahora comenzaremos a ver algunos aspectos que
complejizan todo esto.

-----------------------------------------------------------------------------------

Operación abstracta:

Una operación abstracta es una operación que no tiene método, es decir, una operación que
solo tiene la firma. A priori puede no resultar útil esta herramienta, es decir, perfectamente
ustedes pueden preguntarse ¿para qué sirve una operación que no funciona? Digamos que
podría haber alguna situación en la que, dada una clase, sabemos que debe tener tal o cual
operación pero que por algún motivo no queremos o no podemos implementarla, por tanto
la declaramos como abstracta.

Por ejemplo, en mi clase Persona yo podría definir una operación calcularSueldo que
retorne el sueldo de una Persona, pero en esa clase no tenemos suficientes datos como para
brindar dicho valor. Por tanto declaramos esa operación como abstracta. Serán luego las
clases derivadas las encargadas de darle método a esa operación.

Para declarar una operación como abstracta usamos la palabra reservada abstract antes del
tipo de retorno. Por ejemplo:

Código:
1. public abstract String getNombre();

En forma general sería:

Código:
1. modificadorDeAcceso abstract tipoDeRetorno
nombreDeLaOperacion(argumentos);

Obviamente, al ser abstracta y no tener método, la operación no lleva llaves de apertura { y

cierre }. Así, colocamos la firma y luego el punto y coma.

NOTA: Una operación NO abstracta se llama concreta.

---------------------------------------------------------------------------------

Clase abstracta:

Una clase abstracta es una clase que no puede ser instanciada, es decir no podemos crear
objetos de ella haciendo new. Esto implica que no podemos obtener instancias directas de
la clase. Por ejemplo, si mi clase Persona es abstracta yo no puedo hacer new Persona, sin
embargo, puedo tener clases derivadas de ella y por tanto objetos de sus clases derivadas
son también objetos Persona (la herencia de ahora en más estará siempre presente).

Para indicar que una clase es abstracta utilizamos la palabra abstract antes de la palabra
class al declararla, por ejemplo:

Código:
1. public abstract class Persona {. . .

Al igual que con las operaciones abstractas, pueden preguntarse para qué puede servir una
clase de la que no puedo crear objetos directamente. Pues en muchos casos son útiles. Yo
podría querer que exista la clase Persona y defina lo básico que debe tener una Persona,
pero no quiero que existan objetos directos de Persona, sino que lo que quiero es que se
herede de ella para extenderla, teniendo en mi sistema objetos Empleado, Trabajador,
Proveedor, etc.

Regla importante:

Si una clase tiene al menos una operación abstracta entonces la clase debe ser abstracta. Si
no lo hacemos NetBeans nos marcará error de sintaxis. ¿A qué se debe esto? Pues si lo
piensan un segundo seguro lo deducen. Si una clase NO es abstracta (es concreta) significa
que yo puedo crear objetos de ella, pero si tiene una operación abstracta esta no tendrá
método. ¿Qué pasa cuando yo llame a esa operación a través de un objeto? Pues justamente
eso no puede suceder.
No deben confundir esto a la inversa, o sea, una clase declarada como abstracta puede NO
tener ninguna operación abstracta. Es decir, yo puedo declarar una clase como abstracta
pero declarar todas sus operaciones como concretas. Con esto simplemente diré que no
quiero que se creen instancias directas de esa clase.

Observación: Una clase abstracta está pensada para ser heredada, es decir, para que existan
instancias indirectas de ella. Cuando una clase hereda de una clase abstracta alguna
operación abstracta tiene dos opciones:

 Deja la operación así como está, es decir, la deja abstracta.

 Le da método a esa operación.
Si una clase que hereda una operación abstracta no le da método a esta entonces la
operación se mantendrá abstracta y por tanto esta clase también debe ser abstracta. Para
cambiar esto, la clase derivada debe dar método a todas las operaciones abstractas que
hereda.

==============================================