Neste projeto, vamos construir um sistema bancário simples que inclui duas classes principais: Conta e Cliente. Este projeto tem como objetivo aplicar os conceitos de encapsulamento que discutimos anteriormente. Vamos começar.

Classe Cliente

Criamos primeiro a classe Cliente que representará o cliente de um banco.

class Cliente:
    def __init__(self, nome, sobrenome, nif):
        self._nome = nome
        self._sobrenome = sobrenome
        self._nif = nif

    def get_nome_completo(self):
        return f"{self._nome} {self._sobrenome}"

    def get_nif(self):
        return self._nif

Classe Conta

Em seguida, criamos a classe Conta. Esta classe terá informações sobre o saldo e permitirá operações como depósito e levantamento.

class Conta:
    def __init__(self, cliente, saldo_inicial=0):
        self._cliente = cliente
        self._saldo = saldo_inicial

    def depositar(self, quantia):
        if quantia > 0:
            self._saldo += quantia
            return True
        return False

    def levantar(self, quantia):
        if 0 < quantia <= self._saldo:
            self._saldo -= quantia
            return True
        return False

    def consultar_saldo(self):
        return self._saldo

    def get_cliente(self):
        return self._cliente.get_nome_completo()

Utilização do Sistema

Agora que temos as nossas classes definidas, vamos ver como podemos utilizar este sistema bancário.

def main():
    # Criar um cliente
    cliente = Cliente("João", "Silva", "123456789")

    # Criar uma conta para o cliente com saldo inicial de 1000
    conta = Conta(cliente, 1000)

    # Consultar o saldo atual
    print(f"Saldo atual: €{conta.consultar_saldo()}")

    # Depositar 500
    conta.depositar(500)
    print(f"Saldo após depósito: €{conta.consultar_saldo()}")

    # Levantar 200
    if conta.levantar(200):
        print(f"Saldo após levantamento: €{conta.consultar_saldo()}")
    else:
        print("Levantamento falhou! Saldo insuficiente.")

    # Consultar informações do cliente associado à conta
    print(f"Cliente: {conta.get_cliente()}")

if __name__ == "__main__":
    main()

Resumo

Neste capítulo, construímos um sistema bancário simples com duas classes principais: Cliente e Conta. Utilizámos o conceito de encapsulamento para proteger os dados das nossas classes, e fornecemos métodos públicos para interagir com esses dados de forma controlada.

Quiz

1. O que é encapsulamento e por que é importante em POO?

   • a) É o processo de esconder dados de implementação interna, permitindo acesso apenas através de métodos definidos.
   • b) É o método de herdar métodos e atributos de outra classe.
   • c) Significa criar múltiplas espécies de métodos com o mesmo nome.

2. Qual a utilidade do método depositar na classe Conta?

   • a) Atualizar o nome do cliente.
   • b) Adicionar uma quantia ao saldo da conta, se a quantia for positiva.
   • c) Levantar uma quantia do saldo da conta.

3. Como podemos aceder ao nome completo de um cliente associado a uma conta?

   • a) Utilizando o método get_nome_completo diretamente na classe Conta.
   • b) Passando o nome diretamente ao método consultar_saldo.
   • c) Através do método get_cliente na classe Conta.

4. O que acontece se tentar levantar mais dinheiro do que o saldo existente na classe Conta?

   • a) Levantamento é realizado, mas o saldo torna-se negativo.
   • b) Levantamento falha e o saldo permanece o mesmo.
   • c) Levantamento é realizado sem verificar o saldo.

Respostas: 1-a, 2-b, 3-c, 4-b