OOP, Trouble understanding composition versus inheritance

Let's examine the data model first.

A Savings Bank contains deposits of various types in the name of various holders. The correct model contains three classes: Savings Bank, Deposit and Holder, since a person can have several deposits and the Savings Bank contains deposits from many people.

Holder Class

The title class is the easiest. In real life, data such as your ID, address, etc. would have to be included.

# Titulares
class Titular:
    def __init__(self, nombre):
        self.nombre = nombre

    def __str__(self):
        return f"Nombre: {self.nombre}"

Important: it is not printed inside classes. What it does is return a string that can be used to print, or send by email, etc. That's why we define the function __str__for all classes.

When you write print(algo), what Python does is look up the method __str__of the object algo, call it to get a string which will then be printed.

Account Class

The Account class must include all methods to be used in derived classes; for that reason I included the method ganancia, since every account has a profit, even if it is zero.

# creamos la clase Cuenta
class Cuenta:
    # inicializamos los atributos de la clase
    def __init__(self, titular, cantidad):
        self.titular = titular
        self.cantidad = cantidad

    def ganancia(self):
        return 0

    # imprimimos los datos
    def __str__(self):
        return f"{str(self.titular)}\n    Cantidad: {self.cantidad}"

Fixed Term Class

This class derives from account, and what it does is model a fixed-term deposit with a certain interest.

# creamos la clase PlazoFijo
# esta clase también hereda atributos de la clase Cuenta
class PlazoFijo(Cuenta):
    # inicializamos los atributos de la clase
    def __init__(self, titular, cantidad, plazo, interes):
        super().__init__(titular, cantidad)
        self.plazo = plazo
        self.interes = interes

        # calculamos la ganancia

    def ganancia(self):
        ganancia = self.cantidad * self.interes / 100
        return ganancia

    # imprimimos los resultados
    def __str__(self):
        return f"""
    Cuenta a plazo fijo 
    {super().__str__()}
    Plazo disponible en días: {self.plazo}
    Interés: {self.interes}
    Ganancia: {self.ganancia()}
    """

SavingsBox Class

This class is a container for accounts (deposits actually). All we need is a name for the box.

Since the class is a container for accounts, we add the method addto add a new account.

class CajaAhorro():
    # iniciamos los atributos de la clase
    def __init__(self, nombre):
        self.nombre = nombre
        self.cuentas = []

    def add(self, cuenta):
        self.cuentas.append(cuenta)

    def __str__(self):
        st = [f"Caja Ahorro {self.nombre}"]
        st.extend([str(x) for x in self.cuentas])
        return "\n".join(st)

show

Let's see how everything works when Manuel decides to take two time deposits:

# Titulares
class Titular:
    def __init__(self, nombre):
        self.nombre = nombre

    def __str__(self):
        return f"Nombre: {self.nombre}"

# creamos la clase Cuenta
class Cuenta:
    # inicializamos los atributos de la clase
    def __init__(self, titular, cantidad):
        self.titular = titular
        self.cantidad = cantidad

    def ganancia(self):
        return 0

    # imprimimos los datos
    def __str__(self):
        return f"{str(self.titular)}\n    Cantidad: {self.cantidad}"

# creamos la clase PlazoFijo
# esta clase también hereda atributos de la clase Cuenta
class PlazoFijo(Cuenta):
    # inicializamos los atributos de la clase
    def __init__(self, titular, cantidad, plazo, interes):
        super().__init__(titular, cantidad)
        self.plazo = plazo
        self.interes = interes

        # calculamos la ganancia

    def ganancia(self):
        ganancia = self.cantidad * self.interes / 100
        return ganancia

    # imprimimos los resultados
    def __str__(self):
        return f"""
    Cuenta a plazo fijo 
    {super().__str__()}
    Plazo disponible en días: {self.plazo}
    Interés: {self.interes}
    Ganancia: {self.ganancia()}
    """

# creamos la clase CajaAhorro, una colección de cuentas
class CajaAhorro():
    # iniciamos los atributos de la clase
    def __init__(self, nombre):
        self.nombre = nombre
        self.cuentas = []

    def add(self, cuenta):
        self.cuentas.append(cuenta)

    def __str__(self):
        st = [f"Caja Ahorro {self.nombre}"]
        st.extend([str(x) for x in self.cuentas])
        return "\n".join(st)

titular = Titular("Manuel")
plazo_fijo = PlazoFijo(titular, 5000, 60, 1)
plazo_fijo2 = PlazoFijo(titular, 1000, 90, 1.1)
caja_ahorro = CajaAhorro("La Preferida")
caja_ahorro.add(plazo_fijo)
caja_ahorro.add(plazo_fijo2)
print(caja_ahorro)

produces

Caja Ahorro La Preferida

    Cuenta a plazo fijo 
    Nombre: Manuel
    Cantidad: 5000
    Plazo disponible en días: 60
    Interés: 1
    Ganancia: 50.0
    

    Cuenta a plazo fijo 
    Nombre: Manuel
    Cantidad: 1000
    Plazo disponible en días: 90
    Interés: 1.1
    Ganancia: 11.0
    

Edition: Composition/Inheritance

The class CuentaAhorrois essentially a list ( composition ) of class objects Cuenta. The class CuentaAhorrodoes not inherit or duplicate any methods of the class listused to store the accounts.

The class Cuentaillustrates both composition (incorporates an object Titular) and inheritance; has a subclass of CuentaFija.

Each technique has its application.