Curso Python. Volumen XI: Herencia en Orientado a Objetos

Curso Python. Volumen XI: Herencia en Orientado a Objetos

Javier Ceballos Fernández

Bienvenidos un día más al curso de Python, hoy vamos a continuar con la programación Orientada a Objetos. Vamos hablar sobre la herencia, este recurso se utiliza para no tener que repetir atributos, ni métodos entre clases. Las clases que se obtienen aplicando el concepto de herencia, también son conocidas como subclases. Pongámonos manos a la obra para entender bien estos conceptos.

Para entender mejor este concepto seguiré usando el ejemplo del banco. En su momento definimos una clase cuenta.

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.