From ac17edb915f6a5070941f2858dd492abfe2cf993 Mon Sep 17 00:00:00 2001 From: Vinicius Torres Date: Sun, 16 Nov 2025 12:40:57 -0300 Subject: [PATCH 1/9] Atualizando fork --- respExercicio01.py | 23 ++++++++++++++++++++++ respExercicio02.py | 44 +++++++++++++++++++++++++++++++++++++++++++ tempCodeRunnerFile.py | 1 + 3 files changed, 68 insertions(+) create mode 100644 respExercicio01.py create mode 100644 respExercicio02.py create mode 100644 tempCodeRunnerFile.py diff --git a/respExercicio01.py b/respExercicio01.py new file mode 100644 index 0000000..7923669 --- /dev/null +++ b/respExercicio01.py @@ -0,0 +1,23 @@ +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + + def info_aluno(self): + return f"Nome: {self.nome}, Matrícula: {self.matricula}, Curso: {self.curso}" + +class Disciplina: + def __init__(self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + + def info_displina(self): + return f"Nome {self.nome}, Código: {self.codigo}, Carga Horária: {self.carga_horaria}" + +aluno1 = Aluno("João", 6325225, "ADS") +discplina1 = Disciplina("Cloud", 12112025, 25) + +print(aluno1.info_aluno()) +print(discplina1.info_displina()) \ No newline at end of file diff --git a/respExercicio02.py b/respExercicio02.py new file mode 100644 index 0000000..dc45599 --- /dev/null +++ b/respExercicio02.py @@ -0,0 +1,44 @@ +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.notas = [] + + def info_aluno(self): + return f"Nome: {self.nome}, Matrícula: {self.matricula}, Curso: {self.curso}" + + def adicionar_nota(self, nota): + self.notas.append(nota) + + def calcular_media(self): + if len(self.notas) == 0: + return 0 + + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + if media >= 7: + return "Aprovado!" + else: + return "Reprovado!" + +class Disciplina: + def __init__(self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + + def info_displina(self): + return f"Nome {self.nome}, Código: {self.codigo}, Carga Horária: {self.carga_horaria}" + +aluno = Aluno("João Silva", "2023001", "Engenharia de Software") + +aluno.adicionar_nota(8.5) +aluno.adicionar_nota(7.0) +aluno.adicionar_nota(9.2) + +print(f"Média: {aluno.calcular_media()}") + +aluno.status() \ No newline at end of file diff --git a/tempCodeRunnerFile.py b/tempCodeRunnerFile.py new file mode 100644 index 0000000..b4fa555 --- /dev/null +++ b/tempCodeRunnerFile.py @@ -0,0 +1 @@ +"João" \ No newline at end of file From d175c07238b9300a5e4ad7c9138b4d74c347ca2c Mon Sep 17 00:00:00 2001 From: Vinicius Torres Date: Sun, 16 Nov 2025 13:48:14 -0300 Subject: [PATCH 2/9] =?UTF-8?q?Implementa=20exerc=C3=ADcio=2003=20-=20Enca?= =?UTF-8?q?psulamento=20e=20Propriedades?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- respExercicio03.py | 64 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+) create mode 100644 respExercicio03.py diff --git a/respExercicio03.py b/respExercicio03.py new file mode 100644 index 0000000..8745a2e --- /dev/null +++ b/respExercicio03.py @@ -0,0 +1,64 @@ +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.notas = [] + + def info_aluno(self): + return f"Nome: {self.nome}, Matrícula: {self.matricula}, Curso: {self.curso}" + + def adicionar_nota(self, nota): + self.notas.append(nota) + + def calcular_media(self): + if len(self.notas) == 0: + return 0 + + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + if media >= 7: + return "Aprovado!" + else: + return "Reprovado!" + +class Professor: + def __init__(self, nome, departamento, salarioInicial): + self.nome = nome + self.departamento = departamento + self._salario = salarioInicial + + def getSalario(self): # getter + return self._salario + + def setSalario(self, novoSalario): #setter + if novoSalario > 0: + self._salario = novoSalario + else: + return "Erro! O novo salário não pode ser uma valor negativo." + +class Disciplina: + def __init__(self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + + def info_displina(self): + return f"Nome {self.nome}, Código: {self.codigo}, Carga Horária: {self.carga_horaria}" + +# Exemplo de Uso + +prof = Professor("Dr. Silva", "Computação", 5000.0) + +# Usando o getter para obter o salário atual +print(f"Salário atual: R$ {prof.getSalario()}") + +# Usando o setter para alterar o salário +prof.setSalario(6000.0) # Deve funcionar +print(f"Novo salário: R$ {prof.getSalario()}") + +# Tentando definir um salário inválido +prof.setSalario(-1000.0) # Deve dar erro +print(f"Salário após tentativa inválida: R$ {prof.getSalario()}") \ No newline at end of file From 057f08342125b0357ece096fbe636f8766d3a8d9 Mon Sep 17 00:00:00 2001 From: Vinicius Torres Date: Sun, 16 Nov 2025 14:09:16 -0300 Subject: [PATCH 3/9] =?UTF-8?q?Implementa=20exerc=C3=ADcio=2004=20-=20Hera?= =?UTF-8?q?n=C3=A7a=20Simples=20(Especializa=C3=A7=C3=A3o)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- respExercicio04.py | 82 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 82 insertions(+) create mode 100644 respExercicio04.py diff --git a/respExercicio04.py b/respExercicio04.py new file mode 100644 index 0000000..04abaa0 --- /dev/null +++ b/respExercicio04.py @@ -0,0 +1,82 @@ +class Pessoa: + def __init__(self, nome, cpf, data_nascimento): + self.nome = nome + self.cpf = cpf + self.data_nascimento = data_nascimento + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf} e eu nasci em {self.data_nascimento}." + +class Funcionario(Pessoa): + def __init__(self, nome, cpf, data_nascimento, cargo): + super().__init__(nome, cpf, data_nascimento) + self.cargo = cargo + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf}, eu nasci em {self.data_nascimento} e sou {self.cargo}." + +class Tutor(Pessoa): + def __init__(self, nome, cpf, data_nascimento, area_atuacao): + super().__init__(nome, cpf, data_nascimento) + self.area_atuacao = area_atuacao + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf}, eu nasci em {self.data_nascimento} e atuo na área de {self.area_atuacao}." + +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.notas = [] + + def info_aluno(self): + return f"Nome: {self.nome}, Matrícula: {self.matricula}, Curso: {self.curso}" + + def adicionar_nota(self, nota): + self.notas.append(nota) + + def calcular_media(self): + if len(self.notas) == 0: + return 0 + + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + if media >= 7: + return "Aprovado!" + else: + return "Reprovado!" + +class Professor: + def __init__(self, nome, departamento, salarioInicial): + self.nome = nome + self.departamento = departamento + self._salario = salarioInicial + + def getSalario(self): # getter + return self._salario + + def setSalario(self, novoSalario): #setter + if novoSalario > 0: + self._salario = novoSalario + else: + return "Erro! O novo salário não pode ser uma valor negativo." + +class Disciplina: + def __init__(self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + + def info_displina(self): + return f"Nome {self.nome}, Código: {self.codigo}, Carga Horária: {self.carga_horaria}" + +# Exemplo de Uso + +funcionario = Funcionario("João Silva", "123.456.789-00", "01/01/1990", "Secretário") +tutor = Tutor("Maria Santos", "987.654.321-00", "15/05/1985", "Programação") + +print(funcionario.apresentar()) +print(tutor.apresentar()) \ No newline at end of file From 1865132b0e37c0cd5941f097788bb1dd53579169 Mon Sep 17 00:00:00 2001 From: Vinicius Torres Date: Sun, 16 Nov 2025 14:36:11 -0300 Subject: [PATCH 4/9] =?UTF-8?q?Implementa=20exerc=C3=ADcio=2005=20-=20Hera?= =?UTF-8?q?n=C3=A7a=20e=20o=20Uso=20de=20super()?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- respExercicio05.py | 83 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 83 insertions(+) create mode 100644 respExercicio05.py diff --git a/respExercicio05.py b/respExercicio05.py new file mode 100644 index 0000000..b61f10e --- /dev/null +++ b/respExercicio05.py @@ -0,0 +1,83 @@ +class Pessoa: + def __init__(self, nome, cpf, data_nascimento): + self.nome = nome + self.cpf = cpf + self.data_nascimento = data_nascimento + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf} e eu nasci em {self.data_nascimento}." + +class Funcionario(Pessoa): + def __init__(self, nome, cpf, data_nascimento, cargo, salario): + super().__init__(nome, cpf, data_nascimento) + self.cargo = cargo + self.salario = salario + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf}, eu nasci em {self.data_nascimento} e sou {self.cargo}." + + def exibir_dados(self): + return f"=== Dados do Funcionário ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nCargo: {self.cargo}\nSalário: {self.salario}" + +class Tutor(Pessoa): + def __init__(self, nome, cpf, data_nascimento, area_atuacao): + super().__init__(nome, cpf, data_nascimento) + self.area_atuacao = area_atuacao + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf}, eu nasci em {self.data_nascimento} e atuo na área de {self.area_atuacao}." + +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.notas = [] + + def info_aluno(self): + return f"Nome: {self.nome}, Matrícula: {self.matricula}, Curso: {self.curso}" + + def adicionar_nota(self, nota): + self.notas.append(nota) + + def calcular_media(self): + if len(self.notas) == 0: + return 0 + + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + if media >= 7: + return "Aprovado!" + else: + return "Reprovado!" + +class Professor: + def __init__(self, nome, departamento, salarioInicial): + self.nome = nome + self.departamento = departamento + self._salario = salarioInicial + + def getSalario(self): # getter + return self._salario + + def setSalario(self, novoSalario): #setter + if novoSalario > 0: + self._salario = novoSalario + else: + return "Erro! O novo salário não pode ser uma valor negativo." + +class Disciplina: + def __init__(self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + + def info_displina(self): + return f"Nome {self.nome}, Código: {self.codigo}, Carga Horária: {self.carga_horaria}" + +# Exemplo de Uso + +funcionario = Funcionario("Ana Costa", "111.222.333-44", "20/03/1988", "Coordenadora", 4500.0) +print(funcionario.exibir_dados()) \ No newline at end of file From 56bb67eb72771a832ea5275723634e2cf1afc16b Mon Sep 17 00:00:00 2001 From: Vinicius Torres Date: Tue, 18 Nov 2025 20:14:02 -0300 Subject: [PATCH 5/9] =?UTF-8?q?Implementa=20os=20exerc=C3=ADcios=20do=2007?= =?UTF-8?q?=20ao=2010.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Resposta_10.md | 53 +++++++++++++++ Resposta_10.py | 48 ++++++++++++++ respExercicio06.py | 110 +++++++++++++++++++++++++++++++ respExercicio07.py | 132 +++++++++++++++++++++++++++++++++++++ respExercicio08.py | 159 +++++++++++++++++++++++++++++++++++++++++++++ respExercicio09.py | 48 ++++++++++++++ 6 files changed, 550 insertions(+) create mode 100644 Resposta_10.md create mode 100644 Resposta_10.py create mode 100644 respExercicio06.py create mode 100644 respExercicio07.py create mode 100644 respExercicio08.py create mode 100644 respExercicio09.py diff --git a/Resposta_10.md b/Resposta_10.md new file mode 100644 index 0000000..68566e0 --- /dev/null +++ b/Resposta_10.md @@ -0,0 +1,53 @@ +# Resposta 10 - Relatório dos Erros Encontrados e Soluções + +## Erro 1: Nome da classe `pessoa` +- **Descrição do problema**: O nome da classe `pessoa` não segue a convenção de nomenclatura do Python (PEP 8), que recomenda o uso de PascalCase para nomes de classes. +- **Solução**: Renomeei a classe para `Pessoa`. +- **Conceito POO**: Convenção de nomenclatura. + +--- + +## Erro 2: Atributo `nome` não inicializado corretamente +- **Descrição do problema**: No construtor da classe `pessoa`, o atributo `nome` foi atribuído diretamente ao parâmetro, sem usar `self`. +- **Solução**: Corrigi a inicialização para `self.nome = nome`. +- **Conceito POO**: Inicialização de atributos. + +--- + +## Erro 3: Atributo privado `__cpf` não utilizado +- **Descrição do problema**: O atributo `__cpf` foi declarado, mas não foi utilizado ou acessado em nenhum lugar do código. +- **Solução**: Mantive o atributo como privado, respeitando o encapsulamento, mas ele pode ser acessado futuramente com métodos `getter` e `setter`. +- **Conceito POO**: Encapsulamento. + +--- + +## Erro 4: Método `apresentar` sem o parâmetro `self` +- **Descrição do problema**: O método `apresentar` não possui o parâmetro `self`, o que impede o acesso aos atributos da instância. +- **Solução**: Adicionei o parâmetro `self` ao método. +- **Conceito POO**: Definição de métodos. + +--- + +## Erro 5: Construtor da classe `Estudante` não chama o construtor da superclasse +- **Descrição do problema**: O construtor da classe `Estudante` não chama o construtor da superclasse `Pessoa`, o que resulta na ausência de inicialização dos atributos herdados. +- **Solução**: Adicionei a chamada ao construtor da superclasse com `super().__init__(nome, idade)`. +- **Conceito POO**: Herança e uso de `super()`. + +--- + +## Erro 6: Divisão por zero no método `calcular_media` +- **Descrição do problema**: O método `calcular_media` não trata o caso em que a lista de notas está vazia, o que pode causar uma divisão por zero. +- **Solução**: Adicionei uma verificação para retornar `0` caso a lista de notas esteja vazia. +- **Conceito POO**: Lógica de negócio. + +--- + +## Erro 7: Método `calcular_media` chamado sem adicionar notas +- **Descrição do problema**: No exemplo de uso, o método `calcular_media` é chamado antes de adicionar notas ao estudante, o que resulta em uma lista vazia. +- **Solução**: Adicionei notas ao estudante antes de chamar o método `calcular_media`. +- **Conceito POO**: Lógica de negócio. + +--- + +## Conclusão +Após corrigir os 7 erros, o código agora segue as boas práticas de Programação Orientada a Objetos, respeitando os princípios de encapsulamento, herança, inicialização de atributos e lógica de negócio. \ No newline at end of file diff --git a/Resposta_10.py b/Resposta_10.py new file mode 100644 index 0000000..bf58ebc --- /dev/null +++ b/Resposta_10.py @@ -0,0 +1,48 @@ +class Pessoa: # Corrigido: Nome da classe com letra maiúscula (convenção PEP 8) + def __init__(self, nome, idade): + self.nome = nome # Corrigido: Atributo `self.nome` foi corretamente inicializado + self.idade = idade + self.__cpf = None # Mantido como atributo privado (encapsulamento) + + def apresentar(self): # Corrigido: Adicionado `self` como parâmetro do método + return f"Olá, sou {self.nome}" + + +class Estudante(Pessoa): # Corrigido: Nome da classe com letra maiúscula e herança corrigida + def __init__(self, nome, idade, curso): + super().__init__(nome, idade) # Corrigido: Chamada ao construtor da superclasse + self.curso = curso + self.notas = [] + + def adicionar_nota(self, nota): + if 0 <= nota <= 10: # Mantida a validação de nota + self.notas.append(nota) + + def calcular_media(self): + if len(self.notas) == 0: # Corrigido: Tratamento para evitar divisão por zero + return 0 + return sum(self.notas) / len(self.notas) + + +class Professor(Pessoa): # Corrigido: Nome da classe com letra maiúscula e herança corrigida + def __init__(self, nome, idade, departamento, salario): + super().__init__(nome, idade) # Corrigido: Chamada ao construtor da superclasse + self.departamento = departamento + self.salario = salario + + def apresentar(self): + return f"Olá, sou o professor {self.nome} do departamento {self.departamento}" + + +# Testando o código corrigido +estudante = Estudante("João", 20, "Engenharia") +professor = Professor("Dr. Silva", 45, "Computação", 8000) + +# Adicionando notas ao estudante +estudante.adicionar_nota(8) +estudante.adicionar_nota(9) + +# Exibindo as apresentações e a média do estudante +print(estudante.apresentar()) +print(professor.apresentar()) +print(f"Média do estudante: {estudante.calcular_media()}") \ No newline at end of file diff --git a/respExercicio06.py b/respExercicio06.py new file mode 100644 index 0000000..7bd7bd4 --- /dev/null +++ b/respExercicio06.py @@ -0,0 +1,110 @@ +class Pessoa: + def __init__(self, nome, cpf, data_nascimento): + self.nome = nome + self.cpf = cpf + self.data_nascimento = data_nascimento + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf} e eu nasci em {self.data_nascimento}." + +class Funcionario(Pessoa): + def __init__(self, nome, cpf, data_nascimento, cargo, salario): + super().__init__(nome, cpf, data_nascimento) + self.cargo = cargo + self.salario = salario + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf}, eu nasci em {self.data_nascimento} e sou {self.cargo}." + + def exibir_dados(self): + return f"=== Dados do Funcionário ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nCargo: {self.cargo}\nSalário: {self.salario}" + +class Tutor(Pessoa): + def __init__(self, nome, cpf, data_nascimento, area_atuacao): + super().__init__(nome, cpf, data_nascimento) + self.area_atuacao = area_atuacao + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf}, eu nasci em {self.data_nascimento} e atuo na área de {self.area_atuacao}." + +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.notas = [] + + def info_aluno(self): + return f"Nome: {self.nome}, Matrícula: {self.matricula}, Curso: {self.curso}" + + def adicionar_nota(self, nota): + self.notas.append(nota) + + def calcular_media(self): + if len(self.notas) == 0: + return 0 + + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + if media >= 7: + return "Aprovado!" + else: + return "Reprovado!" + +class Professor: + def __init__(self, nome, departamento, salarioInicial): + self.nome = nome + self.departamento = departamento + self._salario = salarioInicial + + def getSalario(self): # getter + return self._salario + + def setSalario(self, novoSalario): #setter + if novoSalario > 0: + self._salario = novoSalario + else: + return "Erro! O novo salário não pode ser uma valor negativo." + +class Disciplina: + def __init__(self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + + def info_displina(self): + return f"Nome {self.nome}, Código: {self.codigo}, Carga Horária: {self.carga_horaria}" + +class Curso: + def __init__(self, nome, codigo): + self.nome = nome + self.codigo = codigo + self.disciplinas = [] + + def adicionar_disciplina(self, disciplina): + self.disciplinas.append(disciplina) + + def listar_disciplinas(self): + print(f"=== Disciplinas do Curso: {self.nome} ===") + for disciplina in self.disciplinas: + print(f"- {disciplina.nome} ({disciplina.codigo})") + + def carga_horaria_total(self): + return sum(disciplina.carga_horaria for disciplina in self.disciplinas) + +# Exemplo de Uso +curso = Curso("Engenharia de Software", "ES001") # objeto da classe Curso +disciplina1 = Disciplina("Programação Orientada a Objetos", "POO001", 60) # objeto da classe Disciplina +disciplina2 = Disciplina("Banco de Dados", "BD001", 80) # objeto da classe Disciplina + +# Adicionando disciplinas ao curso +curso.adicionar_disciplina(disciplina1) # objeto da classe Curso chamando um método da classe disciplina +curso.adicionar_disciplina(disciplina2) + +# Listando disciplinas +curso.listar_disciplinas() + +# Exibindo a carga horária total +print(f"Carga horária total: {curso.carga_horaria_total()}h") \ No newline at end of file diff --git a/respExercicio07.py b/respExercicio07.py new file mode 100644 index 0000000..bc04f88 --- /dev/null +++ b/respExercicio07.py @@ -0,0 +1,132 @@ +class Pessoa: + def __init__(self, nome, cpf, data_nascimento): + self.nome = nome + self.cpf = cpf + self.data_nascimento = data_nascimento + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf} e eu nasci em {self.data_nascimento}." + +class Funcionario(Pessoa): + def __init__(self, nome, cpf, data_nascimento, cargo, salario): + super().__init__(nome, cpf, data_nascimento) + self.cargo = cargo + self.salario = salario + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf}, eu nasci em {self.data_nascimento} e sou {self.cargo}." + + def exibir_dados(self): + return f"=== Dados do Funcionário ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nCargo: {self.cargo}\nSalário: {self.salario}" + +class Tutor(Pessoa): + def __init__(self, nome, cpf, data_nascimento, area_atuacao): + super().__init__(nome, cpf, data_nascimento) + self.area_atuacao = area_atuacao + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf}, eu nasci em {self.data_nascimento} e atuo na área de {self.area_atuacao}." + +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.disciplinas_inscritas = [] # Lista de disciplinas em que o aluno está inscrito + + def info_aluno(self): + return f"Nome: {self.nome}, Matrícula: {self.matricula}, Curso: {self.curso}" + + def listar_disciplinas(self): + print(f"=== Disciplinas de {self.nome} ===") + for disciplina in self.disciplinas_inscritas: + print(f"- {disciplina.nome} ({disciplina.codigo})") + + def adicionar_nota(self, nota): + self.notas.append(nota) + + def calcular_media(self): + if len(self.notas) == 0: + return 0 + + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + if media >= 7: + return "Aprovado!" + else: + return "Reprovado!" + +class Professor: + def __init__(self, nome, departamento, salarioInicial): + self.nome = nome + self.departamento = departamento + self._salario = salarioInicial + + def getSalario(self): # getter + return self._salario + + def setSalario(self, novoSalario): #setter + if novoSalario > 0: + self._salario = novoSalario + else: + return "Erro! O novo salário não pode ser uma valor negativo." + +class Disciplina: + def __init__(self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + self.alunos_matriculados = [] # Lista de alunos matriculados na disciplina + + def info_displina(self): + return f"Nome: {self.nome}, Código: {self.codigo}, Carga Horária: {self.carga_horaria}" + + def listar_alunos(self): + print(f"=== Alunos matriculados em {self.nome} ===") + for aluno in self.alunos_matriculados: + print(f"- {aluno.nome} ({aluno.matricula})") + +class Curso: + def __init__(self, nome, codigo): + self.nome = nome + self.codigo = codigo + self.disciplinas = [] + + def adicionar_disciplina(self, disciplina): + self.disciplinas.append(disciplina) + + def listar_disciplinas(self): + print(f"=== Disciplinas do Curso: {self.nome} ===") + for disciplina in self.disciplinas: + print(f"- {disciplina.nome} ({disciplina.codigo})") + + def carga_horaria_total(self): + return sum(disciplina.carga_horaria for disciplina in self.disciplinas) + +class Secretaria: + @staticmethod + def inscrever_aluno(aluno, disciplina): + """Inscreve um aluno em uma disciplina e atualiza as listas de ambos.""" + if disciplina not in aluno.disciplinas_inscritas: + aluno.disciplinas_inscritas.append(disciplina) + if aluno not in disciplina.alunos_matriculados: + disciplina.alunos_matriculados.append(aluno) + +# Exemplo de Uso +aluno1 = Aluno("João Silva", "2023001", "Engenharia de Software") +aluno2 = Aluno("Maria Santos", "2023002", "Ciência da Computação") +disciplina1 = Disciplina("POO", "POO001", 60) +disciplina2 = Disciplina("Banco de Dados", "BD001", 80) + +# Inscrevendo alunos nas disciplinas +Secretaria.inscrever_aluno(aluno1, disciplina1) +Secretaria.inscrever_aluno(aluno1, disciplina2) +Secretaria.inscrever_aluno(aluno2, disciplina1) + +# Listando disciplinas de um aluno +aluno1.listar_disciplinas() + +# Listando alunos de uma disciplina +disciplina1.listar_alunos() \ No newline at end of file diff --git a/respExercicio08.py b/respExercicio08.py new file mode 100644 index 0000000..c14ffed --- /dev/null +++ b/respExercicio08.py @@ -0,0 +1,159 @@ +class Pessoa: + def __init__(self, nome, cpf, data_nascimento): + self.nome = nome + self.cpf = cpf + self.data_nascimento = data_nascimento + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf} e eu nasci em {self.data_nascimento}." + +class Funcionario(Pessoa): + def __init__(self, nome, cpf, data_nascimento, cargo, salario): + super().__init__(nome, cpf, data_nascimento) + self.cargo = cargo + self.salario = salario + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf}, eu nasci em {self.data_nascimento} e sou {self.cargo}." + + def exibir_dados(self): + return f"=== Dados do Funcionário ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nCargo: {self.cargo}\nSalário: {self.salario}" + +class Tutor(Pessoa): + def __init__(self, nome, cpf, data_nascimento, area_atuacao): + super().__init__(nome, cpf, data_nascimento) + self.area_atuacao = area_atuacao + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf}, eu nasci em {self.data_nascimento} e atuo na área de {self.area_atuacao}." + +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.disciplinas_inscritas = [] # Lista de disciplinas em que o aluno está inscrito + + def info_aluno(self): + return f"Nome: {self.nome}, Matrícula: {self.matricula}, Curso: {self.curso}" + + def listar_disciplinas(self): + print(f"=== Disciplinas de {self.nome} ===") + for disciplina in self.disciplinas_inscritas: + print(f"- {disciplina.nome} ({disciplina.codigo})") + + def adicionar_nota(self, nota): + self.notas.append(nota) + + def calcular_media(self): + if len(self.notas) == 0: + return 0 + + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + if media >= 7: + return "Aprovado!" + else: + return "Reprovado!" + +class Professor: + def __init__(self, nome, departamento, salarioInicial): + self.nome = nome + self.departamento = departamento + self._salario = salarioInicial + + def getSalario(self): # getter + return self._salario + + def setSalario(self, novoSalario): #setter + if novoSalario > 0: + self._salario = novoSalario + else: + return "Erro! O novo salário não pode ser uma valor negativo." + +class Disciplina: + def __init__(self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + self.alunos_matriculados = [] # Lista de alunos matriculados na disciplina + + def info_displina(self): + return f"Nome: {self.nome}, Código: {self.codigo}, Carga Horária: {self.carga_horaria}" + + def listar_alunos(self): + print(f"=== Alunos matriculados em {self.nome} ===") + for aluno in self.alunos_matriculados: + print(f"- {aluno.nome} ({aluno.matricula})") + +class Curso: + def __init__(self, nome, codigo): + self.nome = nome + self.codigo = codigo + self.disciplinas = [] + + def adicionar_disciplina(self, disciplina): + self.disciplinas.append(disciplina) + + def listar_disciplinas(self): + print(f"=== Disciplinas do Curso: {self.nome} ===") + for disciplina in self.disciplinas: + print(f"- {disciplina.nome} ({disciplina.codigo})") + + def carga_horaria_total(self): + return sum(disciplina.carga_horaria for disciplina in self.disciplinas) + +class Secretaria: + @staticmethod + def inscrever_aluno(aluno, disciplina): + """Inscreve um aluno em uma disciplina e atualiza as listas de ambos.""" + if disciplina not in aluno.disciplinas_inscritas: + aluno.disciplinas_inscritas.append(disciplina) + if aluno not in disciplina.alunos_matriculados: + disciplina.alunos_matriculados.append(aluno) + +class Departamento: + def __init__(self, nome, sigla): + self.nome = nome + self.sigla = sigla + self.professores = [] # Lista de professores associados ao departamento + + @classmethod + def criar_departamento_exatas(cls, nome): + """Cria um departamento com a sigla 'EXA'.""" + return cls(nome, "EXA") + + @classmethod + def criar_departamento_humanas(cls, nome): + """Cria um departamento com a sigla 'HUM'.""" + return cls(nome, "HUM") + + def adicionar_professor(self, professor): + """Adiciona um professor à lista de professores do departamento.""" + self.professores.append(professor) + + def listar_professores(self): + """Lista os professores associados ao departamento.""" + print(f"=== Professores do Departamento: {self.nome} ({self.sigla}) ===") + for professor in self.professores: + print(f"- {professor.nome}") + +# Exemplo de Uso +dept_exatas = Departamento.criar_departamento_exatas("Matemática e Computação") +dept_humanas = Departamento.criar_departamento_humanas("Letras e Filosofia") + +print(f"Departamento: {dept_exatas.nome} - Sigla: {dept_exatas.sigla}") +print(f"Departamento: {dept_humanas.nome} - Sigla: {dept_humanas.sigla}") + +# Criando professores e adicionando aos departamentos +prof1 = Professor("Dr. Silva", dept_exatas, 5000.0) # Corrigido +prof2 = Professor("Dr. Costa", dept_humanas, 4500.0) # Corrigido + +dept_exatas.adicionar_professor(prof1) +dept_humanas.adicionar_professor(prof2) + +# Listando professores de cada departamento +dept_exatas.listar_professores() +dept_humanas.listar_professores() \ No newline at end of file diff --git a/respExercicio09.py b/respExercicio09.py new file mode 100644 index 0000000..f7e1d50 --- /dev/null +++ b/respExercicio09.py @@ -0,0 +1,48 @@ +class Pessoa: + def __init__(self, nome): + self.nome = nome + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}." + + +class Aluno(Pessoa): + def __init__(self, nome, matricula, curso): + super().__init__(nome) + self.matricula = matricula + self.curso = curso + + def apresentar(self): + return f"Olá, sou o aluno {self.nome} e estudo no curso {self.curso}." + + +class Professor(Pessoa): + def __init__(self, nome, departamento, salario): + super().__init__(nome) + self.departamento = departamento + self.salario = salario + + def apresentar(self): + return f"Olá, sou o professor {self.nome} e leciono no departamento {self.departamento}." + + +class Funcionario(Pessoa): + def __init__(self, nome, cpf, data_nascimento, cargo, salario): + super().__init__(nome) + self.cpf = cpf + self.data_nascimento = data_nascimento + self.cargo = cargo + self.salario = salario + + def apresentar(self): + return f"Olá, sou o funcionário {self.nome} e meu cargo é {self.cargo}." + +# Exemplo de Uso +pessoas = [ + Aluno("João Silva", "2023001", "Engenharia de Software"), + Professor("Dr. Maria", "Computação", 8000.0), + Funcionario("Carlos Santos", "123.456.789-00", "01/01/1980", "Secretário", 3000.0), +] + +for pessoa in pessoas: + print(pessoa.apresentar()) \ No newline at end of file From 14e811514919efce75d0cf3c84ef2664f1c29206 Mon Sep 17 00:00:00 2001 From: Vinicius Torres Date: Wed, 19 Nov 2025 19:24:36 -0300 Subject: [PATCH 6/9] =?UTF-8?q?Implementa=20exerc=C3=ADcio=2011=20-=20Prin?= =?UTF-8?q?c=C3=ADpio=20da=20Responsabilidade=20=C3=9Anica=20(SRP)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- respExercicio11.py | 45 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 respExercicio11.py diff --git a/respExercicio11.py b/respExercicio11.py new file mode 100644 index 0000000..e255985 --- /dev/null +++ b/respExercicio11.py @@ -0,0 +1,45 @@ +# Classe Funcionario: Responsável apenas por armazenar os dados do funcionário +class Funcionario: + def __init__(self, nome, salario, cargo): + self.nome = nome + self.salario = salario + self.cargo = cargo + +# Classe CalculadoraSalario: Responsável pelos cálculos relacionados ao salário +class CalculadoraSalario: + @staticmethod + def calcular_salario_liquido(funcionario, descontos): + return funcionario.salario - descontos + +# Classe GeradorRelatorio: Responsável pela geração de relatórios +class GeradorRelatorio: + @staticmethod + def gerar_relatorio(funcionario): + return f"Relatório: {funcionario.nome} - {funcionario.cargo} - R$ {funcionario.salario:.2f}" + +# Classe RepositorioFuncionario: Responsável pela persistência de dados +class RepositorioFuncionario: + @staticmethod + def salvar(funcionario): + print(f"Salvando {funcionario.nome} no banco de dados...") + +# Exemplo de Uso +if __name__ == "__main__": + # Criando um funcionário + funcionario = Funcionario("Ana Silva", 5000.0, "Desenvolvedora") + + # Instanciando as classes responsáveis por cada funcionalidade + calculadora = CalculadoraSalario() + gerador = GeradorRelatorio() + repositorio = RepositorioFuncionario() + + # Calculando o salário líquido + salario_liquido = calculadora.calcular_salario_liquido(funcionario, 500.0) + print(f"Salário líquido: R$ {salario_liquido:.2f}") + + # Gerando o relatório + relatorio = gerador.gerar_relatorio(funcionario) + print(relatorio) + + # Salvando o funcionário no banco de dados + repositorio.salvar(funcionario) \ No newline at end of file From 9242c462b4e7b9b88c7a92247fe9ea24a9403c8f Mon Sep 17 00:00:00 2001 From: Vinicius Torres Date: Wed, 19 Nov 2025 19:37:47 -0300 Subject: [PATCH 7/9] =?UTF-8?q?Implementa=20exerc=C3=ADcio=2012=20-=20Prin?= =?UTF-8?q?c=C3=ADpio=20Aberto/Fechado=20(OCP)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- respExercicio12.py | 65 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) create mode 100644 respExercicio12.py diff --git a/respExercicio12.py b/respExercicio12.py new file mode 100644 index 0000000..0bf8b58 --- /dev/null +++ b/respExercicio12.py @@ -0,0 +1,65 @@ +from abc import ABC, abstractmethod + +# Classe Funcionario: Responsável apenas por armazenar os dados do funcionário +class Funcionario: + def __init__(self, nome, salario, cargo): + self.nome = nome + self.salario = salario + self.cargo = cargo + +# Classe CalculadoraSalario: Responsável pelos cálculos relacionados ao salário +class CalculadoraSalario: + @staticmethod + def calcular_salario_liquido(funcionario, descontos): + return funcionario.salario - descontos + +# Classe GeradorRelatorio: Responsável pela geração de relatórios +class GeradorRelatorio: + @staticmethod + def gerar_relatorio(funcionario): + return f"Relatório: {funcionario.nome} - {funcionario.cargo} - R$ {funcionario.salario:.2f}" + +# Classe RepositorioFuncionario: Responsável pela persistência de dados +class RepositorioFuncionario: + @staticmethod + def salvar(funcionario): + print(f"Salvando {funcionario.nome} no banco de dados...") + +# Classe abstrata para cálculo de descontos +class CalculadorDesconto(ABC): + @abstractmethod + def calcular(self, valor): + """Método abstrato para calcular o desconto""" + pass + +# Implementação de diferentes tipos de desconto +class DescontoEstudante(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.9 # 10% de desconto + +class DescontoFuncionario(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.85 # 15% de desconto + +# Classe para processar pagamentos com diferentes descontos +class ProcessadorPagamento: + def processar(self, valor, calculador_desconto): + return calculador_desconto.calcular(valor) + +# Exemplo de Uso +if __name__ == "__main__": + # Uso do sistema + pagamento = ProcessadorPagamento() + valor_original = 1000.0 + + # Diferentes tipos de desconto + desconto_estudante = DescontoEstudante() + desconto_funcionario = DescontoFuncionario() + + # Processando pagamentos com diferentes descontos + valor_final1 = pagamento.processar(valor_original, desconto_estudante) + valor_final2 = pagamento.processar(valor_original, desconto_funcionario) + + # Exibindo os resultados + print(f"Estudante: R$ {valor_final1:.2f}") + print(f"Funcionário: R$ {valor_final2:.2f}") \ No newline at end of file From 49791369cefd45c06caf4999f3c5d25e770e8ca6 Mon Sep 17 00:00:00 2001 From: Vinicius Torres Date: Wed, 19 Nov 2025 19:44:38 -0300 Subject: [PATCH 8/9] =?UTF-8?q?Implementa=20exerc=C3=ADcio=2013=20-=20Prin?= =?UTF-8?q?c=C3=ADpio=20da=20Substitui=C3=A7=C3=A3o=20de=20Liskov=20(LSP)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- respExercicio13.py | 117 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 117 insertions(+) create mode 100644 respExercicio13.py diff --git a/respExercicio13.py b/respExercicio13.py new file mode 100644 index 0000000..43b5905 --- /dev/null +++ b/respExercicio13.py @@ -0,0 +1,117 @@ +from abc import ABC, abstractmethod + +# Classe Funcionario: Responsável apenas por armazenar os dados do funcionário +class Funcionario: + def __init__(self, nome, salario, cargo): + self.nome = nome + self.salario = salario + self.cargo = cargo + +# Classe CalculadoraSalario: Responsável pelos cálculos relacionados ao salário +class CalculadoraSalario: + @staticmethod + def calcular_salario_liquido(funcionario, descontos): + return funcionario.salario - descontos + +# Classe GeradorRelatorio: Responsável pela geração de relatórios +class GeradorRelatorio: + @staticmethod + def gerar_relatorio(funcionario): + return f"Relatório: {funcionario.nome} - {funcionario.cargo} - R$ {funcionario.salario:.2f}" + +# Classe RepositorioFuncionario: Responsável pela persistência de dados +class RepositorioFuncionario: + @staticmethod + def salvar(funcionario): + print(f"Salvando {funcionario.nome} no banco de dados...") + +# Classe abstrata para cálculo de descontos +class CalculadorDesconto(ABC): + @abstractmethod + def calcular(self, valor): + """Método abstrato para calcular o desconto""" + pass + +# Implementação de diferentes tipos de desconto +class DescontoEstudante(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.9 # 10% de desconto + +class DescontoFuncionario(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.85 # 15% de desconto + +# Classe para processar pagamentos com diferentes descontos +class ProcessadorPagamento: + def processar(self, valor, calculador_desconto): + return calculador_desconto.calcular(valor) + +# Classe base Veiculo +class Veiculo(ABC): + def __init__(self, velocidade_maxima): + self.velocidade_atual = 0 + self.velocidade_maxima = velocidade_maxima + + @abstractmethod + def acelerar(self): + """Aumenta a velocidade do veículo""" + pass + + @abstractmethod + def frear(self): + """Diminui a velocidade do veículo""" + pass + + def get_velocidade(self): + """Retorna a velocidade atual""" + return self.velocidade_atual + +# Classe Carro +class Carro(Veiculo): + def __init__(self): + super().__init__(180) # Velocidade máxima de 180 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 20, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 20, 0) + +# Classe Bicicleta +class Bicicleta(Veiculo): + def __init__(self): + super().__init__(50) # Velocidade máxima de 50 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 10, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 10, 0) + +# Classe Aviao +class Aviao(Veiculo): + def __init__(self): + super().__init__(900) # Velocidade máxima de 900 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 100, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 100, 0) + +# Função para testar veículos +def testar_veiculo(veiculo): + print(f"Testando {type(veiculo).__name__}") + veiculo.acelerar() + veiculo.acelerar() + print(f"Velocidade: {veiculo.get_velocidade()} km/h") + veiculo.frear() + print(f"Velocidade após frear: {veiculo.get_velocidade()} km/h") + +# Todos os veículos devem funcionar da mesma forma +if __name__ == "__main__": + carro = Carro() + bicicleta = Bicicleta() + + testar_veiculo(carro) + testar_veiculo(bicicleta) \ No newline at end of file From e80a50c4bbeaa308a28894864124bb0082d433a0 Mon Sep 17 00:00:00 2001 From: Vinicius Torres Date: Wed, 19 Nov 2025 19:50:19 -0300 Subject: [PATCH 9/9] =?UTF-8?q?Implementa=20exerc=C3=ADcio=2014=20-=20Prin?= =?UTF-8?q?c=C3=ADpio=20da=20Segrega=C3=A7=C3=A3o=20de=20Interface=20(ISP)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- respExercicio14.py | 180 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 180 insertions(+) create mode 100644 respExercicio14.py diff --git a/respExercicio14.py b/respExercicio14.py new file mode 100644 index 0000000..12bbead --- /dev/null +++ b/respExercicio14.py @@ -0,0 +1,180 @@ +from abc import ABC, abstractmethod + +# Classe Funcionario: Responsável apenas por armazenar os dados do funcionário +class Funcionario: + def __init__(self, nome, salario, cargo): + self.nome = nome + self.salario = salario + self.cargo = cargo + +# Classe CalculadoraSalario: Responsável pelos cálculos relacionados ao salário +class CalculadoraSalario: + @staticmethod + def calcular_salario_liquido(funcionario, descontos): + return funcionario.salario - descontos + +# Classe GeradorRelatorio: Responsável pela geração de relatórios +class GeradorRelatorio: + @staticmethod + def gerar_relatorio(funcionario): + return f"Relatório: {funcionario.nome} - {funcionario.cargo} - R$ {funcionario.salario:.2f}" + +# Classe RepositorioFuncionario: Responsável pela persistência de dados +class RepositorioFuncionario: + @staticmethod + def salvar(funcionario): + print(f"Salvando {funcionario.nome} no banco de dados...") + +# Classe abstrata para cálculo de descontos +class CalculadorDesconto(ABC): + @abstractmethod + def calcular(self, valor): + """Método abstrato para calcular o desconto""" + pass + +# Implementação de diferentes tipos de desconto +class DescontoEstudante(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.9 # 10% de desconto + +class DescontoFuncionario(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.85 # 15% de desconto + +# Classe para processar pagamentos com diferentes descontos +class ProcessadorPagamento: + def processar(self, valor, calculador_desconto): + return calculador_desconto.calcular(valor) + +# Classe base Veiculo +class Veiculo(ABC): + def __init__(self, velocidade_maxima): + self.velocidade_atual = 0 + self.velocidade_maxima = velocidade_maxima + + @abstractmethod + def acelerar(self): + """Aumenta a velocidade do veículo""" + pass + + @abstractmethod + def frear(self): + """Diminui a velocidade do veículo""" + pass + + def get_velocidade(self): + """Retorna a velocidade atual""" + return self.velocidade_atual + +# Classe Carro +class Carro(Veiculo): + def __init__(self): + super().__init__(180) # Velocidade máxima de 180 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 20, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 20, 0) + +# Classe Bicicleta +class Bicicleta(Veiculo): + def __init__(self): + super().__init__(50) # Velocidade máxima de 50 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 10, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 10, 0) + +# Classe Aviao +class Aviao(Veiculo): + def __init__(self): + super().__init__(900) # Velocidade máxima de 900 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 100, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 100, 0) + +# Interfaces específicas +class Trabalhavel(ABC): + @abstractmethod + def trabalhar(self): + pass + +class Alimentavel(ABC): + @abstractmethod + def comer(self): + pass + +class Descansavel(ABC): + @abstractmethod + def dormir(self): + pass + +class Programavel(ABC): + @abstractmethod + def programar(self): + pass + +# Classes concretas +class Desenvolvedor(Trabalhavel, Alimentavel, Descansavel, Programavel): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f"{self.nome} está trabalhando.") + + def comer(self): + print(f"{self.nome} está comendo.") + + def dormir(self): + print(f"{self.nome} está dormindo.") + + def programar(self): + print(f"{self.nome} está programando.") + +class Gerente(Trabalhavel, Alimentavel, Descansavel): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f"{self.nome} está trabalhando.") + + def comer(self): + print(f"{self.nome} está comendo.") + + def dormir(self): + print(f"{self.nome} está dormindo.") + +class Robo(Trabalhavel, Programavel): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f"{self.nome} está trabalhando.") + + def programar(self): + print(f"{self.nome} está programando.") + +# Exemplo de Uso +if __name__ == "__main__": + desenvolvedor = Desenvolvedor("Ana") + gerente = Gerente("Carlos") + robo = Robo("R2D2") + + # Desenvolvedor faz tudo + desenvolvedor.trabalhar() + desenvolvedor.comer() + desenvolvedor.programar() + + # Gerente não programa + gerente.trabalhar() + gerente.comer() + + # Robô não come nem dorme + robo.trabalhar() + robo.programar() \ No newline at end of file