diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..54ac0fd --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,15 @@ +{ + "python.analysis.autoImportCompletions": true, + "python.analysis.completeFunctionParens": true, + "python.analysis.supportAllPythonDocuments": true, + "python.analysis.diagnosticMode": "workspace", + "python.analysis.indexing": true, + "python.analysis.autoSearchPaths": true, + "python.analysis.extraPaths": ["."], + "editor.quickSuggestions": { + "other": true, + "comments": false, + "strings": false +}, +"editor.definitionLinkOpensInPeek": false +} diff --git a/Resposta_10.md b/Resposta_10.md new file mode 100644 index 0000000..edeac49 --- /dev/null +++ b/Resposta_10.md @@ -0,0 +1,42 @@ +Erro 1 = Nome da classe pessoa minúscula +Problema: classes em Py devem seguir a conversão CamelCase +Solução: Alterado para clss Pessoa +Conceito: Convenção e boas praticas de POO + +Erro 2 = Pendente Self. (atributo nome não sendo iniciado corretamente) +Problema: Dentro do `__init__`, estava escrito `nome = nome`, não atribuindo valor ao objeto. +Solução: Inserido self.nome = nome +Conceito: Encapsulado e inicialização correta de atributos + +Erro 3 = Atributo privado contribuindo para falha futura +Problema: self._cpf = None estava correto, mas poderia causar confusão sem getter/setter +Solução:Mantido (não é erro de fato). Apenas confirmamos sua funcionalidade. +Conceito: Encapsulamento + +Erro 4 = Metodo apresentar() sem parametro self +Problema: Definido como def apresentar () +Solução: Corrigido para `def apresentar(self) +Conceito: Metodo de instância + +Erro 5 = Classe Estudante não chamando o construtor da classe mãe +Problema: Estava redefinindo `self.nome = nome` diretamente +Solução: Usado `super().__init__(nome, idade) +Conceito: Herança e uso correto de `super() + +Erro 6 = Divisão por zero na média +Problema: sum(self.notas) / len(self.notas)` causa erro se a lista estiver vazia. +Solução:Adicionada verificação: + +if len(self.notas) == 0: + return 0 + +Conceito: + +Erro 7 = Média sendo calculada sem adicionar notas antes +Problema: No teste, chamava calcular_media() sem adicionar nenhuma nota. +Solução: Notas foram adicionadas antes da chamada e também implementada proteção no método. +Conceito: Lógica do programa e integridade dos dados. + + + + diff --git a/Resposta_10.py b/Resposta_10.py new file mode 100644 index 0000000..5c5c048 --- /dev/null +++ b/Resposta_10.py @@ -0,0 +1,48 @@ +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}" + + +class Estudante(Pessoa): + def __init__(self, nome, idade, curso): + super().__init__(nome, idade) + self.curso = curso + self.notas = [] + + def adicionar_nota(self, nota): + if 0 <= nota <= 10: + self.notas.append(nota) + + def calcular_media(self): + if len(self.notas) == 0: + return 0 + return sum(self.notas) / len(self.notas) + + +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"Ola, sou o professor {self.nome} do departamento {self.departamento}" + + +if __name__ == "__main__": + estudante = Estudante("Joao", 20, "Engenharia") + professor = Professor("Dr. Silva", 45, "Computacao", 8000) + + print(estudante.apresentar()) + print(professor.apresentar()) + + estudante.adicionar_nota(8) + estudante.adicionar_nota(10) + + print(f"Média do estudante: {estudante.calcular_media()}") + print(f"Salário do professor: {professor.salario}") diff --git a/respExercicio01.py b/respExercicio01.py new file mode 100644 index 0000000..063d8e6 --- /dev/null +++ b/respExercicio01.py @@ -0,0 +1,26 @@ +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 + + +# Exemplos de uso +Aluno1 = Aluno("Joao Silva", "2023001", "Engenharia de Software") +Aluno2 = Aluno("Maria Santos", "2023002", "Ciencia da Computacao") + +Disciplina1 = Disciplina("Programação Orientada a Objetos", "POO101", 60) +Disciplina2 = Disciplina("Estruturas de Dados", "ED202", 45) + +print(f"Aluno: {Aluno1.nome}, Matrícula: {Aluno1.matricula}, Curso: {Aluno1.curso}") +print(f"Aluno: {Aluno2.nome}, Matrícula: {Aluno2.matricula}, Curso: {Aluno2.curso}") + +print(f"Disciplina: {Disciplina1.nome}, Código: {Disciplina1.codigo}, Carga Horaria: {Disciplina1.carga_horaria} horas") +print(f"Disciplina: {Disciplina2.nome}, Código: {Disciplina2.codigo}, Carga Horaria: {Disciplina2.carga_horaria} horas") diff --git a/respExercicio02.py b/respExercicio02.py new file mode 100644 index 0000000..2865343 --- /dev/null +++ b/respExercicio02.py @@ -0,0 +1,40 @@ +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.notas = [] + + 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" + elif media >= 5: + return "Recuperação" + else: + return "Reprovado" + +alunoTeste = Aluno("Carlos Silva", "2023003", "Matemática") +alunoTeste.adicionar_nota(8) +alunoTeste.adicionar_nota(7) +alunoTeste.adicionar_nota(9) +print(f"Média: {alunoTeste.calcular_media()}") +print(f"Status: {alunoTeste.status()}") + + + + + + + + + + diff --git a/respExercicio03.py b/respExercicio03.py new file mode 100644 index 0000000..84ec28d --- /dev/null +++ b/respExercicio03.py @@ -0,0 +1,32 @@ +class Professor: + def __init__(self, nome: str, departamento: str, salario: float): + self.nome = nome + self.departamento = departamento + self._salario = salario # atributo privado + + @property + def salario(self): + return self._salario + + @salario.setter + def salario(self, novo_valor): + if novo_valor > 0: + self._salario = novo_valor + else: + print("Erro: Salário deve ser um valor positivo!") + + def exibir_informacoes(self): + return f"Professor: {self.nome}, Departamento: {self.departamento}, Salário: R$ {self._salario:.2f}" + +if __name__ == "__main__": + professor = Professor("Dr. Silva", "Computacao", 5000.00) + print(f"salario atual: {professor.salario}") + professor.salario = 6000.00 + print(f"novo salario: {professor.salario}") + professor.salario = -1000.00 + print(f"salario apos tentativa invalida: {professor.salario}") + + + + + \ No newline at end of file diff --git a/respExercicio04.py b/respExercicio04.py new file mode 100644 index 0000000..df837dc --- /dev/null +++ b/respExercicio04.py @@ -0,0 +1,39 @@ +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}, meu CPF é {self.cpf}" + + +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} e eu trabalho no cargo de {self.cargo}." + + +class Professor(Pessoa): + def __init__(self, nome, cpf, data_nascimento, departamento): + super().__init__(nome, cpf, data_nascimento) + self.departamento = departamento + + def apresentar(self): + return f"Olá, meu nome é {self.nome}, sou professor no departamento de {self.departamento}." + + +class Tutor(Professor): + def __init__(self, nome, cpf, data_nascimento, area_atuacao): + # o teste espera isso: departamento NÃO é pedido + super().__init__(nome, cpf, data_nascimento, departamento="Tutoria") + self.area_atuacao = area_atuacao + + def apresentar(self): + return ( + f"Olá, meu nome é {self.nome}, sou tutor na área de {self.area_atuacao} " + f"e pertenço ao departamento de {self.departamento}." + ) diff --git a/respExercicio05.py b/respExercicio05.py new file mode 100644 index 0000000..1535cdf --- /dev/null +++ b/respExercicio05.py @@ -0,0 +1,36 @@ +class Pessoa: + def __init__(self, nome, cpf, data_nascimento): # def = criar + self.nome = nome + self.cpf = cpf + self.data_nascimento = 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 exibir_dados(self): + print("=== Dados do Funcionário ===") + print(f"Nome: {self.nome}") + print(f"CPF: {self.cpf}") + print(f"Data de Nascimento: {self.data_nascimento}") + print(f"Cargo: {self.cargo}") + print(f"Salário: R$ {self.salario:.2f}") +if __name__ == "__main__": + funcionario = Funcionario( + "Ana Costa", + "111.222.333-44", + "20/03/1988", + "Coordenadora", + 4500.0) + funcionario.exibir_dados() + + + + + + + + \ No newline at end of file diff --git a/respExercicio06.py b/respExercicio06.py new file mode 100644 index 0000000..ca0797d --- /dev/null +++ b/respExercicio06.py @@ -0,0 +1,40 @@ +class Disciplina: + def __init__(self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = 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("Disciplinas do curso:") + for d in self.disciplinas: + print(f"- {d.nome} (Código: {d.codigo})") + + def carga_horaria_total(self): + total = 0 + for d in self.disciplinas: + total += d.carga_horaria + return total + +if __name__ == "__main__": + curso = Curso("Engenharia de Software", "ES001") + disciplina1 = Disciplina("Programação Orientada a Objetos", "POO001", 60) + disciplina2 = Disciplina("Banco de Dados", "BD001", 80) + + curso.adicionar_disciplina(disciplina1) + curso.adicionar_disciplina(disciplina2) + curso.listar_disciplinas() + 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..444d355 --- /dev/null +++ b/respExercicio07.py @@ -0,0 +1,54 @@ + +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.disciplinas_inscritas = [] + + def listar_disciplinas(self): + print(f"=== Disciplinas inscritas do aluno {self.nome}:===") + if not self.disciplinas_inscritas: + print("Nenhuma disciplina inscrita.") + else: + for d in self.disciplinas_inscritas: + print(f"- {d.nome_disciplina} (Código: {d.codigo_disciplina})") + print() + +class Disciplina: + def __init__(self, nome_disciplina, codigo_disciplina, carga_horaria): + self.nome_disciplina = nome_disciplina + self.codigo_disciplina = codigo_disciplina + self.carga_horaria = carga_horaria + self.alunos_matriculados = [] + + def listar_alunos(self): + print(f"===Alunos matriculados na disciplina {self.nome_disciplina}:===") + if not self.alunos_matriculados: + print("Nenhum aluno matriculado.") + else: + for a in self.alunos_matriculados: + print(f"- {a.nome} (Matrícula: {a.matricula})") + print() + +class Secretaria: + @staticmethod + def inscrever_aluno(aluno, disciplina): + if disciplina not in aluno.disciplinas_inscritas: + aluno.disciplinas_inscritas.append(disciplina) + if aluno not in disciplina.alunos_matriculados: + disciplina.alunos_matriculados.append(aluno) + +if __name__ == "__main__": #executa o código + + 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) + + Secretaria.inscrever_aluno(aluno1, disciplina1) + Secretaria.inscrever_aluno(aluno1, disciplina2) + Secretaria.inscrever_aluno(aluno2, disciplina1) + + aluno1.listar_disciplinas() + disciplina1.listar_alunos() \ No newline at end of file diff --git a/respExercicio08.py b/respExercicio08.py new file mode 100644 index 0000000..9e8dd41 --- /dev/null +++ b/respExercicio08.py @@ -0,0 +1,47 @@ +class Departamento: + def __init__(self, nome, sigla): + self.nome = nome + self.sigla = sigla + self.professores = [] + + + @classmethod + def criar_departamento_exatas(cls, nome): + return cls(nome, "EXA") + + @classmethod + def criar_departamento_humanas(cls, nome): + return cls(nome, "HUM") + + def adicionar_professor(self, professor): + self.professores.append(professor) + + def listar_professores(self): + print(f"=== Professores do departamento {self.nome}: ===") + for p in self.professores: + print(f"- {p}") + + + + + + + +if __name__ == "__main__": + depto_exatas = Departamento.criar_departamento_exatas("Matemática e Computação") + depto_humanas = Departamento.criar_departamento_humanas("Letras e Filosofia") + + print(f"Departamento: {depto_exatas.nome}, Sigla: {depto_exatas.sigla}") + print(f"Departamento: {depto_humanas.nome}, Sigla: {depto_humanas.sigla}") + + depto_exatas.adicionar_professor("João Silva") + depto_exatas.adicionar_professor("Ana Costa") + + depto_exatas.listar_professores() + + + + + + + \ No newline at end of file diff --git a/respExercicio09.py b/respExercicio09.py new file mode 100644 index 0000000..e91632a --- /dev/null +++ b/respExercicio09.py @@ -0,0 +1,64 @@ +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + + def apresentar(self): + return ( + f"Olá, meu nome é {self.nome}, " + f"sou aluno do curso de {self.curso} " + f"e minha matrícula é {self.matricula}." + ) + + +class Professor: + def __init__(self, nome, departamento, salario): + self.nome = nome + self.departamento = departamento + self.salario = salario + + def apresentar(self): + return ( + f"Olá, meu nome é {self.nome}, " + f"sou professor e trabalho no departamento de {self.departamento}." + ) + + +class Funcionario: + def __init__(self, nome, cpf, data_nascimento, setor, salario): + self.nome = nome + self.cpf = cpf + self.data_nascimento = data_nascimento + self.setor = setor + self.salario = salario + + def apresentar(self): + return ( + f"Olá, meu nome é {self.nome}, " + f"sou funcionário e trabalho no setor de {self.setor}." + ) + + +# Demonstração de polimorfismo +if __name__ == "__main__": + 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", "Secretaria", 3000.0) + ] + + for pessoa in pessoas: + print(pessoa.apresentar()) + + +#dúvidas????? + +#aluno = aluno("João Silva", "2023001", "Engenharia de Software") +#professor = professor("Dr. Maria", "Computação") +#funcionario = funcionario("Carlos Santos", "Recursos Humanos") + + # apresentações +#print(aluno.apresentar()) +#print(professor.apresentar()) +#print(funcionario.apresentar()) \ No newline at end of file diff --git a/respExercicio11.py b/respExercicio11.py new file mode 100644 index 0000000..266fcc2 --- /dev/null +++ b/respExercicio11.py @@ -0,0 +1,31 @@ +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, descontos): + return funcionario.salario - descontos + +class GeradorRelatorio: + def gerar_relatorio(self, funcionario): + return f"Relatório: {funcionario.nome} - {funcionario.cargo} - R$ {funcionario.salario}" + +class RepositorioFuncionario: + def salvar(self, funcionario): + print(f"Salvando {funcionario.nome} no banco de dados...") + + +if __name__ == "__main__": + + calculadora = CalculadoraSalario() + gerador = GeradorRelatorio() + repositorio = RepositorioFuncionario() + funcionario = Funcionario("Ana Silva", 5000, "Desenvolvedor") + + salario_liquido = calculadora.calcular_salario_liquido(funcionario, 500) + relatorio = gerador.gerar_relatorio(funcionario) + repositorio.salvar(funcionario) + print(relatorio) + diff --git a/respExercicio12.py b/respExercicio12.py new file mode 100644 index 0000000..d76f2bc --- /dev/null +++ b/respExercicio12.py @@ -0,0 +1,42 @@ +from abc import ABC, abstractmethod + +class CalculadorDesconto(ABC): + @abstractmethod + def calcular(self, valor): + pass + + +class DescontoEstudante(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.90 # 10% + + +class DescontoFuncionario(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.85 # 15% + + +class DescontoVIP(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.80 # 20% + + +class ProcessadorPagamento: + def processar(self, valor, estrategia: CalculadorDesconto): + return estrategia.calcular(valor) + + +# Demonstração de extensão sem modificar código existente +class DescontoNetshoes(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.75 # 25% + + +if __name__ == "__main__": + pagamento = ProcessadorPagamento() + valor_original = 1000.0 + + print("Estudante:", pagamento.processar(valor_original, DescontoEstudante())) + print("Funcionário:", pagamento.processar(valor_original, DescontoFuncionario())) + print("VIP:", pagamento.processar(valor_original, DescontoVIP())) + print("Netshoes:", pagamento.processar(valor_original, DescontoNetshoes())) diff --git a/respExercicio13.py b/respExercicio13.py new file mode 100644 index 0000000..517f191 --- /dev/null +++ b/respExercicio13.py @@ -0,0 +1,58 @@ +# SOLID - Liskov Substitution Principle (LSP) + +# SOLID - Liskov Substitution Principle (LSP) + +class Veiculo: + def __init__(self, velocidade_maxima): + self.velocidade = 0 + self.velocidade_maxima = velocidade_maxima + + def acelerar(self): + if self.velocidade + 20 <= self.velocidade_maxima: + self.velocidade += 20 + + def frear(self): + if self.velocidade - 10 >= 0: + self.velocidade -= 10 + + def get_velocidade(self): + return self.velocidade + + +class Carro(Veiculo): + def __init__(self): + super().__init__(180) + + +class Bicicleta(Veiculo): + def __init__(self): + super().__init__(50) + + +class Aviao(Veiculo): + def __init__(self): + super().__init__(900) + + +class ControladorTrafego: + def testar_veiculo(self, 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") + + +if __name__ == "__main__": + + controlador = ControladorTrafego() + + carro = Carro() + bicicleta = Bicicleta() + aviao = Aviao() + + controlador.testar_veiculo(carro) + controlador.testar_veiculo(bicicleta) + controlador.testar_veiculo(aviao) + diff --git a/respExercicio14.py b/respExercicio14.py new file mode 100644 index 0000000..53162a1 --- /dev/null +++ b/respExercicio14.py @@ -0,0 +1,96 @@ +# Exercício 14 - Princípio da Segregação de Interface (ISP) + +## Objetivo +#Aplicar o quarto princípio SOLID - Interface Segregation Principle (ISP). + +## Descrição do Exercício +#Refatore interfaces "gordas" em interfaces menores e mais específicas. + +from abc import ABC, abstractmethod + +# Interfaces pequenas e 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 como desenvolvedora.") + + 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 como gerente.") + + 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, id_robo): + self.id_robo = id_robo + + def trabalhar(self): + print(f"Robo {self.id_robo} está executando tarefas.") + + def programar(self): + print(f"Robo {self.id_robo} está executando código.") + + # Demonstração de uso ---------------------- +if __name__ == "__main__": + + desenvolvedor = Desenvolvedor("Ana") + gerente = Gerente("Carlos") + robo = Robo("R202") + + print("----- Desenvolvedor -----") + desenvolvedor.trabalhar() + desenvolvedor.comer() + desenvolvedor.dormir() + desenvolvedor.programar() + + print("\n----- Gerente -----") + gerente.trabalhar() + gerente.comer() + gerente.dormir() + + print("\n----- Robo -----") + robo.trabalhar() + robo.programar() + + \ No newline at end of file diff --git a/respExercicio15.py b/respExercicio15.py new file mode 100644 index 0000000..221a4f2 --- /dev/null +++ b/respExercicio15.py @@ -0,0 +1,56 @@ +# Exercício 15 - Princípio da Inversão de Dependência (DIP) + +## Objetivo +#Aplicar o quinto princípio SOLID - Dependency Inversion Principle (DIP). + +## Descrição do Exercício +#Refatore código que depende de implementações concretas para depender de abstrações. + + +from abc import ABC, abstractmethod + + +#abstração +class ServicoNotificacao(ABC): + @abstractmethod + def enviar (self, mensagem): + pass + + #concretas + +class EmailService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando email com a mensagem: {mensagem}") + +class SMSService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando SMS com a mensagem: {mensagem}") + +class PushService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando notificação push com a mensagem: {mensagem}") + +#Alta camada de depende da abstraçã, não da implementação concreta + +class NotificadorService: + def __init__(self, servico: ServicoNotificacao): + self.servico = servico #injeção de dependência + + def notificar(self, mensagem): + self.servico.enviar(mensagem) + + #demonstração +if __name__ == "__main__": + email_service = EmailService() + sms_service = SMSService() + push_service = PushService() + + notificador_email = NotificadorService(email_service) + notificador_sms = NotificadorService(sms_service) + notificador_push = NotificadorService(push_service) + + mensagem = "Bem-vindo ao sistema!" + + notificador_email.notificar(mensagem) + notificador_sms.notificar(mensagem) + notificador_push.notificar(mensagem) diff --git a/respExercicio16.py b/respExercicio16.py new file mode 100644 index 0000000..1244999 --- /dev/null +++ b/respExercicio16.py @@ -0,0 +1,51 @@ +class ProcessadorPagamento: + def processar_pagamento(self, valor, cartao): + pass +class PayPalAPI: + def make_payment(self, amount, credit_card_number): + return f"PayPal: Processando ${amount} no cartão {credit_card_number}" + + #crie o adaptador +class PayPalAdapter(ProcessadorPagamento): + def __init__(self, paypal_api): + self.paypal_api = paypal_api + + def processar_pagamento(self, valor, cartao): + return self.paypal_api.make_payment(valor, cartao) + +#Processador de pagamento interno (exemplo) + +class ProcessadorPagamentoInterno(ProcessadorPagamento): + def processar_pagamento(self, valor, cartao): + return f"Sistema Interno: Processando ${valor} no cartão {cartao}" + +#qualquer processador de pagamento pode ser usado aqui +class SistemaPagamento: + def __init__(self, processador: ProcessadorPagamento): + self.processador = processador + + def realizar_pagamento(self, valor, cartao): + resultado = self.processador.processar_pagamento(valor, cartao) + print(resultado) + +if __name__ == "__main__": + +#uso +# 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") + + + + diff --git a/respExercicio17.py b/respExercicio17.py new file mode 100644 index 0000000..f1eb4bb --- /dev/null +++ b/respExercicio17.py @@ -0,0 +1,82 @@ +#Padrão Decorator (Estrutural) +#Crie um sistema de bebidas onde você pode adicionar ingredientes extras usando decorators. + +class Bebida: + def get_descricao(self): + return self.descricao() + pass + + def get_preco(self): + pass + +class Cafe(Bebida): + def get_descricao(self): + return "Café" + + def get_preco(self): + return 5.00 + +class Cha(Bebida): + def get_descricao(self): + return "Chá" + + def get_preco(self): + return 3.00 + + + #decorator base +class BebidaDecorator(Bebida): + def __init__(self, bebida: Bebida): + self.bebida = bebida + + def get_descricao(self): + return self.bebida.get_descricao() + + def get_preco(self): + return self.bebida.get_preco() + + + #decorators concretos +class Leite(BebidaDecorator): + def get_descricao(self): + return self.bebida.get_descricao() + ", com Leite" + + def get_preco(self): + return self.bebida.get_preco() + 2.00 + +class Acucar(BebidaDecorator): + def get_descricao(self): + return self.bebida.get_descricao() + " com Açúcar" + + def get_preco(self): + return self.bebida.get_preco() + 0.50 + +class Chantilly(BebidaDecorator): + def get_descricao(self): + return self.bebida.get_descricao() + " com Chantilly" + + def get_preco(self): + return self.bebida.get_preco() + 3.00 + + #demostração de uso + +if __name__ == "__main__": + + # Bebida simples + cafe = Cafe() + print(f"{cafe.get_descricao()} - R$ {cafe.get_preco():.2f}") + + # Bebida com decorators + cafe_com_leite = Leite(cafe) + print(f"{cafe_com_leite.get_descricao()} - R$ {cafe_com_leite.get_preco():.2f}") + + # Múltiplos decorators + cafe_especial = Chantilly(Acucar(Leite(Cafe()))) + print(f"{cafe_especial.get_descricao()} - R$ {cafe_especial.get_preco():.2f}") + + + + + + + diff --git a/respExercicio18.py b/respExercicio18.py new file mode 100644 index 0000000..070d322 --- /dev/null +++ b/respExercicio18.py @@ -0,0 +1,105 @@ +#Implementar o padrão de projeto Facade para simplificar uma interface complexa. + +## Descrição do Exercício# +#Crie uma facade para simplificar o uso de um sistema complexo de home theater. + +class Amplificador: + def ligar(self): + print("Amplificador ligado.") + + def definir_volume(self, volume): + print(f"Volume definido para {volume}.") + + + def desligar(self): + print("Amplificador desligado.") + +class DVDPlayer: + def ligar(self): + print("DVD Player ligado.") + + def reproduzir(self, filme): + print(f"Reproduzindo filme: {filme}") + + def parar(self): + print("DVD Player parado.") + + def desligar(self): + print("DVD Player desligado.") + + +class Projetor: + def ligar(self): + print("Projetor ligado.") + + def modo_widescreen(self): + print("Projetor em modo widescreen.") + + def desligar(self): + print("Projetor desligado.") + +class Luzes: + def aumentar(self, nivel): + print(f"Luzes aumentadas para {nivel}%.") + + def diminuir(self, nivel): + print(f"Luzes diminuídas para {nivel}%.") + +class PipocaPopper: + def ligar(self): + print("Pipoca Popper ligado.") + + def fazer_pipoca(self): + print("Fazendo pipoca...") + +#Facade + +class HomeTheaterFacade: + def __init__(self): + self.amp = Amplificador() + self.dvd = DVDPlayer() + self.proj = Projetor() + self.luzes = Luzes() + self.pipoca = PipocaPopper() + + def assistir_filme(self, filme): + print("Preparando para assistir ao filme...") + + self.pipoca.ligar() + self.pipoca.fazer_pipoca() + + self.luzes.diminuir(10) + + self.proj.ligar() + self.proj.modo_widescreen() + + self.amp.ligar() + self.amp.definir_volume(5) + + self.dvd.ligar() + self.dvd.reproduzir(filme) + + print("Aproveite o filme!") + + def fim_filme(self): + print("Desligando o home theater...") + + self.amp.desligar() + self.dvd.parar() + self.dvd.desligar() + self.proj.desligar() + self.luzes.aumentar(100) + + print("Home theater desligado.") + +#Uso da Facade +if __name__ == "__main__": + home_theater = HomeTheaterFacade() + home_theater.assistir_filme("Matrix") + home_theater.fim_filme() + + + + + + diff --git a/respExercicio19.py b/respExercicio19.py new file mode 100644 index 0000000..8b36aae --- /dev/null +++ b/respExercicio19.py @@ -0,0 +1,69 @@ +#Implementar o padrão de projeto Observer para notificação de mudanças de estado. + +## Descrição do Exercício +#Crie um sistema de notificações onde múltiplos observadores são notificados quando o estado de um objeto muda. + +from abc import ABC, abstractmethod + +# Classe Observador (Observer) +class Observer(ABC): + @abstractmethod + def update(self, message): + pass + +# Classe Sujeito (Subject) +class EstacaoMeteorologica: + def __init__(self): + self.observers = [] + self.temperatura = None + self.umidade = None + self.pressao = None + + def adicionar_observer(self, observer): + self.observers.append(observer) + + def remover_observer(self, observer): + self.observers.remove(observer) + + def notificar_observers(self): + for observer in self.observers: + observer.update(self.temperatura, self.umidade, self.pressao) + + def definir_medicoes(self, temperatura, umidade, pressao): + self.temperatura = temperatura + self.umidade = umidade + self.pressao = pressao + self.notificar_observers() + + # Observers Concretos + +class DisplayTemperatura(Observer): + def update(self, temperatura, umidade, pressao): + print(f"Display Temperatura: {temperatura}°C") + +class DisplayUmidade(Observer): + def update(self, temperatura, umidade, pressao): + print(f"Display Umidade: {umidade}%") +class DisplayCompleto(Observer): + def update(self, temperatura, umidade, pressao): + print(f"Display Completo: {temperatura}°C, {umidade}%, {pressao} hPa") + + +# Demonstração de uso +if __name__ == "__main__": + + estacao = EstacaoMeteorologica() + + # Criando displays + display_temp = DisplayTemperatura() + display_umidade = DisplayUmidade() + display_completo = DisplayCompleto() + + # Registrando observadores + estacao.adicionar_observer(display_temp) + estacao.adicionar_observer(display_umidade) + estacao.adicionar_observer(display_completo) + + # Mudança de estado + estacao.definir_medicoes(25.5, 65.0, 1013.2) + estacao.definir_medicoes(27.0, 70.0, 1015.1) \ No newline at end of file diff --git a/respExercicio20.py b/respExercicio20.py new file mode 100644 index 0000000..82e4dcc --- /dev/null +++ b/respExercicio20.py @@ -0,0 +1,58 @@ +from abc import ABC, abstractmethod + +# ----------------------------- +# Interface (Strategy) +# ----------------------------- +class EstrategiaFrete(ABC): + @abstractmethod + def calcular_frete(self, peso, distancia): + pass + + +# ----------------------------- +# Estratégias Concretas +# ----------------------------- +class FreteNormal(EstrategiaFrete): + def calcular_frete(self, peso, distancia): + return 5.00 + (peso * 2.0) + (distancia * 0.1) + + +class FreteExpresso(EstrategiaFrete): + def calcular_frete(self, peso, distancia): + return 15.00 + (peso * 3.0) + (distancia * 0.2) + + +class FreteEconomico(EstrategiaFrete): + def calcular_frete(self, peso, distancia): + return 2.00 + (peso * 1.0) + (distancia * 0.05) + + +# ----------------------------- +# Contexto (Calculadora de Frete) +# ----------------------------- +class CalculadoraFrete: + def __init__(self, estrategia: EstrategiaFrete): + self.estrategia = estrategia + + def definir_estrategia(self, nova_estrategia: EstrategiaFrete): + self.estrategia = nova_estrategia + + def calcular(self, peso, distancia): + return self.estrategia.calcular_frete(peso, distancia) + + +# ----------------------------- +# Demonstração de uso +# ----------------------------- +if __name__ == "__main__": + peso = 10.0 # kg + distancia = 100.0 # km + + calculadora = CalculadoraFrete(FreteNormal()) + print(f"Frete Normal: R$ {calculadora.calcular(peso, distancia)}") + + calculadora.definir_estrategia(FreteExpresso()) + print(f"Frete Expresso: R$ {calculadora.calcular(peso, distancia)}") + + calculadora.definir_estrategia(FreteEconomico()) + print(f"Frete Econômico: R$ {calculadora.calcular(peso, distancia)}") diff --git a/tests/test_exercicio01.py b/tests/test_exercicio01.py index 3c9b02f..ac0b978 100644 --- a/tests/test_exercicio01.py +++ b/tests/test_exercicio01.py @@ -6,8 +6,8 @@ class TestExercicio01(unittest.TestCase): def setUp(self): try: - import prof_respExercicio01 - self.module = prof_respExercicio01 + import respExercicio01 + self.module = respExercicio01 except ImportError: self.fail("Arquivo respExercicio01.py não encontrado")