From 2867ea092011d53351af826a9877a0aae0ffa0d2 Mon Sep 17 00:00:00 2001 From: Gabriel Reis Date: Wed, 12 Nov 2025 19:13:26 -0300 Subject: [PATCH 1/7] Exercicio 01 Resolvido --- README.md | 24 +++++++++++++++++++++++- exercicio_01.md | 8 ++++++-- respExercicio01.py | 18 ++++++++++++++++++ respExercicio02.py | 0 respExercicio03.py | 0 respExercicio04.py | 0 respExercicio05.py | 0 7 files changed, 47 insertions(+), 3 deletions(-) create mode 100644 respExercicio01.py create mode 100644 respExercicio02.py create mode 100644 respExercicio03.py create mode 100644 respExercicio04.py create mode 100644 respExercicio05.py diff --git a/README.md b/README.md index 1646acf..0771180 100644 --- a/README.md +++ b/README.md @@ -11,16 +11,19 @@ Proporcionar aos estudantes uma experiência prática e progressiva dos conceito ### Fundamentos de POO #### Classes e Objetos + - **Classe**: Um modelo ou template que define a estrutura e comportamento de objetos. É como um "molde" que especifica quais atributos (dados) e métodos (funções) os objetos terão. - **Objeto**: Uma instância específica de uma classe. É a materialização concreta do modelo definido pela classe. - **Instanciação**: O processo de criar um objeto a partir de uma classe usando o operador de chamada `()`. #### Construtores + - **Método `__init__()`**: Método especial chamado automaticamente quando um objeto é criado. Responsável por inicializar os atributos do objeto. - **Parâmetros do Construtor**: Valores passados durante a criação do objeto para configurar seu estado inicial. - **Self**: Referência ao próprio objeto, usado para acessar atributos e métodos da instância. #### Atributos e Métodos + - **Atributos de Instância**: Variáveis que pertencem a cada objeto específico, definidas com `self.atributo`. - **Atributos de Classe**: Variáveis compartilhadas por todas as instâncias da classe. - **Métodos de Instância**: Funções que operam sobre dados específicos de cada objeto. @@ -30,17 +33,21 @@ Proporcionar aos estudantes uma experiência prática e progressiva dos conceito ### Encapsulamento #### Princípio do Encapsulamento + O encapsulamento é um dos pilares fundamentais da POO que consiste em: + - **Ocultar detalhes internos**: Proteger dados e implementação interna da classe - **Controlar acesso**: Definir como os dados podem ser acessados e modificados - **Manter integridade**: Garantir que o objeto sempre esteja em um estado válido #### Níveis de Visibilidade em Python + - **Público**: Atributos e métodos acessíveis de qualquer lugar (`atributo`) - **Protegido**: Convenção para indicar uso interno, prefixo `_` (`_atributo`) - **Privado**: Dificultam acesso externo, prefixo `__` (`__atributo`) #### Properties e Getters/Setters + - **@property**: Decorator que permite acessar métodos como se fossem atributos - **Getter**: Método para obter o valor de um atributo privado - **Setter**: Método para definir o valor de um atributo com validação @@ -49,11 +56,13 @@ O encapsulamento é um dos pilares fundamentais da POO que consiste em: ### Herança #### Conceitos Fundamentais + - **Classe Base (Pai/Superclasse)**: Classe que define características comuns - **Classe Derivada (Filha/Subclasse)**: Classe que herda e especializa a classe base - **Relação "é um"**: A herança representa uma relação hierárquica onde a subclasse "é um" tipo da superclasse #### Mecanismos de Herança + - **Herança Simples**: Uma classe herda de apenas uma classe pai - **Herança Múltipla**: Uma classe herda de múltiplas classes pai (suportada em Python) - **Método super()**: Função que permite chamar métodos da classe pai @@ -63,11 +72,13 @@ O encapsulamento é um dos pilares fundamentais da POO que consiste em: ### Polimorfismo #### Definição e Tipos + - **Polimorfismo**: Capacidade de objetos de diferentes classes responderem à mesma interface de forma específica - **Polimorfismo de Sobrescrita**: Mesmo método implementado diferentemente em classes relacionadas por herança - **Polimorfismo de Interface**: Objetos não relacionados que implementam os mesmos métodos #### Benefícios do Polimorfismo + - **Flexibilidade**: Código que funciona com diferentes tipos de objetos - **Extensibilidade**: Facilita adição de novos tipos sem modificar código existente - **Manutenibilidade**: Reduz acoplamento entre componentes do sistema @@ -75,16 +86,19 @@ O encapsulamento é um dos pilares fundamentais da POO que consiste em: ### Relacionamentos entre Objetos #### Composição + - **Definição**: Relacionamento "tem um" onde um objeto contém outros objetos como partes integrantes - **Ciclo de Vida**: Os objetos componentes dependem do objeto principal - **Exemplo**: Um Carro "tem um" Motor - se o carro é destruído, o motor também é #### Agregação + - **Definição**: Relacionamento "usa um" onde objetos existem independentemente mas se referenciam - **Ciclo de Vida**: Os objetos podem existir separadamente - **Exemplo**: Um Professor "leciona para" Alunos - professor e alunos existem independentemente #### Relacionamentos N:N (Muitos para Muitos) + - **Definição**: Múltiplos objetos de um tipo se relacionam com múltiplos objetos de outro tipo - **Implementação**: Geralmente usando listas ou conjuntos para armazenar referências - **Exemplo**: Alunos podem estar matriculados em várias Disciplinas, e cada Disciplina pode ter vários Alunos @@ -92,12 +106,14 @@ O encapsulamento é um dos pilares fundamentais da POO que consiste em: ### Recursos Avançados #### Métodos de Classe (@classmethod) + - **Propósito**: Métodos que operam sobre a classe, não sobre instâncias específicas - **Primeiro Parâmetro**: `cls` (referência à classe) - **Uso Comum**: Factory methods (métodos fábrica) para criar objetos de formas específicas - **Acesso**: Podem ser chamados tanto pela classe quanto por instâncias #### Métodos Estáticos (@staticmethod) + - **Propósito**: Funções relacionadas à classe mas que não precisam acessar dados da classe ou instância - **Parâmetros**: Não recebem `self` nem `cls` automaticamente - **Uso Comum**: Funções utilitárias relacionadas ao domínio da classe @@ -147,12 +163,14 @@ Todos os exercícios são baseados em entidades e situações de uma **escola de Antes de submeter sua solução, você pode executar os testes localmente para verificar se sua implementação está correta: #### Pré-requisitos + ```bash # Instale as dependências pip install -r requirements.txt ``` #### Executando um teste específico + ```bash # Para testar apenas o exercício 1 python -m pytest tests/test_exercicio01.py -v @@ -162,17 +180,20 @@ python -m pytest tests/test_exercicio02.py -v ``` #### Executando todos os testes + ```bash # Executa todos os testes do projeto python -m pytest tests/ -v ``` #### Interpretando a saída dos testes + - **PASSED**: Teste passou - sua implementação está correta - **FAILED**: Teste falhou - verifique a mensagem de erro - **ERROR**: Erro de importação - verifique o nome do arquivo #### Exemplo de saída de teste bem-sucedido + ``` tests/test_exercicio01.py::test_aluno_creation PASSED tests/test_exercicio01.py::test_disciplina_creation PASSED @@ -180,6 +201,7 @@ tests/test_exercicio01.py::test_aluno_attributes PASSED ``` #### Exemplo de saída com erro + ``` tests/test_exercicio01.py::test_aluno_creation FAILED E AttributeError: 'Aluno' object has no attribute 'nome' @@ -311,4 +333,4 @@ Para dúvidas sobre os exercícios: --- -**Bons estudos!** \ No newline at end of file +**Bons estudos!** diff --git a/exercicio_01.md b/exercicio_01.md index af1b0fe..7194328 100644 --- a/exercicio_01.md +++ b/exercicio_01.md @@ -1,12 +1,14 @@ # Exercício 01 - Modelagem Básica de Entidades ## Objetivo + Praticar a criação de classes simples e inicialização de objetos. ## Descrição do Exercício + Crie duas classes: **Aluno** e **Disciplina**. -### Requisitos: +### Requisitos 1. **Classe Aluno** deve ter atributos para: - nome @@ -23,12 +25,14 @@ Crie duas classes: **Aluno** e **Disciplina**. 4. Instancie dois objetos de cada classe e imprima seus atributos. ## Entrega + Crie um arquivo chamado `respExercicio01.py` com a implementação das classes e a criação dos objetos solicitados. ## Exemplo de Saída Esperada + ``` Aluno: João Silva, Matrícula: 2023001, Curso: Engenharia de Software Aluno: Maria Santos, Matrícula: 2023002, Curso: Ciência da Computação Disciplina: Programação Orientada a Objetos, Código: POO001, Carga Horária: 60h Disciplina: Banco de Dados, Código: BD001, Carga Horária: 80h -``` \ No newline at end of file +``` diff --git a/respExercicio01.py b/respExercicio01.py new file mode 100644 index 0000000..d1bb58e --- /dev/null +++ b/respExercicio01.py @@ -0,0 +1,18 @@ +class Aluno: + def __init__ (self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + +class Disciplina: + def __init__ (self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + +aluno = Aluno("João Silva", "2023001", "Engenharia de Software") +disciplina = Disciplina("Programação Orientada a Objetos", "CS101", 60) + +print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}, Curso: {aluno.curso}") + +print(f"Disciplina: {disciplina.nome}, Código: {disciplina.codigo}, Carga Horária: {disciplina.carga_horaria} horas") \ No newline at end of file diff --git a/respExercicio02.py b/respExercicio02.py new file mode 100644 index 0000000..e69de29 diff --git a/respExercicio03.py b/respExercicio03.py new file mode 100644 index 0000000..e69de29 diff --git a/respExercicio04.py b/respExercicio04.py new file mode 100644 index 0000000..e69de29 diff --git a/respExercicio05.py b/respExercicio05.py new file mode 100644 index 0000000..e69de29 From 2b2516f80b50440f84db4e8d796b064405c4d5d5 Mon Sep 17 00:00:00 2001 From: Gabriel Reis Date: Wed, 12 Nov 2025 20:12:44 -0300 Subject: [PATCH 2/7] exercicio 2 e 3 feito --- respExercicio02.py | 42 ++++++++++++++++++++++++++++++ respExercicio03.py | 65 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 107 insertions(+) diff --git a/respExercicio02.py b/respExercicio02.py index e69de29..948e25c 100644 --- a/respExercicio02.py +++ b/respExercicio02.py @@ -0,0 +1,42 @@ +class Aluno: + def __init__ (self, nome, matricula, curso, notas=[]): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.notas = notas + + def adicionar_nota(self, nota): + if len(self.notas) >= 2: + print("Número máximo de notas atingido.") + self.notas = [] + self.notas.append(nota) + + def calcular_media(self): + print(self.notas) + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + return "Aprovado" if media >= 7 else "Reprovado" + +class Disciplina: + def __init__ (self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + +aluno = Aluno("João Silva", "2023001", "Engenharia de Software") + +aluno.adicionar_nota(8) +aluno.adicionar_nota(7) + +aluno_media = aluno.calcular_media() + +print(f"Média do aluno: {aluno_media:.2f}") +aluno.status() + +disciplina = Disciplina("Programação Orientada a Objetos", "CS101", 60) + +print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}, Curso: {aluno.curso}") + +print(f"Disciplina: {disciplina.nome}, Código: {disciplina.codigo}, Carga Horária: {disciplina.carga_horaria} horas") \ No newline at end of file diff --git a/respExercicio03.py b/respExercicio03.py index e69de29..b81980a 100644 --- a/respExercicio03.py +++ b/respExercicio03.py @@ -0,0 +1,65 @@ +class Aluno: + def __init__ (self, nome, matricula, curso, notas=[]): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.notas = notas + + def adicionar_nota(self, nota): + if len(self.notas) >= 2: + print("Número máximo de notas atingido.") + self.notas = [] + self.notas.append(nota) + + def calcular_media(self): + print(self.notas) + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + return "Aprovado" if media >= 7 else "Reprovado" + +class Disciplina: + def __init__ (self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + +class Professor: + def __init__ (self, nome, departamento, salario): + self.nome = nome + self.departamento = departamento + self._salario = salario + + @property + def salario(self): + return self._salario + + @salario.setter + def salario(self, novo_salario): + if novo_salario > 0: + self._salario = novo_salario + else: + print("Salário deve ser positivo.") + +aluno = Aluno("João Silva", "2023001", "Engenharia de Software") + +aluno.adicionar_nota(8) +aluno.adicionar_nota(7) + +aluno_media = aluno.calcular_media() + +print(f"Média do aluno: {aluno_media:.2f}") +aluno.status() + +disciplina = Disciplina("Programação Orientada a Objetos", "CS101", 60) + +print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}, Curso: {aluno.curso}") + +print(f"Disciplina: {disciplina.nome}, Código: {disciplina.codigo}, Carga Horária: {disciplina.carga_horaria} horas") + +prof = Professor("Dr. Carlos", "Ciência da Computação", 5000) +print(f"Salário do professor: R$ {prof.salario:.2f}") +prof.salario = 6000 +print(f"Novo salário do professor: R$ {prof.salario:.2f}") +prof.salario = -1000 # Isso levantará um ValueError \ No newline at end of file From 56bcd5c4f0b9c8ac03f1c78f5626fe8c7ad7a34e Mon Sep 17 00:00:00 2001 From: Gabriel Reis Date: Wed, 12 Nov 2025 20:29:28 -0300 Subject: [PATCH 3/7] Exercicio 4 e 5 Resolvido --- exercicio_05.md | 9 +++- respExercicio04.py | 101 ++++++++++++++++++++++++++++++++++++++++++++ respExercicio05.py | 102 +++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 210 insertions(+), 2 deletions(-) diff --git a/exercicio_05.md b/exercicio_05.md index 9165174..c84fd64 100644 --- a/exercicio_05.md +++ b/exercicio_05.md @@ -1,12 +1,14 @@ # Exercício 05 - Herança e o Uso de super() ## Objetivo + Entender e utilizar a função super() no construtor da classe filha. ## Descrição do Exercício + Aprimore a classe **Funcionario** do exercício 4 utilizando corretamente a função `super()`. -### Requisitos: +### Requisitos 1. No construtor (`__init__`) de **Funcionario**, utilize `super().__init__(...)` para inicializar os atributos herdados de **Pessoa**. @@ -17,15 +19,18 @@ Aprimore a classe **Funcionario** do exercício 4 utilizando corretamente a fun 4. Crie um objeto Funcionario e garanta que todos os atributos (herdados e próprios) foram inicializados corretamente. ## Entrega + Crie um arquivo chamado `respExercicio05.py` com a implementação aprimorada usando `super()`. ## Exemplo de Uso + ```python funcionario = Funcionario("Ana Costa", "111.222.333-44", "20/03/1988", "Coordenadora", 4500.0) funcionario.exibir_dados() ``` ## Exemplo de Saída Esperada + ``` === Dados do Funcionário === Nome: Ana Costa @@ -33,4 +38,4 @@ CPF: 111.222.333-44 Data de Nascimento: 20/03/1988 Cargo: Coordenadora Salário: R$ 4500.0 -``` \ No newline at end of file +``` diff --git a/respExercicio04.py b/respExercicio04.py index e69de29..d38b01e 100644 --- a/respExercicio04.py +++ b/respExercicio04.py @@ -0,0 +1,101 @@ +class Aluno: + def __init__ (self, nome, matricula, curso, notas=[]): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.notas = notas + + def adicionar_nota(self, nota): + if len(self.notas) >= 2: + print("Número máximo de notas atingido.") + self.notas = [] + self.notas.append(nota) + + def calcular_media(self): + print(self.notas) + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + return "Aprovado" if media >= 7 else "Reprovado" + +class Disciplina: + def __init__ (self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + +class Professor: + def __init__ (self, nome, departamento, salario): + self.nome = nome + self.departamento = departamento + self._salario = salario + + @property + def salario(self): + return self._salario + + @salario.setter + def salario(self, novo_salario): + if novo_salario > 0: + self._salario = novo_salario + else: + print("Salário deve ser positivo.") + +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"Nome: {self.nome}, CPF: {self.cpf}, Data de Nascimento: {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): + apresent = super().apresentar() + apresent += f", Cargo: {self.cargo}" + return apresent + +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): + apresent = super().apresentar() + apresent += f", Área de Atuação: {self.area_atuacao}" + return apresent + +aluno = Aluno("João Silva", "2023001", "Engenharia de Software") + +aluno.adicionar_nota(8) +aluno.adicionar_nota(7) + +aluno_media = aluno.calcular_media() + +print(f"Média do aluno: {aluno_media:.2f}") +aluno.status() + +disciplina = Disciplina("Programação Orientada a Objetos", "CS101", 60) + +print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}, Curso: {aluno.curso}") + +print(f"Disciplina: {disciplina.nome}, Código: {disciplina. codigo}, Carga Horária: {disciplina.carga_horaria} horas") + +#--------------------------------------------------- +prof = Professor("Dr. Carlos", "Ciência da Computação", 5000) +print(f"Salário do professor: R$ {prof.salario:.2f}") +prof.salario = 6000 +print(f"Novo salário do professor: R$ {prof.salario:.2f}") +prof.salario = -1000 + + +#--------------------------------------------------- +funcionario = Funcionario("Ana Souza", "123.456.789-00", "15/04/1985", "Gerente") +print(funcionario.apresentar()) + +tutor = Tutor("Carlos Pereira", "987.654.321-00", "22/09/1990", "Matemática") +print(tutor.apresentar()) \ No newline at end of file diff --git a/respExercicio05.py b/respExercicio05.py index e69de29..838d5da 100644 --- a/respExercicio05.py +++ b/respExercicio05.py @@ -0,0 +1,102 @@ +class Aluno: + def __init__ (self, nome, matricula, curso, notas=[]): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.notas = notas + + def adicionar_nota(self, nota): + if len(self.notas) >= 2: + print("Número máximo de notas atingido.") + self.notas = [] + self.notas.append(nota) + + def calcular_media(self): + print(self.notas) + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + return "Aprovado" if media >= 7 else "Reprovado" + +class Disciplina: + def __init__ (self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + +class Professor: + def __init__ (self, nome, departamento, salario): + self.nome = nome + self.departamento = departamento + self._salario = salario + + @property + def salario(self): + return self._salario + + @salario.setter + def salario(self, novo_salario): + if novo_salario > 0: + self._salario = novo_salario + else: + print("Salário deve ser positivo.") + +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"Nome: {self.nome}, CPF: {self.cpf}, Data de Nascimento: {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): + print(f"=== Dados do Funcionário ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nCargo: {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): + print(f"=== Dados do Tutor ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nÁrea de Atuação: {self.area_atuacao}") + + + +aluno = Aluno("João Silva", "2023001", "Engenharia de Software") + +aluno.adicionar_nota(8) +aluno.adicionar_nota(7) + +aluno_media = aluno.calcular_media() + +print(f"Média do aluno: {aluno_media:.2f}") +aluno.status() + +disciplina = Disciplina("Programação Orientada a Objetos", "CS101", 60) + +print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}, Curso: {aluno.curso}") + +print(f"Disciplina: {disciplina.nome}, Código: {disciplina. codigo}, Carga Horária: {disciplina.carga_horaria} horas") + +#--------------------------------------------------- +prof = Professor("Dr. Carlos", "Ciência da Computação", 5000) +print(f"Salário do professor: R$ {prof.salario:.2f}") +prof.salario = 6000 +print(f"Novo salário do professor: R$ {prof.salario:.2f}") +prof.salario = -1000 + + +#--------------------------------------------------- +funcionario = Funcionario("Ana Souza", "123.456.789-00", "15/04/1985", "Gerente") +print(funcionario.apresentar()) + +tutor = Tutor("Carlos Pereira", "987.654.321-00", "22/09/1990", "Matemática") +print(tutor.apresentar()) + + +#--------------------------------------------------- From 5c29e3717f36c117cb37a054d9ccc4095ca4c603 Mon Sep 17 00:00:00 2001 From: Gabriel Reis Date: Wed, 12 Nov 2025 22:05:04 -0300 Subject: [PATCH 4/7] 5 corrigido, ate o 9 feito, 10 falta 2 erros --- Resposta_10.py | 38 +++++++++ exercicio_06.md | 9 +- exercicio_08.md | 9 +- respExercicio05.py | 11 +-- respExercicio06.py | 127 +++++++++++++++++++++++++++ respExercicio07.py | 158 ++++++++++++++++++++++++++++++++++ respExercicio08.py | 190 +++++++++++++++++++++++++++++++++++++++++ respExercicio09.py | 207 +++++++++++++++++++++++++++++++++++++++++++++ 8 files changed, 740 insertions(+), 9 deletions(-) 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.py b/Resposta_10.py new file mode 100644 index 0000000..ae3c61b --- /dev/null +++ b/Resposta_10.py @@ -0,0 +1,38 @@ +class Pessoa: + def __init__(self, nome, idade): + self.nome = nome + self.idade = idade + self.__cpf + + def apresentar(self): + return f"Olá, sou {self.nome}" + +class Estudante(Pessoa): + def __init__(self, nome, idade, curso): + super().__init__(nome, idade) + self.curso = curso + self.notas = [] + + def adicionar_nota(self, nota): + if nota >= 0 and nota <= 10: + self.notas.append(nota) + + def calcular_media(self): + return sum(self.notas) / len(self.notas) # Erro 6 + +class Professor(Pessoa): + def __init__(self, nome, idade, departamento, salario): + super().__init__(nome, idade) + 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 +estudante = Estudante("João", 20, "Engenharia") +professor = Professor("Dr. Silva", 45, "Computação", 8000) + +print(estudante.apresentar()) +print(professor.apresentar()) +print(f"Média do estudante: {estudante.calcular_media()}") # Erro 7 \ No newline at end of file diff --git a/exercicio_06.md b/exercicio_06.md index 4bad163..9999a36 100644 --- a/exercicio_06.md +++ b/exercicio_06.md @@ -1,12 +1,14 @@ # Exercício 06 - Composição (Relacionamento "Tem Um") ## Objetivo + Praticar o princípio da Composição, onde um objeto é feito de outros objetos. ## Descrição do Exercício + Crie a classe **Curso** que será composta por objetos **Disciplina**. -### Requisitos: +### Requisitos 1. Crie a classe **Curso** com atributos: - nome @@ -22,9 +24,11 @@ Crie a classe **Curso** que será composta por objetos **Disciplina**. 5. Adicione um método `carga_horaria_total()` que retorne a soma da carga horária de todas as disciplinas. ## Entrega + Crie um arquivo chamado `respExercicio06.py` com a implementação das classes e demonstração da composição. ## Exemplo de Uso + ```python curso = Curso("Engenharia de Software", "ES001") disciplina1 = Disciplina("Programação Orientada a Objetos", "POO001", 60) @@ -37,9 +41,10 @@ print(f"Carga horária total: {curso.carga_horaria_total()}h") ``` ## Exemplo de Saída Esperada + ``` === Disciplinas do Curso: Engenharia de Software === - Programação Orientada a Objetos (POO001) - Banco de Dados (BD001) Carga horária total: 140h -``` \ No newline at end of file +``` diff --git a/exercicio_08.md b/exercicio_08.md index bbd7d0d..e132541 100644 --- a/exercicio_08.md +++ b/exercicio_08.md @@ -1,12 +1,14 @@ # Exercício 08 - Método de Classe (@classmethod) ## Objetivo + Entender o uso de métodos de classe para criar fábricas de objetos. ## Descrição do Exercício + Crie a classe **Departamento** com métodos de classe para facilitar a criação de objetos. -### Requisitos: +### Requisitos 1. Crie a classe **Departamento** com atributos: - nome @@ -22,9 +24,11 @@ Crie a classe **Departamento** com métodos de classe para facilitar a criação 5. Use esses métodos para criar dois departamentos distintos. ## Entrega + Crie um arquivo chamado `respExercicio08.py` com a implementação dos métodos de classe. ## Exemplo de Uso + ```python dept_exatas = Departamento.criar_departamento_exatas("Matemática e Computação") dept_humanas = Departamento.criar_departamento_humanas("Letras e Filosofia") @@ -34,7 +38,8 @@ print(f"Departamento: {dept_humanas.nome} - Sigla: {dept_humanas.sigla}") ``` ## Exemplo de Saída Esperada + ``` Departamento: Matemática e Computação - Sigla: EXA Departamento: Letras e Filosofia - Sigla: HUM -``` \ No newline at end of file +``` diff --git a/respExercicio05.py b/respExercicio05.py index 838d5da..2655ebd 100644 --- a/respExercicio05.py +++ b/respExercicio05.py @@ -52,11 +52,12 @@ def apresentar(self): return f"Nome: {self.nome}, CPF: {self.cpf}, Data de Nascimento: {self.data_nascimento}" class Funcionario(Pessoa): - def __init__(self, nome, cpf, data_nascimento, cargo): + def __init__(self, nome, cpf, data_nascimento, cargo, salario): super().__init__(nome, cpf, data_nascimento) self.cargo = cargo - def apresentar(self): - print(f"=== Dados do Funcionário ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nCargo: {self.cargo}") + self.salario = salario + def exibir_dados(self): + print(f"=== Dados do Funcionário ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nCargo: {self.cargo}\nSalário: R$ {self.salario:.2f}") class Tutor(Pessoa): def __init__(self, nome, cpf, data_nascimento, area_atuacao): @@ -92,8 +93,8 @@ def apresentar(self): #--------------------------------------------------- -funcionario = Funcionario("Ana Souza", "123.456.789-00", "15/04/1985", "Gerente") -print(funcionario.apresentar()) +funcionario = Funcionario("Ana Souza", "123.456.789-00", "15/04/1985", "Gerente", 7000) +funcionario.exibir_dados() tutor = Tutor("Carlos Pereira", "987.654.321-00", "22/09/1990", "Matemática") print(tutor.apresentar()) diff --git a/respExercicio06.py b/respExercicio06.py new file mode 100644 index 0000000..a90afd7 --- /dev/null +++ b/respExercicio06.py @@ -0,0 +1,127 @@ +class Aluno: + def __init__ (self, nome, matricula, curso, notas=[]): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.notas = notas + + def adicionar_nota(self, nota): + if len(self.notas) >= 2: + print("Número máximo de notas atingido.") + self.notas = [] + self.notas.append(nota) + + def calcular_media(self): + print(self.notas) + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + return "Aprovado" if media >= 7 else "Reprovado" + +class Disciplina: + def __init__ (self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + +class Professor: + def __init__ (self, nome, departamento, salario): + self.nome = nome + self.departamento = departamento + self._salario = salario + + @property + def salario(self): + return self._salario + + @salario.setter + def salario(self, novo_salario): + if novo_salario > 0: + self._salario = novo_salario + else: + print("Salário deve ser positivo.") + +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"Nome: {self.nome}, CPF: {self.cpf}, Data de Nascimento: {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): + print(f"=== Dados do Funcionário ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nCargo: {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): + print(f"=== Dados do Tutor ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nÁrea de Atuação: {self.area_atuacao}") + +class Curso: + def __init__ (self, nome, codigo, disciplinas: list[Disciplina] = []): + self.nome = nome + self.codigo = codigo + self.disciplinas = disciplinas + + def adicionar_disciplina(self, disciplina: Disciplina): + if len(self.disciplinas) >= 2: + self.disciplinas = [] + self.disciplinas.append(disciplina) + + def listar_disciplinas(self): + for disciplina in self.disciplinas: + print(f"Disciplina: {disciplina.nome}\nCódigo: {disciplina.codigo}") + + def carga_horaria_total(self): + total = sum(disciplina.carga_horaria for disciplina in self.disciplinas) + return total + +aluno = Aluno("João Silva", "2023001", "Engenharia de Software") + +aluno.adicionar_nota(8) +aluno.adicionar_nota(7) + +aluno_media = aluno.calcular_media() + +print(f"Média do aluno: {aluno_media:.2f}") +aluno.status() + +disciplina = Disciplina("Programação Orientada a Objetos", "CS101", 60) + +print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}, Curso: {aluno.curso}") + +print(f"Disciplina: {disciplina.nome}, Código: {disciplina. codigo}, Carga Horária: {disciplina.carga_horaria} horas") + +#--------------------------------------------------- +prof = Professor("Dr. Carlos", "Ciência da Computação", 5000) +print(f"Salário do professor: R$ {prof.salario:.2f}") +prof.salario = 6000 +print(f"Novo salário do professor: R$ {prof.salario:.2f}") +prof.salario = -1000 + + +#--------------------------------------------------- +funcionario = Funcionario("Ana Souza", "123.456.789-00", "15/04/1985", "Gerente") +print(funcionario.apresentar()) + +tutor = Tutor("Carlos Pereira", "987.654.321-00", "22/09/1990", "Matemática") +print(tutor.apresentar()) + + +#--------------------------------------------------- +curso = Curso("Engenharia de Software", "ES101") +disc1 = Disciplina("Programação", "CS101", 60) +disc2 = Disciplina("Banco de Dados", "CS102", 80) +curso.adicionar_disciplina(disc1) +curso.adicionar_disciplina(disc2) +curso.listar_disciplinas() +total_carga = curso.carga_horaria_total() +print(f"Carga horária total do curso: {total_carga} horas") \ No newline at end of file diff --git a/respExercicio07.py b/respExercicio07.py new file mode 100644 index 0000000..ea8b4fa --- /dev/null +++ b/respExercicio07.py @@ -0,0 +1,158 @@ +class Aluno: + def __init__ (self, nome, matricula, curso, notas=[], disciplinas_inscritas: list = []): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.notas = notas + self.disciplinas_inscritas = disciplinas_inscritas + + def adicionar_nota(self, nota): + if len(self.notas) >= 2: + print("Número máximo de notas atingido.") + self.notas = [] + self.notas.append(nota) + + def calcular_media(self): + print(self.notas) + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + return "Aprovado" if media >= 7 else "Reprovado" + + def listar_disciplinas(self): + print("Disciplinas inscritas:\n") + for disciplina in self.disciplinas_inscritas: + print(f"Disciplina: {disciplina.nome}, Código: {disciplina.codigo}") + +class Disciplina: + def __init__ (self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + self.alunos_matriculados = [] + + def listar_alunos(self): + print("Alunos inscritos na disciplina:\n") + for aluno in self.alunos_matriculados: + print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}") + +class Professor: + def __init__ (self, nome, departamento, salario): + self.nome = nome + self.departamento = departamento + self._salario = salario + + @property + def salario(self): + return self._salario + + @salario.setter + def salario(self, novo_salario): + if novo_salario > 0: + self._salario = novo_salario + else: + print("Salário deve ser positivo.") + +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"Nome: {self.nome}, CPF: {self.cpf}, Data de Nascimento: {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): + print(f"=== Dados do Funcionário ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nCargo: {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): + print(f"=== Dados do Tutor ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nÁrea de Atuação: {self.area_atuacao}") + +class Curso: + def __init__ (self, nome, codigo, disciplinas: list[Disciplina] = []): + self.nome = nome + self.codigo = codigo + self.disciplinas = disciplinas + + def adicionar_disciplina(self, disciplina: Disciplina): + if len(self.disciplinas) >= 2: + self.disciplinas = [] + self.disciplinas.append(disciplina) + + def listar_disciplinas(self): + for disciplina in self.disciplinas: + print(f"Disciplina: {disciplina.nome}\nCódigo: {disciplina.codigo}") + + def carga_horaria_total(self): + total = sum(disciplina.carga_horaria for disciplina in self.disciplinas) + return total + +class Secretaria: + def inscrever_aluno(aluno: Aluno, disciplina: Disciplina): + aluno.disciplinas_inscritas.append(disciplina) + disciplina.alunos_matriculados.append(aluno) + print(f"Aluno {aluno.nome} inscrito na disciplina {disciplina.nome}.") + +# Testando as classes criadas +aluno = Aluno("João Silva", "2023001", "Engenharia de Software") + +aluno.adicionar_nota(8) +aluno.adicionar_nota(7) + +aluno_media = aluno.calcular_media() + +print(f"Média do aluno: {aluno_media:.2f}") +aluno.status() + +disciplina = Disciplina("Programação Orientada a Objetos", "CS101", 60) + +print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}, Curso: {aluno.curso}") + +print(f"Disciplina: {disciplina.nome}, Código: {disciplina. codigo}, Carga Horária: {disciplina.carga_horaria} horas") + +#--------------------------------------------------- +prof = Professor("Dr. Carlos", "Ciência da Computação", 5000) +print(f"Salário do professor: R$ {prof.salario:.2f}") +prof.salario = 6000 +print(f"Novo salário do professor: R$ {prof.salario:.2f}") +prof.salario = -1000 + + +#--------------------------------------------------- +funcionario = Funcionario("Ana Souza", "123.456.789-00", "15/04/1985", "Gerente") +print(funcionario.apresentar()) + +tutor = Tutor("Carlos Pereira", "987.654.321-00", "22/09/1990", "Matemática") +print(tutor.apresentar()) + + +#--------------------------------------------------- +curso = Curso("Engenharia de Software", "ES101") +disc1 = Disciplina("Programação", "CS101", 60) +disc2 = Disciplina("Banco de Dados", "CS102", 80) +curso.adicionar_disciplina(disc1) +curso.adicionar_disciplina(disc2) +curso.listar_disciplinas() +total_carga = curso.carga_horaria_total() +print(f"Carga horária total do curso: {total_carga} horas") + +#--------------------------------------------------- +aluno1 = Aluno("Maria Oliveira", "2023002", "Engenharia de Software") +aluno2 = Aluno("Pedro Santos", "2023003", "Engenharia de Software") +disciplina1 = Disciplina("Estruturas de Dados", "CS201", 70) +disciplina2 = Disciplina("Redes de Computadores", "CS202", 50) +Secretaria.inscrever_aluno(aluno1, disciplina1) +Secretaria.inscrever_aluno(aluno1, disciplina2) +Secretaria.inscrever_aluno(aluno2, disciplina1) +aluno1.listar_disciplinas() +disciplina1.listar_alunos() +disciplina2.listar_alunos() \ No newline at end of file diff --git a/respExercicio08.py b/respExercicio08.py new file mode 100644 index 0000000..4d83042 --- /dev/null +++ b/respExercicio08.py @@ -0,0 +1,190 @@ +class Aluno: + def __init__ (self, nome, matricula, curso, notas=[], disciplinas_inscritas: list = []): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.notas = notas + self.disciplinas_inscritas = disciplinas_inscritas + + def adicionar_nota(self, nota): + if len(self.notas) >= 2: + print("Número máximo de notas atingido.") + self.notas = [] + self.notas.append(nota) + + def calcular_media(self): + print(self.notas) + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + return "Aprovado" if media >= 7 else "Reprovado" + + def listar_disciplinas(self): + print("Disciplinas inscritas:\n") + for disciplina in self.disciplinas_inscritas: + print(f"Disciplina: {disciplina.nome}, Código: {disciplina.codigo}") + +class Disciplina: + def __init__ (self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + self.alunos_matriculados = [] + + def listar_alunos(self): + print("Alunos inscritos na disciplina:\n") + for aluno in self.alunos_matriculados: + print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}") + +class Professor: + def __init__ (self, nome, departamento, salario): + self.nome = nome + self.departamento = departamento + self._salario = salario + + @property + def salario(self): + return self._salario + + @salario.setter + def salario(self, novo_salario): + if novo_salario > 0: + self._salario = novo_salario + else: + print("Salário deve ser positivo.") + +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"Nome: {self.nome}, CPF: {self.cpf}, Data de Nascimento: {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): + print(f"=== Dados do Funcionário ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nCargo: {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): + print(f"=== Dados do Tutor ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nÁrea de Atuação: {self.area_atuacao}") + +class Curso: + def __init__ (self, nome, codigo, disciplinas: list[Disciplina] = []): + self.nome = nome + self.codigo = codigo + self.disciplinas = disciplinas + + def adicionar_disciplina(self, disciplina: Disciplina): + if len(self.disciplinas) >= 2: + self.disciplinas = [] + self.disciplinas.append(disciplina) + + def listar_disciplinas(self): + for disciplina in self.disciplinas: + print(f"Disciplina: {disciplina.nome}\nCódigo: {disciplina.codigo}") + + def carga_horaria_total(self): + total = sum(disciplina.carga_horaria for disciplina in self.disciplinas) + return total + +class Secretaria: + def inscrever_aluno(aluno: Aluno, disciplina: Disciplina): + aluno.disciplinas_inscritas.append(disciplina) + disciplina.alunos_matriculados.append(aluno) + print(f"Aluno {aluno.nome} inscrito na disciplina {disciplina.nome}.") + +class Departamento: + def __init__(self, nome, sigla, professores: list[Professor] = []): + self.nome = nome + self.sigla = sigla + self.professores: list[Professor] = professores + + @classmethod + def criar_departamento_exatas(self, nome): + dept = Departamento(nome, "EXA") + dept.sigla = "EXA" + return dept + + @classmethod + def criar_departamento_humanas(self, nome): + dept = Departamento(nome, "HUM") + dept.sigla = "HUM" + return dept + + def adicionar_professor(self, professor: Professor): + self.professores.append(professor) + + def listar_professores(self): + for professor in self.professores: + print(f"Professor: {professor.nome}, Departamento: {professor.departamento}") + +# Testando as classes criadas +aluno = Aluno("João Silva", "2023001", "Engenharia de Software") + +aluno.adicionar_nota(8) +aluno.adicionar_nota(7) + +aluno_media = aluno.calcular_media() + +print(f"Média do aluno: {aluno_media:.2f}") +aluno.status() + +disciplina = Disciplina("Programação Orientada a Objetos", "CS101", 60) + +print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}, Curso: {aluno.curso}") + +print(f"Disciplina: {disciplina.nome}, Código: {disciplina. codigo}, Carga Horária: {disciplina.carga_horaria} horas") + +#--------------------------------------------------- +prof = Professor("Dr. Carlos", "Ciência da Computação", 5000) +print(f"Salário do professor: R$ {prof.salario:.2f}") +prof.salario = 6000 +print(f"Novo salário do professor: R$ {prof.salario:.2f}") +prof.salario = -1000 + + +#--------------------------------------------------- +funcionario = Funcionario("Ana Souza", "123.456.789-00", "15/04/1985", "Gerente") +print(funcionario.apresentar()) + +tutor = Tutor("Carlos Pereira", "987.654.321-00", "22/09/1990", "Matemática") +print(tutor.apresentar()) + + +#--------------------------------------------------- +curso = Curso("Engenharia de Software", "ES101") +disc1 = Disciplina("Programação", "CS101", 60) +disc2 = Disciplina("Banco de Dados", "CS102", 80) +curso.adicionar_disciplina(disc1) +curso.adicionar_disciplina(disc2) +curso.listar_disciplinas() +total_carga = curso.carga_horaria_total() +print(f"Carga horária total do curso: {total_carga} horas") + +#--------------------------------------------------- +aluno1 = Aluno("Maria Oliveira", "2023002", "Engenharia de Software") +aluno2 = Aluno("Pedro Santos", "2023003", "Engenharia de Software") +disciplina1 = Disciplina("Estruturas de Dados", "CS201", 70) +disciplina2 = Disciplina("Redes de Computadores", "CS202", 50) +Secretaria.inscrever_aluno(aluno1, disciplina1) +Secretaria.inscrever_aluno(aluno1, disciplina2) +Secretaria.inscrever_aluno(aluno2, disciplina1) +aluno1.listar_disciplinas() +disciplina1.listar_alunos() +disciplina2.listar_alunos() + +#--------------------------------------------------- +dept_exatas = Departamento.criar_departamento_exatas("Departamento de Ciências Exatas") +dept_humanas = Departamento.criar_departamento_humanas("Departamento de Ciências Humanas") + +print(f"Departamento: {dept_exatas.nome}, Sigla: {dept_exatas.sigla}") +print(f"Departamento: {dept_humanas.nome}, Sigla: {dept_humanas.sigla}") \ No newline at end of file diff --git a/respExercicio09.py b/respExercicio09.py new file mode 100644 index 0000000..be1f85a --- /dev/null +++ b/respExercicio09.py @@ -0,0 +1,207 @@ +class Aluno: + def __init__ (self, nome, matricula, curso, notas=[], disciplinas_inscritas: list = []): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.notas = notas + self.disciplinas_inscritas = disciplinas_inscritas + + def adicionar_nota(self, nota): + if len(self.notas) >= 2: + print("Número máximo de notas atingido.") + self.notas = [] + self.notas.append(nota) + + def calcular_media(self): + print(self.notas) + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + return "Aprovado" if media >= 7 else "Reprovado" + + def listar_disciplinas(self): + print("Disciplinas inscritas:\n") + for disciplina in self.disciplinas_inscritas: + print(f"Disciplina: {disciplina.nome}, Código: {disciplina.codigo}") + + def apresentar(self): + return f"Olá, sou o aluno {self.nome} e estudo no curso {self.curso}." + +class Disciplina: + def __init__ (self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + self.alunos_matriculados = [] + + def listar_alunos(self): + print("Alunos inscritos na disciplina:\n") + for aluno in self.alunos_matriculados: + print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}") + +class Professor: + def __init__ (self, nome, departamento, salario): + self.nome = nome + self.departamento = departamento + self._salario = salario + + @property + def salario(self): + return self._salario + + @salario.setter + def salario(self, novo_salario): + if novo_salario > 0: + self._salario = novo_salario + else: + print("Salário deve ser positivo.") + + def apresentar(self): + return f"Olá, sou o professor {self.nome} do departamento de {self.departamento}." + +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"Nome: {self.nome}, CPF: {self.cpf}, Data de Nascimento: {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"=== Dados do Funcionário ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nCargo: {self.cargo}\nSalário: R$ {self.salario:.2f}" + +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): + print(f"=== Dados do Tutor ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nÁrea de Atuação: {self.area_atuacao}") + +class Curso: + def __init__ (self, nome, codigo, disciplinas: list[Disciplina] = []): + self.nome = nome + self.codigo = codigo + self.disciplinas = disciplinas + + def adicionar_disciplina(self, disciplina: Disciplina): + if len(self.disciplinas) >= 2: + self.disciplinas = [] + self.disciplinas.append(disciplina) + + def listar_disciplinas(self): + for disciplina in self.disciplinas: + print(f"Disciplina: {disciplina.nome}\nCódigo: {disciplina.codigo}") + + def carga_horaria_total(self): + total = sum(disciplina.carga_horaria for disciplina in self.disciplinas) + return total + +class Secretaria: + def inscrever_aluno(aluno: Aluno, disciplina: Disciplina): + aluno.disciplinas_inscritas.append(disciplina) + disciplina.alunos_matriculados.append(aluno) + print(f"Aluno {aluno.nome} inscrito na disciplina {disciplina.nome}.") + +class Departamento: + def __init__(self, nome, sigla, professores: list[Professor] = []): + self.nome = nome + self.sigla = sigla + self.professores: list[Professor] = professores + + @classmethod + def criar_departamento_exatas(self, nome): + dept = Departamento(nome, "EXA") + dept.sigla = "EXA" + return dept + + @classmethod + def criar_departamento_humanas(self, nome): + dept = Departamento(nome, "HUM") + dept.sigla = "HUM" + return dept + + def adicionar_professor(self, professor: Professor): + self.professores.append(professor) + + def listar_professores(self): + for professor in self.professores: + print(f"Professor: {professor.nome}, Departamento: {professor.departamento}") + +# Testando as classes criadas +aluno = Aluno("João Silva", "2023001", "Engenharia de Software") + +aluno.adicionar_nota(8) +aluno.adicionar_nota(7) + +aluno_media = aluno.calcular_media() + +print(f"Média do aluno: {aluno_media:.2f}") +aluno.status() + +disciplina = Disciplina("Programação Orientada a Objetos", "CS101", 60) + +print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}, Curso: {aluno.curso}") + +print(f"Disciplina: {disciplina.nome}, Código: {disciplina. codigo}, Carga Horária: {disciplina.carga_horaria} horas") + +#--------------------------------------------------- +prof = Professor("Dr. Carlos", "Ciência da Computação", 5000) +print(f"Salário do professor: R$ {prof.salario:.2f}") +prof.salario = 6000 +print(f"Novo salário do professor: R$ {prof.salario:.2f}") +prof.salario = -1000 + + +#--------------------------------------------------- +funcionario = Funcionario("Ana Souza", "123.456.789-00", "15/04/1985", "Gerente", 7000) +print(funcionario.apresentar()) + +tutor = Tutor("Carlos Pereira", "987.654.321-00", "22/09/1990", "Matemática") +print(tutor.apresentar()) + + +#--------------------------------------------------- +curso = Curso("Engenharia de Software", "ES101") +disc1 = Disciplina("Programação", "CS101", 60) +disc2 = Disciplina("Banco de Dados", "CS102", 80) +curso.adicionar_disciplina(disc1) +curso.adicionar_disciplina(disc2) +curso.listar_disciplinas() +total_carga = curso.carga_horaria_total() +print(f"Carga horária total do curso: {total_carga} horas") + +#--------------------------------------------------- +aluno1 = Aluno("Maria Oliveira", "2023002", "Engenharia de Software") +aluno2 = Aluno("Pedro Santos", "2023003", "Engenharia de Software") +disciplina1 = Disciplina("Estruturas de Dados", "CS201", 70) +disciplina2 = Disciplina("Redes de Computadores", "CS202", 50) +Secretaria.inscrever_aluno(aluno1, disciplina1) +Secretaria.inscrever_aluno(aluno1, disciplina2) +Secretaria.inscrever_aluno(aluno2, disciplina1) +aluno1.listar_disciplinas() +disciplina1.listar_alunos() +disciplina2.listar_alunos() + +#--------------------------------------------------- +dept_exatas = Departamento.criar_departamento_exatas("Departamento de Ciências Exatas") +dept_humanas = Departamento.criar_departamento_humanas("Departamento de Ciências Humanas") + +print(f"Departamento: {dept_exatas.nome}, Sigla: {dept_exatas.sigla}") +print(f"Departamento: {dept_humanas.nome}, Sigla: {dept_humanas.sigla}") + +#--------------------------------------------------- +pessoas = [ + Aluno("João Silva", "2023001", "Engenharia de Software"), + Professor("Dr. Maria", "Computação", 8000), + Funcionario("Carlos Santos", "123.456.789-00", "01/01/1980", "Secretário", 7000), +] + +for pessoa in pessoas: + print(pessoa.apresentar()) \ No newline at end of file From 1efe23b655483965da2bd80a976c2bfb19c16070 Mon Sep 17 00:00:00 2001 From: Gabriel Reis Date: Sat, 15 Nov 2025 10:08:35 -0300 Subject: [PATCH 5/7] =?UTF-8?q?t=C3=A9rmino=20do=2010=20e=20relat=C3=B3rio?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Resposta_10.md | 96 ++++++++++++++++++++++++++++++++++++++++++++++++++ Resposta_10.py | 8 +++-- 2 files changed, 101 insertions(+), 3 deletions(-) create mode 100644 Resposta_10.md diff --git a/Resposta_10.md b/Resposta_10.md new file mode 100644 index 0000000..7fa277e --- /dev/null +++ b/Resposta_10.md @@ -0,0 +1,96 @@ +# Relatório: Erros encontrados e correções - Exercício 10 + +Abaixo estão os 7 erros identificados no código fornecido, a solução aplicada e o princípio de POO envolvido. + +--- + +**Erro 1**: Nome da classe em minúsculas + +- Descrição: A classe foi declarada como `class pessoa:` (nome em minúsculas). Pela convenção do Python e boas práticas de POO, nomes de classes devem usar PascalCase. +- Solução: Renomeada para `class Pessoa:`. +- Conceito POO: Convenção de nomenclatura / legibilidade. + +--- + +**Erro 2**: Atributo `nome` não atribuído ao objeto + +- Descrição: No construtor foi usado `nome = nome` (atribuição local), em vez de `self.nome = nome`. Isso não cria o atributo de instância. +- Solução: Corrigido para `self.nome = nome` no `__init__` de `Pessoa`. +- Conceito POO: Encapsulamento / inicialização de atributos de instância. + +--- + +**Erro 3**: Uso incorreto / falta de inicialização do atributo `__cpf` + +- Descrição: Existia uma referência solta a `self.__cpf` no construtor (ou em algumas versões faltava a atribuição). Esse uso sem atribuição provoca `AttributeError` ou é ambíguo. +- Solução: Inicializar o atributo privado corretamente: `self.__cpf = None`. +- Conceito POO: Encapsulamento / atributos privados (name mangling). Inicialização correta de estado do objeto. + +--- + +**Erro 4**: Método `apresentar` sem parâmetro `self` + +- Descrição: O método foi definido como `def apresentar():`, sem o parâmetro `self`, tornando impossível acessar `self.nome` dentro do método. +- Solução: Alterado para `def apresentar(self):` e uso de `self.nome` para compor a string. +- Conceito POO: Métodos de instância devem aceitar `self` como primeiro parâmetro. + +--- + +**Erro 5**: Inicialização incorreta na subclasse `Estudante` + +- Descrição: A classe `Estudante` atribuía manualmente `self.nome = nome` e `self.idade = idade` invés de reutilizar o construtor da superclasse, perdendo lógica de inicialização e manutenção. +- Solução: Usar `super().__init__(nome, idade)` dentro de `Estudante.__init__` para reaproveitar a inicialização da classe `Pessoa`. +- Conceito POO: Herança e reutilização de construtores com `super()`. + +--- + +**Erro 6**: Cálculo de média sem tratamento de casos especiais + +- Descrição: O cálculo `sum(self.notas) / len(self.notas)` assume que `self.notas` não está vazia; quando lista vazia, causa `ZeroDivisionError`. +- Solução parcial/relacionada: implementar verificação antes da divisão (feito na solução final abaixo). +- Conceito POO / Lógica: Validação de estado do objeto e tratamento de exceções. + +--- + +**Erro 7**: Chamada de `calcular_media` com lista de notas vazia + +- Descrição: O teste no final do script chama `estudante.calcular_media()` sem ter adicionado nenhuma nota, resultando em `ZeroDivisionError` no código original. +- Solução: Implementar proteção dentro de `calcular_media` para retornar `0.0` quando `self.notas` estiver vazia. Assim, a chamada é segura e o programa não levanta exceção inesperada. A implementação atual em `Resposta_10.py` é: + +```python + def calcular_media(self): + # Evita divisão por zero quando não há notas registradas + if not self.notas: + return 0.0 + return sum(self.notas) / len(self.notas) +``` + +- Conceito POO / Lógica: Validação de estado do objeto; tratamento de entradas inválidas / ausência de dados. + +--- + +## Observações sobre outras escolhas de design + +- O atributo `__cpf` foi mantido como privado (com double-underscore). Isso aplica name-mangling no Python e é adequado se a intenção for tornar o acesso direto mais difícil. Alternativamente, pode-se usar um único underscore (`_cpf`) ou implementar getters/setters para controlar acesso. +- Ao retornar `0.0` para `calcular_media` quando não há notas, optamos por um comportamento seguro e previsível. Outra alternativa seria lançar uma exceção explícita (`ValueError`) para forçar o chamador a validar a existência de notas antes de pedir a média. A escolha depende do comportamento esperado pela aplicação. + +--- + +## Resultado do teste + +Rodando o script `Resposta_10.py` após as correções, a saída é similar a: + +``` +Olá, sou João +Olá, sou o professor Dr. Silva do departamento Computação +Média do estudante: 0.0 +``` + +Isso indica que o programa não produz exceções ao calcular a média quando não há notas (resultado `0.0`). + +--- + +Arquivos entregues: + +- `Resposta_10.py` (corrigido) +- `Resposta_10.md` (este relatório) diff --git a/Resposta_10.py b/Resposta_10.py index ae3c61b..fb2efb8 100644 --- a/Resposta_10.py +++ b/Resposta_10.py @@ -2,7 +2,7 @@ class Pessoa: def __init__(self, nome, idade): self.nome = nome self.idade = idade - self.__cpf + self.__cpf = None def apresentar(self): return f"Olá, sou {self.nome}" @@ -18,8 +18,10 @@ def adicionar_nota(self, nota): self.notas.append(nota) def calcular_media(self): - return sum(self.notas) / len(self.notas) # Erro 6 - + # Evita divisão por zero quando não há notas registradas + if not self.notas: + return 0.0 + return sum(self.notas) / len(self.notas) class Professor(Pessoa): def __init__(self, nome, idade, departamento, salario): super().__init__(nome, idade) From 88741ac983a7c654904e0b858d5d838e0260555d Mon Sep 17 00:00:00 2001 From: Gabriel Reis Date: Wed, 19 Nov 2025 19:32:31 -0300 Subject: [PATCH 6/7] ex11 - ex20 feito --- exercicio_11.md | 14 ++++++--- exercicio_12.md | 9 ++++-- respExercicio1.py | 0 respExercicio11.py | 27 ++++++++++++++++ respExercicio12.py | 37 ++++++++++++++++++++++ respExercicio13.py | 78 ++++++++++++++++++++++++++++++++++++++++++++++ respExercicio14.py | 74 +++++++++++++++++++++++++++++++++++++++++++ respExercicio15.py | 33 ++++++++++++++++++++ respExercicio16.py | 39 +++++++++++++++++++++++ respExercicio17.py | 47 ++++++++++++++++++++++++++++ respExercicio18.py | 71 +++++++++++++++++++++++++++++++++++++++++ respExercicio19.py | 52 +++++++++++++++++++++++++++++++ respExercicio20.py | 39 +++++++++++++++++++++++ 13 files changed, 514 insertions(+), 6 deletions(-) create mode 100644 respExercicio1.py create mode 100644 respExercicio11.py create mode 100644 respExercicio12.py create mode 100644 respExercicio13.py create mode 100644 respExercicio14.py create mode 100644 respExercicio15.py create mode 100644 respExercicio16.py create mode 100644 respExercicio17.py create mode 100644 respExercicio18.py create mode 100644 respExercicio19.py create mode 100644 respExercicio20.py diff --git a/exercicio_11.md b/exercicio_11.md index 0c649e5..4b826ad 100644 --- a/exercicio_11.md +++ b/exercicio_11.md @@ -1,25 +1,28 @@ # Exercício 11 - Princípio da Responsabilidade Única (SRP) ## Objetivo + Aplicar o primeiro princípio SOLID - Single Responsibility Principle (SRP). ## Descrição do Exercício + Refatore uma classe que viola o SRP, separando suas responsabilidades em classes distintas. ### Código Problemático: + ```python class Funcionario: def __init__(self, nome, salario, cargo): self.nome = nome self.salario = salario self.cargo = cargo - + def calcular_salario_liquido(self, descontos): return self.salario - descontos - + def gerar_relatorio(self): return f"Relatório: {self.nome} - {self.cargo} - R$ {self.salario}" - + def salvar_no_banco(self): print(f"Salvando {self.nome} no banco de dados...") ``` @@ -29,6 +32,7 @@ class Funcionario: 1. **Identifique as responsabilidades** da classe Funcionario (dados, cálculos, relatórios, persistência). 2. **Crie classes separadas** para cada responsabilidade: + - **Funcionario**: apenas dados do funcionário - **CalculadoraSalario**: cálculos relacionados a salário - **GeradorRelatorio**: geração de relatórios @@ -39,9 +43,11 @@ class Funcionario: 4. **Demonstre o uso** das classes refatoradas. ## Entrega + Crie um arquivo chamado `respExercicio11.py` com a implementação refatorada seguindo o SRP. ## Exemplo de Uso + ```python funcionario = Funcionario("Ana Silva", 5000.0, "Desenvolvedora") calculadora = CalculadoraSalario() @@ -51,4 +57,4 @@ repositorio = RepositorioFuncionario() salario_liquido = calculadora.calcular_salario_liquido(funcionario, 500.0) relatorio = gerador.gerar_relatorio(funcionario) repositorio.salvar(funcionario) -``` \ No newline at end of file +``` diff --git a/exercicio_12.md b/exercicio_12.md index 458d300..da2f877 100644 --- a/exercicio_12.md +++ b/exercicio_12.md @@ -1,12 +1,14 @@ # Exercício 12 - Princípio Aberto/Fechado (OCP) ## Objetivo + Aplicar o segundo princípio SOLID - Open/Closed Principle (OCP). ## Descrição do Exercício + Implemente um sistema de cálculo de descontos que seja aberto para extensão mas fechado para modificação. -### Requisitos: +### Requisitos 1. **Crie uma classe abstrata** `CalculadorDesconto` com método abstrato `calcular(valor)`. @@ -20,9 +22,11 @@ Implemente um sistema de cálculo de descontos que seja aberto para extensão ma 4. **Demonstre** como adicionar um novo tipo de desconto sem modificar código existente. ## Entrega + Crie um arquivo chamado `respExercicio12.py` com a implementação seguindo o OCP. ## Exemplo de Uso + ```python from abc import ABC, abstractmethod @@ -42,7 +46,8 @@ print(f"Funcionário: R$ {valor_final2}") ``` ## Exemplo de Saída Esperada + ``` Estudante: R$ 900.0 Funcionário: R$ 850.0 -``` \ No newline at end of file +``` diff --git a/respExercicio1.py b/respExercicio1.py new file mode 100644 index 0000000..e69de29 diff --git a/respExercicio11.py b/respExercicio11.py new file mode 100644 index 0000000..33e3ee6 --- /dev/null +++ b/respExercicio11.py @@ -0,0 +1,27 @@ +class Funcionario: + def __init__(self, nome, salario, cargo): + self.nome = nome + self.salario = salario + self.cargo = cargo + +class CalculadoraSalario: + def calcular_salario_liquido(self, funcionario:Funcionario, descontos): + return funcionario.salario - descontos + +class GeradorRelatorio: + def gerar_relatorio(self, funcionario:Funcionario): + return f"Relatório do Funcionário:\nNome: {funcionario.nome}\nCargo: {funcionario.cargo}\nSalário: {funcionario.salario}" + +class RepositorioFuncionario: + def salvar(self, funcionario:Funcionario): + print(f"Funcionário {funcionario.nome} salvo no repositório.") + +if __name__ == "__main__": + funcionario = Funcionario("Ana Silva", 5000.0, "Desenvolvedora") + calculadora = CalculadoraSalario() + gerador = GeradorRelatorio() + repositorio = RepositorioFuncionario() + + salario_liquido = calculadora.calcular_salario_liquido(funcionario, 500.0) + relatorio = gerador.gerar_relatorio(funcionario) + repositorio.salvar(funcionario) \ No newline at end of file diff --git a/respExercicio12.py b/respExercicio12.py new file mode 100644 index 0000000..ed137b5 --- /dev/null +++ b/respExercicio12.py @@ -0,0 +1,37 @@ +from abc import ABC, abstractmethod + +class CalculadorDesconto(): + @abstractmethod + def aplicar_desconto(self, valor: float) -> float: + pass + +class DescontoEstudante(CalculadorDesconto): + def calcular(self, valor: float) -> float: + return valor * 0.9 # 20% de desconto para estudantes + +class DescontoFuncionario(CalculadorDesconto): + def calcular(self, valor: float) -> float: + return valor * 0.85 # 15% de desconto para funcionários + +class DescontoVIP(CalculadorDesconto): + def calcular(self, valor: float) -> float: + return valor * 0.8 # 20% de desconto para clientes VIP + +class ProcessadorPagamento: + def processar(self, valor: float, estrategia_desconto) -> float: + return estrategia_desconto.calcular(valor) + +# Uso do sistema +pagamento = ProcessadorPagamento() +valor_original = 1000.0 + +# Diferentes tipos de desconto +desconto_estudante = DescontoEstudante() +desconto_funcionario = DescontoFuncionario() + + +valor_final1 = pagamento.processar(valor_original, desconto_estudante) +valor_final2 = pagamento.processar(valor_original, desconto_funcionario) + +print(f"Estudante: R$ {valor_final1}") +print(f"Funcionário: R$ {valor_final2}") \ No newline at end of file diff --git a/respExercicio13.py b/respExercicio13.py new file mode 100644 index 0000000..469ba2a --- /dev/null +++ b/respExercicio13.py @@ -0,0 +1,78 @@ +from abc import ABC +from abc import abstractmethod + +class Veiculo(ABC): + @abstractmethod + def acelerar(self): + pass + + @abstractmethod + def frear(self): + pass + + @abstractmethod + def get_velocidade(self): + pass + +class Carro(Veiculo): + def __init__(self): + self.velocidade = 0 + + def acelerar(self): + self.velocidade += 10 + + def frear(self): + self.velocidade -= 10 + if self.velocidade < 0: + self.velocidade = 0 + + def get_velocidade(self): + return self.velocidade + +class Bicicleta(Veiculo): + def __init__(self): + self.velocidade = 0 + + def acelerar(self): + self.velocidade += 5 + + def frear(self): + self.velocidade -= 5 + if self.velocidade < 0: + self.velocidade = 0 + + def get_velocidade(self): + return self.velocidade + +class Aviao(Veiculo): + def __init__(self): + self.velocidade = 0 + + def acelerar(self): + self.velocidade += 50 + + def frear(self): + self.velocidade -= 50 + if self.velocidade < 0: + self.velocidade = 0 + + def get_velocidade(self): + return self.velocidade + + +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 +carro = Carro() +bicicleta = Bicicleta() +aviao = Aviao() + +testar_veiculo(carro) +testar_veiculo(bicicleta) +testar_veiculo(aviao) \ No newline at end of file diff --git a/respExercicio14.py b/respExercicio14.py new file mode 100644 index 0000000..ec6999a --- /dev/null +++ b/respExercicio14.py @@ -0,0 +1,74 @@ +from abc import ABC, abstractmethod + +# Classe Abstrata +class Trabalhavel(ABC): + def __init__(self, nome): + self.nome = nome + + @abstractmethod + def trabalhar(self): + pass + +class Alimentavel(ABC): + @abstractmethod + def comer(self): + pass + +class Programavel(ABC): + @abstractmethod + def programar(self): + pass + +class Descansavel(ABC): + @abstractmethod + def dormir(self): + pass + + +# Classe Específica +class Desenvolvedor(Trabalhavel, Alimentavel, Programavel, Descansavel): + def trabalhar(self): + print(f"{self.nome} está trabalhando.") + + def comer(self): + print(f"{self.nome} está comendo.") + + def programar(self): + print(f"{self.nome} está programando.") + + def dormir(self): + print(f"{self.nome} está dormindo.") + +class Gerente(Trabalhavel, Alimentavel, Descansavel): + def trabalhar(self): + print(f"{self.nome} está gerenciando.") + + def comer(self): + print(f"{self.nome} está comendo.") + + def dormir(self): + print(f"{self.nome} está dormindo.") + +class Robo(Trabalhavel, Programavel): + def trabalhar(self): + print(f"{self.nome} está trabalhando.") + + def programar(self): + print(f"{self.nome} está programando.") + +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 diff --git a/respExercicio15.py b/respExercicio15.py new file mode 100644 index 0000000..d04fd34 --- /dev/null +++ b/respExercicio15.py @@ -0,0 +1,33 @@ +class NotificacaoService: + def __init__(self, metodo_notificacao): + self.metodo_notificacao = metodo_notificacao + + def notificar(self, mensagem): + self.metodo_notificacao.enviar(mensagem) + +class EmailService: + def enviar(self, mensagem): + print(f"Enviando email com a mensagem: {mensagem}") + +class SMSService: + def enviar(self, mensagem): + print(f"Enviando SMS com a mensagem: {mensagem}") + +class PushService: + def enviar(self, mensagem): + print(f"Enviando notificação push com a mensagem: {mensagem}") + +# Diferentes implementações podem ser injetadas +email_service = EmailService() +sms_service = SMSService() +push_service = PushService() + +# Mesmo código cliente funciona com qualquer implementação +notificador1 = NotificacaoService(email_service) +notificador2 = NotificacaoService(sms_service) +notificador3 = NotificacaoService(push_service) + +mensagem = "Bem-vindo ao sistema!" +notificador1.notificar(mensagem) +notificador2.notificar(mensagem) +notificador3.notificar(mensagem) \ No newline at end of file diff --git a/respExercicio16.py b/respExercicio16.py new file mode 100644 index 0000000..5e6465e --- /dev/null +++ b/respExercicio16.py @@ -0,0 +1,39 @@ +class ProcessadorPagamento: + def processar_pagamento(self, valor, conta): + raise NotImplementedError("Este método deve ser implementado pelas subclasses.") + +class ProcessadorPagamentoInterno(ProcessadorPagamento): + def processar_pagamento(self, valor, conta): + print(f"Processando pagamento interno de R${valor} para a conta {conta}.") + +class PayPalAPI: + def make_payment(self, amount, credit_card_number): + return f"PayPal: Processando ${amount} no cartão {credit_card_number}" + +class PayPalAdapter(ProcessadorPagamento): + def __init__(self, paypal_api): + self.paypal_api = paypal_api + + def processar_pagamento(self, valor, conta): + resultado = self.paypal_api.make_payment(valor, conta) + print(resultado) + +class SistemaPagamento: + def __init__(self, processador: ProcessadorPagamento): + self.processador = processador + + def realizar_pagamento(self, valor, conta): + self.processador.processar_pagamento(valor, conta) + +# Sistema funciona com interface padrão +processador_interno = ProcessadorPagamentoInterno() +sistema1 = SistemaPagamento(processador_interno) + +# Adapter permite usar PayPal com a mesma interface +paypal_api = PayPalAPI() +paypal_adapter = PayPalAdapter(paypal_api) +sistema2 = SistemaPagamento(paypal_adapter) + +# Ambos funcionam da mesma forma +sistema1.realizar_pagamento(100.0, "1234-5678") +sistema2.realizar_pagamento(200.0, "8765-4321") \ No newline at end of file diff --git a/respExercicio17.py b/respExercicio17.py new file mode 100644 index 0000000..8fcfd42 --- /dev/null +++ b/respExercicio17.py @@ -0,0 +1,47 @@ +class Bebida: + def __init__(self, descricao, preco): + self.descricao = descricao + self.preco = preco + def get_descricao(self): + return self.descricao + def get_preco(self): + return self.preco + +# Decorator base +class Cafe(Bebida): + def __init__(self): + super().__init__("Café", 5.0) + +class Cha(Bebida): + def __init__(self): + super().__init__("Chá", 4.0) + +# Decorator com decorators +class LeiteDecorator(Bebida): + def __init__(self, bebida): + descricao = bebida.get_descricao() + ", Leite" + preco = bebida.get_preco() + 1.5 + super().__init__(descricao, preco) + +class AcucarDecorator(Bebida): + def __init__(self, bebida): + descricao = bebida.get_descricao() + ", Açúcar" + preco = bebida.get_preco() + 0.5 + super().__init__(descricao, preco) + +class ChantillyDecorator(Bebida): + def __init__(self, bebida): + descricao = bebida.get_descricao() + ", Chantilly" + preco = bebida.get_preco() + 2.0 + super().__init__(descricao, preco) +# Bebida simples +cafe = Cafe() +print(f"{cafe.get_descricao()} - R$ {cafe.get_preco()}") + +# Bebida com decorators +cafe_com_leite = LeiteDecorator(cafe) +print(f"{cafe_com_leite.get_descricao()} - R$ {cafe_com_leite.get_preco()}") + +# Múltiplos decorators +cafe_especial = ChantillyDecorator(AcucarDecorator(LeiteDecorator(Cafe()))) +print(f"{cafe_especial.get_descricao()} - R$ {cafe_especial.get_preco()}") \ No newline at end of file diff --git a/respExercicio18.py b/respExercicio18.py new file mode 100644 index 0000000..f1af9e2 --- /dev/null +++ b/respExercicio18.py @@ -0,0 +1,71 @@ +class LigarFuncao: + def __init__(self, nome): + self.nome = nome + + def ligar(self): + print(f"Ligando {self.nome}...") + +class Amplificador(LigarFuncao): + def __init__(self): + super().__init__("Amplificador") + + def definir_volume(self, volume): + print(f"Definindo volume do Amplificador para {volume}.") + +class DVDPlayer(LigarFuncao): + def __init__(self): + super().__init__("DVD Player") + + def reproduzir(self, filme): + print(f"Reproduzindo filme: {filme}.") + +class Projetor(LigarFuncao): + def __init__(self): + super().__init__("Projetor") + + def modo_widescreen(self): + print("Configurando Projetor para modo widescreen.") + +class Luzes(LigarFuncao): + def __init__(self): + super().__init__("Luzes") + + def diminuir(self, nivel): + print(f"Diminuindo luzes para o nível {nivel}.") + +class PipocaPopper(LigarFuncao): + def __init__(self): + super().__init__("Pipoca Popper") + + def fazer_pipoca(self): + print("Fazendo pipoca.") + +class HomeTheaterFacade: + def __init__(self): + self.amplificador = Amplificador() + self.dvd_player = DVDPlayer() + self.projetor = Projetor() + self.luzes = Luzes() + self.pipoca_popper = PipocaPopper() + + def assistir_filme(self, filme): + print("Preparando para assistir ao filme...") + self.pipoca_popper.ligar() + self.pipoca_popper.fazer_pipoca() + self.luzes.diminuir(10) + self.projetor.ligar() + self.projetor.modo_widescreen() + self.amplificador.ligar() + self.amplificador.definir_volume(5) + self.dvd_player.ligar() + self.dvd_player.reproduzir(filme) + print("Aproveite o filme!") + + def fim_filme(self): + print("Desligando o Home Theater...") + print("Home Theater desligado.") + +# Usando o sistema diretamente +home_theater = HomeTheaterFacade() +home_theater.assistir_filme("Inception") +home_theater.fim_filme() \ No newline at end of file diff --git a/respExercicio19.py b/respExercicio19.py new file mode 100644 index 0000000..4478f96 --- /dev/null +++ b/respExercicio19.py @@ -0,0 +1,52 @@ +class Observer: + def update(self, temperature, humidity, pressure): + pass + +class EstacaoMeteorologica: + def __init__(self): + self.observers = [] + self.temperature = 0 + self.humidity = 0 + self.pressure = 0 + + def register_observer(self, observer): + self.observers.append(observer) + + def remove_observer(self, observer): + self.observers.remove(observer) + + def notify_observers(self): + for observer in self.observers: + observer.update(self.temperature, self.humidity, self.pressure) + + def set_measurements(self, temperature, humidity, pressure): + self.temperature = temperature + self.humidity = humidity + self.pressure = pressure + self.notify_observers() + +class DisplayTemperatura(Observer): + def update(self, temperature, humidity, pressure): + print(f"Temperatura Atual: {temperature}°C") + +class DisplayUmidade(Observer): + def update(self, temperature, humidity, pressure): + print(f"Umidade Atual: {humidity}%") + +class DisplayCompleto(Observer): + def update(self, temperature, humidity, pressure): + print(f"Temperatura: {temperature}°C, Umidade: {humidity}%, Pressão: {pressure} hPa") + +if __name__ == "__main__": + estacao = EstacaoMeteorologica() + + display_temp = DisplayTemperatura() + display_umid = DisplayUmidade() + display_completo = DisplayCompleto() + + estacao.register_observer(display_temp) + estacao.register_observer(display_umid) + estacao.register_observer(display_completo) + + estacao.set_measurements(25, 65, 1013) + estacao.set_measurements(28, 70, 1012) \ No newline at end of file diff --git a/respExercicio20.py b/respExercicio20.py new file mode 100644 index 0000000..3652396 --- /dev/null +++ b/respExercicio20.py @@ -0,0 +1,39 @@ +class EstrategiaFrete: + def calcular_frete(self, peso, distancia): + raise NotImplementedError("Este método deve ser implementado pelas subclasses.") + +class FreteNormal(EstrategiaFrete): + def calcular_frete(self, peso, distancia): + return (peso * 2) + (distancia * 0.1) + 5 # Exemplo de cálculo para frete normal + +class FreteExpresso(EstrategiaFrete): + def calcular_frete(self, peso, distancia): + return (peso * 3) + (distancia * 0.2) + 15 # Exemplo de cálculo para frete expresso + +class FreteEconomico(EstrategiaFrete): + def calcular_frete(self, peso, distancia): + return (peso * 1.0) + (distancia * 0.05) + 2 # Exemplo de cálculo para frete econômico + +class CalculadoraFrete: + def __init__(self, estrategia: EstrategiaFrete): + self.estrategia = estrategia + + def definir_estrategia(self, estrategia: EstrategiaFrete): + self.estrategia = estrategia + + def calcular(self, peso, distancia): + return self.estrategia.calcular_frete(peso, distancia) + +# Exemplo de uso +if __name__ == "__main__": + peso = 10 # em kg + distancia = 100 # em km + + calculadora = CalculadoraFrete(FreteNormal()) + print("Frete Normal: R$ ", calculadora.calcular(peso, distancia)) + + calculadora.definir_estrategia(FreteExpresso()) + print("Frete Expresso: R$ ", calculadora.calcular(peso, distancia)) + + calculadora.definir_estrategia(FreteEconomico()) + print("Frete Econômico: R$ ", calculadora.calcular(peso, distancia)) \ No newline at end of file From 42b28d23d3f68a4675288a6c18e3a38a7d976263 Mon Sep 17 00:00:00 2001 From: Gabriel Reis Date: Wed, 19 Nov 2025 20:28:31 -0300 Subject: [PATCH 7/7] =?UTF-8?q?corre=C3=A7=C3=A3o=20ex10?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Resposta_10.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Resposta_10.py b/Resposta_10.py index fb2efb8..352005c 100644 --- a/Resposta_10.py +++ b/Resposta_10.py @@ -2,7 +2,6 @@ class Pessoa: def __init__(self, nome, idade): self.nome = nome self.idade = idade - self.__cpf = None def apresentar(self): return f"Olá, sou {self.nome}" @@ -37,4 +36,8 @@ def apresentar(self): print(estudante.apresentar()) print(professor.apresentar()) + +estudante.adicionar_nota(8) +estudante.adicionar_nota(7) + print(f"Média do estudante: {estudante.calcular_media()}") # Erro 7 \ No newline at end of file