class Cuenta(object): 
  
     def __init__(self,numeroCuenta,cantidad=0.0): 
         self.__numCuenta=numeroCuenta 
         self.__saldo = cantidad 
  
     def sacarDinero(self, cantidad): 
         self.__saldo -= cantidad 
  
     def ingresarDinero(self, cantidad): 
         self.__saldo += cantidad 
  
     def getSaldo(self): 
         return self.__saldo 
  
     def getNumeroCuenta(self): 
         return self.__numCuenta

Ahora crearemos dos subclases, serán clases que hereden cuenta, ya que un banco tiene diferentes tipos de cuenta. Una será “CuentaAhorro” y la otra “CuentaCorriente“. Ambas cuentas serán derivadas de Cuenta.

Para realizar esto en Python es sencillo como os muestro a continuación:

from cuenta import Cuenta 
  
 class CuentaAhorro(Cuenta): 
     def __init__(self, numeroCuenta, cantidad, fecha, tipo=0.0): 
         Cuenta.__init__(self, numeroCuenta, cantidad) 
         self.__tipoInteres = 1 + tipo 
         self.__fechaApertura = fecha 
  
     def getTipoInteres(self): 
         return self.__tipoInteres 
  
     def setTipoInteres(self, interes): 
         self.__tipoInteres = interes 
  
     def getFecha(self): 
         return self.__fechaApertura 
  
     def ingresarDinero(self, cantidad): 
         self.__saldo += cantidad*self.__tipoInteres

Como se puede comprobar cambiamos el objeto por Cuenta, ya que ahora derivamos de esa clase y no de la genérica. En el constructor (El método “init”) se llama al constructor de la clase padre y hemos añadido 2 nuevos atributos. Tipo de interés y fecha apertura, y hemos modificado el método “ingresarDinero” ya que ahora aplicamos un interés en cada ingreso.

Con la clase “cuentaCorriente” hemos hecho lo siguiente:

from cuenta import Cuenta 
  
 class CuentaCorriente(Cuenta): 
     def __init__(self, numeroCuenta, cantidad, tipo=0.0,tarjetaDebito=False,tarjetaCredito=False,cuota=0.0): 
         Cuenta.__init__(self, numeroCuenta, cantidad) 
         self.__tipoInteres = 1 + tipo 
         self.__tarjetaDebito = tarjetaDebito 
         self.__tarjetaCredito = tarjetaCredito 
         self.__cuotaMantenimiento = cuota 
  
     def getTipoInteres(self): 
         return self.__tipoInteres 
  
     def setTipoInteres(self, interes): 
         self.__tipoInteres = interes 
  
     def getTarjetaDebito(self): 
         return self.__tarjetaDebito 
  
     def setTarjetaDebito(self, tarjeta): 
         self.__tarjetaDebito = tarjeta 
  
     def getTarjetaCredito(self): 
         return self.__tarjetaCredito 
  
     def setTarjetaCredito(self, tarjeta): 
         self.__tarjetaCredito = tarjeta 
  
     def getCuotaMantenimiento(self): 
         return self.__cuotaMantenimiento 
  
     def setCuotaMantenimiento(self, cuota): 
         self.__cuotaMantenimiento = cuota 
  
     def getSaldo(self): 
         return self.__saldo*self.__tipoInteres

Se parece mucho a la clase “CuentaAhorro”, solo que aquí hemos añadido tarjetas y el interés se aplica al saldo completo.

Como se puede comprobar, la herencia sólo es realizar clases derivadas. La filosofía que se sigue es tener una clase padre que tiene lo común de todas las clases hijas, tanto si únicamente es para definir una estructura o para definir una funcionalidad específica, luego las clases hijas se especifican como hemos podido comprobar en estas dos clases.

Otro ejemplo muy común de clases derivadas sería el siguiente:

Creamos una clase “Figura”, con un método de calcular el área, pero esta vez la dejamos vacía como os muestro a continuación, esto es debido a que cada figura tiene su modo de calcular el área y tendremos que definirlo en las subclases:

class Figura(object): 
     """ Una figura en el plano. """ 
  
     def area(self): 
         " Este método debe ser redefinido. " 
         pass

Ahora crearemos dos subclases:

Círculo

from math import pi 
  
 class Circulo(Figura): 
     """ Un círculo en el plano. """ 
  
     def __init__(self, radio=0): 
         " Constructor de círculo. " 
         self.radio = radio 
  
     def area(self): 
         " Devuelve el área del círculo. " 
         return pi * self.radio * self.radio

Triángulo

from math import pi</pre> 
 <pre>class Triangulo(Figura): 
     """ Un triángulo en el plano. """ 
  
     def __init__(self, base=0, altura=0): 
         " Constructor de triángulo. " 
         self.base = base 
         self.altura = altura 
  
     def area(self): 
         " Devuelve el área del triángulo. " 
         return self.base * self.altura / 2.

Y esto es todo por hoy, como veis la herencia es muy fácil de aplicar y a la vez útil porque nos ayuda a mantener nuestro código ordenado. Os invito a que probéis a integrarlo en nuestro programa de ejemplo, sé que os comenté que en esta entrega os daría la solución a lo que os propuse en el capítulo anterior, pero he pensado que es mejor que sigáis enredando con este tipo de programación. Pero no os preocupéis la solución os la daré más adelante.

Os recomendamos visitar nuestro curso online de Python para leer todas y cada una de las entregas que tenemos hasta ahora.