Curso Python. Volumen XI: Herencia en Orientado a Objetos

Escrito por 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.

Últimos análisis

Valoración RZ
7
Valoración RZ
9
Valoración RZ
8
Valoración RZ
8
Valoración RZ
8
Valoración RZ
8
Valoración RZ
10