Para consolidar os conhecimentos sobre Programação Orientada a Objetos (POO) em Python, vamos desenvolver um projeto prático: um sistema de gestão de animais. Este sistema permitirá gerir informações sobre animais e os seus donos, utilizando conceitos como classes, herança, encapsulamento e polimorfismo. Vamos começar com o planeamento do projeto e, em seguida, desenvolver o código passo a passo.

Planeamento do Projeto

O sistema de gestão de animais terá as seguintes funcionalidades:

1. Adicionar, remover e mostrar animais.
2. Adicionar, remover e mostrar donos.
3. Associar animais a donos.
4. Utilizar herança para diferenciar tipos de animais (cães e gatos).
5. Encapsulamento para proteger os dados sensíveis.

Estrutura de Classes

Vamos definir as seguintes classes:

• Animal: Classe base para todos os animais.
• Cao e Gato: Subclasses que herdam de Animal.
• Dono: Para gerir as informações dos donos.
• SistemaGestao: Para gerir as funcionalidades do sistema.

Implementação do Projeto

Classe Animal

class Animal:
    def __init__(self, nome, idade, especie):
        self._nome = nome
        self._idade = idade
        self._especie = especie
    
    def get_nome(self):
        return self._nome
    
    def get_idade(self):
        return self._idade
    
    def set_idade(self, idade):
        if idade > 0:
            self._idade = idade
    
    def __str__(self):
        return f'{self._nome}, {self._idade} anos, {self._especie}'

Subclasses Cao e Gato

class Cao(Animal):
    def __init__(self, nome, idade, raca):
        super().__init__(nome, idade, 'Cao')
        self._raca = raca
    
    def __str__(self):
        return super().__str__() + f', {self._raca}'

class Gato(Animal):
    def __init__(self, nome, idade, pelo):
        super().__init__(nome, idade, 'Gato')
        self._pelo = pelo
    
    def __str__(self):
        return super().__str__() + f', pelo {self._pelo}'

Classe Dono

class Dono:
    def __init__(self, nome, contacto):
        self._nome = nome
        self._contacto = contacto
        self._animais = []
    
    def adicionar_animal(self, animal):
        if animal not in self._animais:
            self._animais.append(animal)
    
    def remover_animal(self, animal):
        if animal in self._animais:
            self._animais.remove(animal)
    
    def get_lista_animais(self):
        return [str(animal) for animal in self._animais]
    
    def __str__(self):
        return f'{self._nome}, Contacto: {self._contacto}'

Classe SistemaGestao

class SistemaGestao:
    def __init__(self):
        self._donos = {}
        self._animais = []
    
    def adicionar_dono(self, nome, contacto):
        if nome not in self._donos:
            self._donos[nome] = Dono(nome, contacto)
    
    def remover_dono(self, nome):
        if nome in self._donos:
            del self._donos[nome]
    
    def adicionar_animal(self, tipo, nome, idade, caracteristica):
        if tipo == "Cao":
            animal = Cao(nome, idade, caracteristica)
        elif tipo == "Gato":
            animal = Gato(nome, idade, caracteristica)
        self._animais.append(animal)
        return animal
    
    def associar_animal_a_dono(self, nome_dono, animal):
        if nome_dono in self._donos:
            self._donos[nome_dono].adicionar_animal(animal)
    
    def mostrar_donos(self):
        return [str(dono) for dono in self._donos.values()]
    
    def mostrar_animais(self):
        return [str(animal) for animal in self._animais]

Exemplo de Utilização

sistema = SistemaGestao()

# Adicionar donos
sistema.adicionar_dono("João", "912345678")
sistema.adicionar_dono("Maria", "987654321")

# Adicionar animais
cao1 = sistema.adicionar_animal("Cao", "Rex", 5, "Labrador")
gato1 = sistema.adicionar_animal("Gato", "Mimi", 3, "Curto")

# Associar animais a donos
sistema.associar_animal_a_dono("João", cao1)
sistema.associar_animal_a_dono("Maria", gato1)

# Mostrar donos e animais
print("Donos:")
for dono in sistema.mostrar_donos():
    print(dono)

print("\nAnimais:")
for animal in sistema.mostrar_animais():
    print(animal)

Resumo

Neste capítulo, desenvolvemos um sistema de gestão de animais utilizando conceitos de Programação Orientada a Objetos em Python. Definimos várias classes e implementámos funcionalidades práticas como adicionar e mostrar animais e donos. Também demonstrámos como encapsular dados e criar herança entre classes.

Quiz

1. O que é encapsulamento e como foi implementado no sistema de gestão de animais?

2. Como se define herança em Python? Justifique com um exemplo do código.

3. Explique a diferença entre métodos de instância e métodos de classe, e dê um exemplo de cada da implementação deste capítulo.

4. Qual é a finalidade da classe SistemaGestao e como ela usa outras classes para gerir o sistema?

5. Que melhoria(s) pode realizar no sistema para aumentar a sua funcionalidade?