Interfaces

Clases Abstractas e Interfaces
Material de clase elaborado por Sandra Victoria Hurtado Gil

Clases Abstractas
Se tiene el siguiente diagrama de clases, que muestra las cuentas que se pueden tener
en una entidad financiera: Cuentas corrientes y cuentas de ahorros:

Las clases CuentaCorriente y CuentaAhorros heredan de Cuenta, pero el código de retirar
es propio de cada una. Esto, sinembargo tiene el inconveniente de el banco no puede
manejar sus cuentas de manera homogénea, tendría siempre que tener aparte las
cuentas de ahorro y aparte las corrientes, a pesar de que ofrecen el mismo servicio, por
ejemplo:
Cuenta cuentaGeneral = new CuentaCorriente(“1-a”,1,10000,2000);
boolean pudoRetirar = cuentaGeneral.retirar(2000); //ERROR

Lo anterior no se puede hacer porque no hay unmétodo retirar en la clase Cuenta. Se
tendría que hacer una conversión de tipos (cast) para poder referenciar el objeto a través
de una variable CuentaCorriente, así:
CuentaCorriente unaCuenta = (CuentaCorriente)cuentaGeneral;
pudoRetirar = unaCuenta.retirar(2000);

Sería muy complicado para el banco tener que hacer un cast cada vez que necesite hacer
una operación en una cuenta. Ademástendría que verificar que el cast sea realmente
posible (para no convertir por error una cuenta corriente en una de ahorros o viceversa, lo
cual generaría un error al ejecutar el programa). Esta validación se hace con el operador
“instanceof”, así

if (cuentaGeneral instanceof CuentaCorriente) {
CuentaCorriente unaCuenta = (CuentaCorriente)cuentaGeneral;
pudoRetirar =unaCuenta.retirar(2000);
}

La solución es crear un método en la clase Cuenta, de manera que sus hijas puedan
sobreescribirlo, y que permita que al banco usarlo en todo tipo de cuentas.
El código de las clases CuentaCorriente y CuentaAhorros, quedaría igual, y solo
cambiaría la clase Cuenta, así:
public class Cuenta {
String número;
int clave;
double saldo;
public Cuenta(String num, int cla, double sal) {número = num;
clave = cla;
saldo = sal;
}
public void consignar(double cantidad) {
saldo = saldo + cantidad;
}
public boolean retirar(double cantidad) {
return true; // un valor de retorno ficticio
}
public double getSaldo() {
return saldo;
}
}

Aquí ya se soluciona el problema para el banco, pero fue necesario crear un código “falso”
en el método retirar de Cuenta. Esto se debe a queel banco nunca tendrá un objeto
Cuenta. Siempre serán objetos CuentaCorriente o CuentaAhorros, y el método retirar no
se usará directamente en objetos Cuenta, sino en objetos de las clases hijas.
La solución es declarar el método abstracto, con la palabra “abstract” en Java. Un
método abstracto no tiene cuerpo, y debe ser sobreescrito en las clases hijas.
La parte del código correspondienteal método quedaría:
//Un método abstracto no tiene cuerpo, solo el encabezado
public abstract boolean retirar(double cantidad);

Sin embargo, para poder definir métodos abstractos es necesario que la clase sea
abstracta. Una clase abstracta permite definir los atributos y métodos generales que
tendrán sus hijas, pero no se usará para crear objetos, lo cual es el caso de la clase
Cuenta.
Elcódigo de la clase queda:

public abstract class Cuenta {
String número;
int clave;
double saldo;
public Cuenta(String num, int cla, double sal) {
número = num;
clave = cla;
saldo = sal;
}
public void consignar(double cantidad) {
saldo = saldo + cantidad;
}
public abstract boolean retirar(double cantidad);
public double getSaldo() {
return saldo;
}
}

A diferencia de lasclases abstractas, las clases de las cuales se pueden crear objetos se
denominan clases concretas.
Exceptuando la posibilidad de crear instancias u objetos a partir de ellas, las clases
abstractas se comportan como cualquier otra clase: pueden tener atributos, métodos, e
incluso se pueden definir variables de su tipo, que harán referencia a objetos de sus
clases hijas.
Algunas observaciones...