diff --git a/resExer/Resposta_10.md b/resExer/Resposta_10.md new file mode 100644 index 0000000..47a33a0 --- /dev/null +++ b/resExer/Resposta_10.md @@ -0,0 +1,36 @@ +## Erro 1 – Nome da classe fora da convenção +**Descrição:** A classe foi declarada como `class pessoa`, começando com letra minúscula. +**Solução:** Renomeada para `class Pessoa`. +**Conceito POO:** Convenção e boas práticas (legibilidade e padronização). + + +## Erro 2 – Atributo não atribuído ao objeto +**Descrição:** Dentro do `__init__`, o código fazia `nome = nome`, sem usar `self`. +**Solução:** Corrigido para `self.nome = nome`. +**Conceito POO:** Encapsulamento / inicialização correta de atributos. + + +## Erro 3 – Uso incorreto de atributo privado +**Descrição:** Foi usado `self.__cpf`, mas nunca foi utilizado ou acessado. Além disso, o duplo underscore causa name mangling desnecessário. +**Solução:** Ajustado para `self._cpf`, que indica atributo protegido. +**Conceito POO:** Encapsulamento. + + +## Erro 4 – Método `apresentar()` sem parâmetro `self` +**Descrição:** O método foi declarado como `def apresentar():`, impossibilitando acessar atributos. +**Solução:** Corrigido para `def apresentar(self):`. +**Conceito POO:** Estrutura de métodos de instância. + + +## Erro 5 – Classe filha não chama o construtor da classe Pai +**Descrição:** `Estudante` ignora `super().__init__()` e redefine atributos manualmente. +**Solução:** Corrigido para `super().__init__(nome, idade)`. +**Conceito POO:** Herança e uso correto de `super()`. + + +## Erro 6 – Cálculo de média sem tratar lista vazia +**Descrição:** `sum(self.notas) / len(self.notas)` causava erro quando a lista estava vazia. +**Solução:** Adicionada verificação: +```python +if len(self.notas) == 0: + return 0.0 \ No newline at end of file diff --git a/resExer/Resposta_10.py b/resExer/Resposta_10.py new file mode 100644 index 0000000..ffcc2f5 --- /dev/null +++ b/resExer/Resposta_10.py @@ -0,0 +1,47 @@ +class Pessoa: # Correção do Erro 1 + def __init__(self, nome, idade): + self.nome = nome # Correção do Erro 2 + self.idade = idade + self._cpf = None # Correção do Erro 3 + + def apresentar(self): # Correção do Erro 4 + return f"Olá, sou {self.nome}" + + +class Estudante(Pessoa): + def __init__(self, nome, idade, curso): + super().__init__(nome, idade) # Correção do Erro 5 + 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: # Correção do Erro 6 + return 0.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"Olá, sou o professor {self.nome} do departamento {self.departamento}" + + +# Código corrigido +if __name__ == "__main__": + estudante = Estudante("João", 20, "Engenharia") + professor = Professor("Dr. Silva", 45, "Computação", 8000) + + estudante.adicionar_nota(8) + estudante.adicionar_nota(9) + + print(estudante.apresentar()) + print(professor.apresentar()) + print(f"Média do estudante: {estudante.calcular_media()}") \ No newline at end of file diff --git a/resExer/respExercicio01.py b/resExer/respExercicio01.py new file mode 100644 index 0000000..e55837b --- /dev/null +++ b/resExer/respExercicio01.py @@ -0,0 +1,19 @@ +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 + +print ("--Aluno--") +aluno1 = Aluno("João Silva", "2023001", "Engenharia") +aluno2 = Aluno("Maria Oliveira", "2023002", "Medicina") + +print ("--Disciplina--") +matricula1 = Disciplina("Cálculo I", "MAT101", 60) +matricula2 = Disciplina("Anatomia", "MED201", 80) \ No newline at end of file diff --git a/resExer/respExercicio02.py b/resExer/respExercicio02.py new file mode 100644 index 0000000..89daad5 --- /dev/null +++ b/resExer/respExercicio02.py @@ -0,0 +1,32 @@ +class Aluno: + def __init__(self, nome, matricula, curso, notas=None): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.notas = [] if notas is None else notas + + def adicionar_nota(self, nota): + self.notas.append(nota) + + def calcular_media(self): + if len(self.notas) == 0: + return 0.0 + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + if media >= 7.0: + print("Aprovado") + else: + print("Reprovado") + + +# Exemplo de uso +if __name__ == "__main__": + aluno = Aluno("João Silva", "2023001", "Engenharia de Software") + aluno.adicionar_nota(8.5) + aluno.adicionar_nota(7.0) + aluno.adicionar_nota(9.2) + + print(f"Média: {aluno.calcular_media():.2f}") + aluno.status() \ No newline at end of file diff --git a/resExer/respExercicio03.py b/resExer/respExercicio03.py new file mode 100644 index 0000000..46a477e --- /dev/null +++ b/resExer/respExercicio03.py @@ -0,0 +1,24 @@ +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, valor): + if valor > 0: + self._salario = valor + else: + print("Erro: Salário deve ser um valor positivo!") +# Exemplo de uso +if __name__ == "__main__": + prof = Professor("Dr. Silva", "Computação", 5000.0) + print(f"Salário atual: R$ {prof.salario}") + + prof.salario = 6000.0 + print(f"Novo salário: R$ {prof.salario}") + + prof.salario = -1000.0 + print(f"Salário após tentativa inválida: R$ {prof.salario}") \ No newline at end of file diff --git a/resExer/respExercicio04.py b/resExer/respExercicio04.py new file mode 100644 index 0000000..6e006d3 --- /dev/null +++ b/resExer/respExercicio04.py @@ -0,0 +1,23 @@ +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á, sou {self.nome}, CPF: {self.cpf}" + + +class Funcionario(Pessoa): + def __init__(self, nome, cpf, data_nascimento, cargo): + super().__init__(nome, cpf, data_nascimento) + self.cargo = cargo + + +class Tutor(Pessoa): + def __init__(self, nome, cpf, data_nascimento, area_atuacao): + super().__init__(nome, cpf, data_nascimento) + self.area_atuacao = area_atuacao + + def apresentar(self): + return f"Olá, sou {self.nome}, CPF: {self.cpf}, atuo na área de {self.area_atuacao}" \ No newline at end of file diff --git a/resExer/respExercicio05.py b/resExer/respExercicio05.py new file mode 100644 index 0000000..e6dbd04 --- /dev/null +++ b/resExer/respExercicio05.py @@ -0,0 +1,20 @@ +class Pessoa: + def __init__(self, nome, cpf, data_nascimento): + 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) # chama o construtor da classe Pai + 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}") \ No newline at end of file diff --git a/resExer/respExercicio06.py b/resExer/respExercicio06.py new file mode 100644 index 0000000..94e42df --- /dev/null +++ b/resExer/respExercicio06.py @@ -0,0 +1,36 @@ +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(f" Disciplinas do Curso: {self.nome} ") + for disc in self.disciplinas: + print(f"- {disc.nome} ({disc.codigo})") + + def carga_horaria_total(self): + total = 0 + for disc in self.disciplinas: + total += disc.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/resExer/respExercicio07.py b/resExer/respExercicio07.py new file mode 100644 index 0000000..1e7796d --- /dev/null +++ b/resExer/respExercicio07.py @@ -0,0 +1,53 @@ +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 de {self.nome} ===") + if not self.disciplinas_inscritas: + print("Nenhuma disciplina inscrita.") + return + for disc in self.disciplinas_inscritas: + print(f"- {disc.nome} ({disc.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(f"=== Alunos matriculados em {self.nome} ===") + if not self.alunos_matriculados: + print("Nenhum aluno matriculado.") + return + for aluno in self.alunos_matriculados: + print(f"- {aluno.nome} ({aluno.matricula})") + +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) + +# Exemplo de uso +if __name__ == "__main__": + 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/resExer/respExercicio08.py b/resExer/respExercicio08.py new file mode 100644 index 0000000..3d695fc --- /dev/null +++ b/resExer/respExercicio08.py @@ -0,0 +1,40 @@ +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} ===") + if not self.professores: + print("Nenhum professor cadastrado.") + return + for prof in self.professores: + print(f"- {prof}") + +# Exemplo de uso +if __name__ == "__main__": + dept_exatas = Departamento.criar_departamento_exatas("Matemática e Computação") + dept_humanas = Departamento.criar_departamento_humanas("Letras e Filosofia") + + print(f"Departamento: {dept_exatas.nome} - Sigla: {dept_exatas.sigla}") + print(f"Departamento: {dept_humanas.nome} - Sigla: {dept_humanas.sigla}") + + + dept_exatas.adicionar_professor("Professor João") + dept_exatas.adicionar_professor("Professora Amanda") + dept_humanas.adicionar_professor("Professora Helena") + + dept_exatas.listar_professores() + dept_humanas.listar_professores() \ No newline at end of file diff --git a/resExer/respExercicio09.py b/resExer/respExercicio09.py new file mode 100644 index 0000000..d66fd07 --- /dev/null +++ b/resExer/respExercicio09.py @@ -0,0 +1,39 @@ +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + + def apresentar(self): + return f"Olá, sou o aluno {self.nome} e estudo no curso {self.curso}." + +class Professor: + def __init__(self, nome, departamento, salario): + self.nome = nome + self.departamento = departamento + self.salario = salario + + def apresentar(self): + return f"Olá, sou o professor {self.nome} e leciono no departamento {self.departamento}." + +class Funcionario: + def __init__(self, nome, cpf, data_nascimento, cargo, salario): + self.nome = nome + self.cpf = cpf + self.data_nascimento = data_nascimento + self.cargo = cargo + self.salario = salario + + def apresentar(self): + return f"Olá, sou o funcionário {self.nome} e meu cargo é {self.cargo}." + +# Exemplo de uso +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", "Secretário", 3000.0) + ] + + for pessoa in pessoas: + print(pessoa.apresentar()) \ No newline at end of file diff --git a/resExer/respExercicio11.py b/resExer/respExercicio11.py new file mode 100644 index 0000000..1373c0c --- /dev/null +++ b/resExer/respExercicio11.py @@ -0,0 +1,30 @@ +class Funcionario: + def __init__(self, nome, salario, cargo): + self.nome = nome + self.salario = salario + self.cargo = cargo + +class CalculadoraSalario: + def calcular_salario_liquido(self, salario, descontos): + return salario - descontos + +class GeradorRelatorio: + def gerar(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...") + +# Exemplo de uso das classes +func = Funcionario("João", 5000, "Desenvolvedor") + +calc = CalculadoraSalario() +salario_liquido = calc.calcular_salario_liquido(func.salario, descontos=800) +print("Salário líquido:", salario_liquido) + +relatorio = GeradorRelatorio() +print(relatorio.gerar(func)) + +repo = RepositorioFuncionario() +repo.salvar(func) \ No newline at end of file diff --git a/resExer/respExercicio12.py b/resExer/respExercicio12.py new file mode 100644 index 0000000..620e0b2 --- /dev/null +++ b/resExer/respExercicio12.py @@ -0,0 +1,45 @@ +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% de desconto + +class DescontoFuncionario(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.85 # 15% de desconto + +class DescontoVIP(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.80 # 20% de desconto + +class ProcessadorPagamento: + def __init__(self, calculadora_desconto: CalculadorDesconto): + self.calculadora_desconto = calculadora_desconto + + def processar(self, valor): + return self.calculadora_desconto.calcular(valor) + +# Exemplo de uso das classes +valor = 1000 + +processador = ProcessadorPagamento(DescontoEstudante()) +print("Estudante paga:", processador.processar(valor)) + +processador = ProcessadorPagamento(DescontoFuncionario()) +print("Funcionário paga:", processador.processar(valor)) + +processador = ProcessadorPagamento(DescontoVIP()) +print("VIP paga:", processador.processar(valor)) + +# Demonstração +class DescontoBlackFriday(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.50 + +processador = ProcessadorPagamento(DescontoBlackFriday()) +print("Black Friday:", processador.processar(1000)) diff --git a/resExer/respExercicio13.py b/resExer/respExercicio13.py new file mode 100644 index 0000000..ba65ecc --- /dev/null +++ b/resExer/respExercicio13.py @@ -0,0 +1,55 @@ +class Veiculo: + def __init__(self, velocidade_maxima): + self._velocidade = 0 + self._velocidade_maxima = velocidade_maxima + + def acelerar(self): + # Aumenta sempre 20 km/h, mas sem ultrapassar a velocidade máxima + nova_vel = self._velocidade + 20 + self._velocidade = min(nova_vel, self._velocidade_maxima) + + def frear(self): + # Sempre reduz 20 km/h, mas não deixa ficar negativo + nova_vel = self._velocidade - 20 + self._velocidade = max(nova_vel, 0) + + def get_velocidade(self): + return self._velocidade + + +class Carro(Veiculo): + def __init__(self): + super().__init__(velocidade_maxima=180) + + +class Bicicleta(Veiculo): + def __init__(self): + super().__init__(velocidade_maxima=50) + + +class Aviao(Veiculo): + def __init__(self): + super().__init__(velocidade_maxima=900) + + +class ControladorTrafego: + def testar(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") + print("-" * 40) + + +# Exemplo de uso +if __name__ == "__main__": + carro = Carro() + bicicleta = Bicicleta() + aviao = Aviao() + + controlador = ControladorTrafego() + controlador.testar(carro) + controlador.testar(bicicleta) + controlador.testar(aviao) \ No newline at end of file diff --git a/resExer/respExercicio14.py b/resExer/respExercicio14.py new file mode 100644 index 0000000..4408610 --- /dev/null +++ b/resExer/respExercicio14.py @@ -0,0 +1,86 @@ +from abc import ABC, abstractmethod + +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 + + +class Desenvolvedor(Trabalhavel, Alimentavel, Descansavel, Programavel): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f"{self.nome} está trabalhando...") + + def comer(self): + print(f"{self.nome} está comendo...") + + def dormir(self): + print(f"{self.nome} está dormindo...") + + def programar(self): + print(f"{self.nome} está programando...") + + +class Gerente(Trabalhavel, Alimentavel, Descansavel): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f"{self.nome} está coordenando o trabalho...") + + def comer(self): + print(f"{self.nome} está comendo...") + + def dormir(self): + print(f"{self.nome} está descansando...") + + +class Robo(Trabalhavel, Programavel): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f"{self.nome} está executando tarefas automáticas...") + + def programar(self): + print(f"{self.nome} está processando código...") + +# Exemplo de Uso +if __name__ == "__main__": + desenvolvedor = Desenvolvedor("Ana") + gerente = Gerente("Carlos") + robo = Robo("R2D2") + + desenvolvedor.trabalhar() + desenvolvedor.comer() + desenvolvedor.programar() + + print() + + gerente.trabalhar() + gerente.comer() + + print() + + robo.trabalhar() + robo.programar() \ No newline at end of file diff --git a/resExer/respExercicio15.py b/resExer/respExercicio15.py new file mode 100644 index 0000000..f9f40fa --- /dev/null +++ b/resExer/respExercicio15.py @@ -0,0 +1,41 @@ +from abc import ABC, abstractmethod + +class ServicoNotificacao(ABC): + @abstractmethod + def enviar(self, mensagem): + pass + +class EmailService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando email: {mensagem}") + +class SMSService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando SMS: {mensagem}") + +class PushService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando push: {mensagem}") + +class NotificacaoService: + def __init__(self, servico_notificacao: ServicoNotificacao): + self.servico = servico_notificacao + + def notificar(self, mensagem): + self.servico.enviar(mensagem) + +# Exemplo de uso +if __name__ == "__main__": + email_service = EmailService() + sms_service = SMSService() + push_service = PushService() + + 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/resExer/respExercicio16.py b/resExer/respExercicio16.py new file mode 100644 index 0000000..dfcfd3d --- /dev/null +++ b/resExer/respExercicio16.py @@ -0,0 +1,42 @@ +class ProcessadorPagamento: + def processar_pagamento(self, valor, cartao): + raise NotImplementedError("Implementar na subclasse") + + +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: PayPalAPI): + self.paypal = paypal_api + + def processar_pagamento(self, valor, cartao): + return self.paypal.make_payment(valor, cartao) + + +class ProcessadorPagamentoInterno(ProcessadorPagamento): + def processar_pagamento(self, valor, cartao): + return f"Processador interno: Cobrança de R${valor} feita no cartão {cartao}" + + +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) + +# Exemplo de uso +if __name__ == "__main__": + processador_interno = ProcessadorPagamentoInterno() + sistema1 = SistemaPagamento(processador_interno) + + paypal_api = PayPalAPI() + paypal_adapter = PayPalAdapter(paypal_api) + sistema2 = SistemaPagamento(paypal_adapter) + + sistema1.realizar_pagamento(100.0, "1234-5678") + sistema2.realizar_pagamento(200.0, "8765-4321") \ No newline at end of file diff --git a/resExer/respExercicio17.py b/resExer/respExercicio17.py new file mode 100644 index 0000000..903eb02 --- /dev/null +++ b/resExer/respExercicio17.py @@ -0,0 +1,68 @@ +class Bebida: + def get_descricao(self): + raise NotImplementedError() + + def get_preco(self): + raise NotImplementedError() + +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 + +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() + +class LeiteDecorator(BebidaDecorator): + def get_descricao(self): + return self.bebida.get_descricao() + " com Leite" + + def get_preco(self): + return self.bebida.get_preco() + 2.00 + +class AcucarDecorator(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 ChantillyDecorator(BebidaDecorator): + def get_descricao(self): + return self.bebida.get_descricao() + " com Chantilly" + + def get_preco(self): + return self.bebida.get_preco() + 3.00 + +# Exemplo de uso +if __name__ == "__main__": + cafe = Cafe() + print(f"{cafe.get_descricao()} - R$ {cafe.get_preco()}") + + cafe_com_leite = LeiteDecorator(cafe) + print(f"{cafe_com_leite.get_descricao()} - R$ {cafe_com_leite.get_preco()}") + + 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/resExer/respExercicio18.py b/resExer/respExercicio18.py new file mode 100644 index 0000000..14fa0e8 --- /dev/null +++ b/resExer/respExercicio18.py @@ -0,0 +1,84 @@ +class Amplificador: + def ligar(self): + print("Ligando amplificador") + + def definir_volume(self, volume): + print(f"Definindo volume para {volume}") + +class DVDPlayer: + def ligar(self): + print("Ligando DVD player") + + def reproduzir(self, filme): + print(f"Reproduzindo {filme}") + +class Projetor: + def ligar(self): + print("Ligando projetor") + + def modo_widescreen(self): + print("Ativando modo widescreen") + +class Luzes: + def diminuir(self, nivel): + print(f"Diminuindo luzes para {nivel}%") + +class PipocaPopper: + def ligar(self): + print("Ligando pipoqueira") + + def fazer_pipoca(self): + print("Fazendo pipoca") + +class HomeTheaterFacade: + def __init__(self): + self.amplificador = Amplificador() + self.dvd = DVDPlayer() + self.projetor = Projetor() + self.luzes = Luzes() + self.pipoca = PipocaPopper() + + def assistir_filme(self, filme): + print(f"Preparando para assistir {filme}...") + self.amplificador.ligar() + self.amplificador.definir_volume(5) + + self.dvd.ligar() + + self.projetor.ligar() + self.projetor.modo_widescreen() + + self.luzes.diminuir(10) + + self.pipoca.ligar() + self.pipoca.fazer_pipoca() + + self.dvd.reproduzir(filme) + + def fim_filme(self): + print("Filme finalizado!") + +# Exemplo de uso +if __name__ == "__main__": + + print("=== Uso complexo (sem facade) ===") + amplificador = Amplificador() + dvd = DVDPlayer() + projetor = Projetor() + luzes = Luzes() + pipoca = PipocaPopper() + + amplificador.ligar() + amplificador.definir_volume(5) + dvd.ligar() + projetor.ligar() + projetor.modo_widescreen() + luzes.diminuir(10) + pipoca.ligar() + pipoca.fazer_pipoca() + dvd.reproduzir("Matrix") + + print("\n=== Uso simples (com facade) ===") + home = HomeTheaterFacade() + home.assistir_filme("Matrix") + home.fim_filme() \ No newline at end of file diff --git a/resExer/respExercicio19.py b/resExer/respExercicio19.py new file mode 100644 index 0000000..647c133 --- /dev/null +++ b/resExer/respExercicio19.py @@ -0,0 +1,56 @@ +class Observer: + def update(self, temperatura, umidade, pressao): + raise NotImplementedError("Método update() deve ser implementado") + +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): + if observer in self.observers: + 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() + +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") + +# Exemplo de uso +if __name__ == "__main__": + estacao = EstacaoMeteorologica() + + display_temp = DisplayTemperatura() + display_umidade = DisplayUmidade() + display_completo = DisplayCompleto() + + estacao.adicionar_observer(display_temp) + estacao.adicionar_observer(display_umidade) + estacao.adicionar_observer(display_completo) + + 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/resExer/respExercicio20.py b/resExer/respExercicio20.py new file mode 100644 index 0000000..2ec6270 --- /dev/null +++ b/resExer/respExercicio20.py @@ -0,0 +1,39 @@ +class EstrategiaFrete: + def calcular_frete(self, peso, distancia): + pass + +class FreteNormal(EstrategiaFrete): + def calcular_frete(self, peso, distancia): + return 5.0 + (peso * 2.0) + (distancia * 0.1) + +class FreteExpresso(EstrategiaFrete): + def calcular_frete(self, peso, distancia): + return 15.0 + (peso * 3.0) + (distancia * 0.2) + +class FreteEconomico(EstrategiaFrete): + def calcular_frete(self, peso, distancia): + return 2.0 + (peso * 1.0) + (distancia * 0.05) + +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) + +# Exemplo de uso +if __name__ == "__main__": + peso = 10.0 + distancia = 100.0 + + 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)}") \ No newline at end of file