diff --git a/Resposta_10.md b/Resposta_10.md new file mode 100644 index 0000000..68566e0 --- /dev/null +++ b/Resposta_10.md @@ -0,0 +1,53 @@ +# Resposta 10 - Relatório dos Erros Encontrados e Soluções + +## Erro 1: Nome da classe `pessoa` +- **Descrição do problema**: O nome da classe `pessoa` não segue a convenção de nomenclatura do Python (PEP 8), que recomenda o uso de PascalCase para nomes de classes. +- **Solução**: Renomeei a classe para `Pessoa`. +- **Conceito POO**: Convenção de nomenclatura. + +--- + +## Erro 2: Atributo `nome` não inicializado corretamente +- **Descrição do problema**: No construtor da classe `pessoa`, o atributo `nome` foi atribuído diretamente ao parâmetro, sem usar `self`. +- **Solução**: Corrigi a inicialização para `self.nome = nome`. +- **Conceito POO**: Inicialização de atributos. + +--- + +## Erro 3: Atributo privado `__cpf` não utilizado +- **Descrição do problema**: O atributo `__cpf` foi declarado, mas não foi utilizado ou acessado em nenhum lugar do código. +- **Solução**: Mantive o atributo como privado, respeitando o encapsulamento, mas ele pode ser acessado futuramente com métodos `getter` e `setter`. +- **Conceito POO**: Encapsulamento. + +--- + +## Erro 4: Método `apresentar` sem o parâmetro `self` +- **Descrição do problema**: O método `apresentar` não possui o parâmetro `self`, o que impede o acesso aos atributos da instância. +- **Solução**: Adicionei o parâmetro `self` ao método. +- **Conceito POO**: Definição de métodos. + +--- + +## Erro 5: Construtor da classe `Estudante` não chama o construtor da superclasse +- **Descrição do problema**: O construtor da classe `Estudante` não chama o construtor da superclasse `Pessoa`, o que resulta na ausência de inicialização dos atributos herdados. +- **Solução**: Adicionei a chamada ao construtor da superclasse com `super().__init__(nome, idade)`. +- **Conceito POO**: Herança e uso de `super()`. + +--- + +## Erro 6: Divisão por zero no método `calcular_media` +- **Descrição do problema**: O método `calcular_media` não trata o caso em que a lista de notas está vazia, o que pode causar uma divisão por zero. +- **Solução**: Adicionei uma verificação para retornar `0` caso a lista de notas esteja vazia. +- **Conceito POO**: Lógica de negócio. + +--- + +## Erro 7: Método `calcular_media` chamado sem adicionar notas +- **Descrição do problema**: No exemplo de uso, o método `calcular_media` é chamado antes de adicionar notas ao estudante, o que resulta em uma lista vazia. +- **Solução**: Adicionei notas ao estudante antes de chamar o método `calcular_media`. +- **Conceito POO**: Lógica de negócio. + +--- + +## Conclusão +Após corrigir os 7 erros, o código agora segue as boas práticas de Programação Orientada a Objetos, respeitando os princípios de encapsulamento, herança, inicialização de atributos e lógica de negócio. \ No newline at end of file diff --git a/Resposta_10.py b/Resposta_10.py new file mode 100644 index 0000000..bf58ebc --- /dev/null +++ b/Resposta_10.py @@ -0,0 +1,48 @@ +class Pessoa: # Corrigido: Nome da classe com letra maiúscula (convenção PEP 8) + def __init__(self, nome, idade): + self.nome = nome # Corrigido: Atributo `self.nome` foi corretamente inicializado + self.idade = idade + self.__cpf = None # Mantido como atributo privado (encapsulamento) + + def apresentar(self): # Corrigido: Adicionado `self` como parâmetro do método + return f"Olá, sou {self.nome}" + + +class Estudante(Pessoa): # Corrigido: Nome da classe com letra maiúscula e herança corrigida + def __init__(self, nome, idade, curso): + super().__init__(nome, idade) # Corrigido: Chamada ao construtor da superclasse + self.curso = curso + self.notas = [] + + def adicionar_nota(self, nota): + if 0 <= nota <= 10: # Mantida a validação de nota + self.notas.append(nota) + + def calcular_media(self): + if len(self.notas) == 0: # Corrigido: Tratamento para evitar divisão por zero + return 0 + return sum(self.notas) / len(self.notas) + + +class Professor(Pessoa): # Corrigido: Nome da classe com letra maiúscula e herança corrigida + def __init__(self, nome, idade, departamento, salario): + super().__init__(nome, idade) # Corrigido: Chamada ao construtor da superclasse + self.departamento = departamento + self.salario = salario + + def apresentar(self): + return f"Olá, sou o professor {self.nome} do departamento {self.departamento}" + + +# Testando o código corrigido +estudante = Estudante("João", 20, "Engenharia") +professor = Professor("Dr. Silva", 45, "Computação", 8000) + +# Adicionando notas ao estudante +estudante.adicionar_nota(8) +estudante.adicionar_nota(9) + +# Exibindo as apresentações e a média do estudante +print(estudante.apresentar()) +print(professor.apresentar()) +print(f"Média do estudante: {estudante.calcular_media()}") \ No newline at end of file diff --git a/respExercicio01.py b/respExercicio01.py new file mode 100644 index 0000000..7923669 --- /dev/null +++ b/respExercicio01.py @@ -0,0 +1,23 @@ +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + + def info_aluno(self): + return f"Nome: {self.nome}, Matrícula: {self.matricula}, Curso: {self.curso}" + +class Disciplina: + def __init__(self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + + def info_displina(self): + return f"Nome {self.nome}, Código: {self.codigo}, Carga Horária: {self.carga_horaria}" + +aluno1 = Aluno("João", 6325225, "ADS") +discplina1 = Disciplina("Cloud", 12112025, 25) + +print(aluno1.info_aluno()) +print(discplina1.info_displina()) \ No newline at end of file diff --git a/respExercicio02.py b/respExercicio02.py new file mode 100644 index 0000000..dc45599 --- /dev/null +++ b/respExercicio02.py @@ -0,0 +1,44 @@ +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.notas = [] + + def info_aluno(self): + return f"Nome: {self.nome}, Matrícula: {self.matricula}, Curso: {self.curso}" + + def adicionar_nota(self, nota): + self.notas.append(nota) + + def calcular_media(self): + if len(self.notas) == 0: + return 0 + + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + if media >= 7: + return "Aprovado!" + else: + return "Reprovado!" + +class Disciplina: + def __init__(self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + + def info_displina(self): + return f"Nome {self.nome}, Código: {self.codigo}, Carga Horária: {self.carga_horaria}" + +aluno = Aluno("João Silva", "2023001", "Engenharia de Software") + +aluno.adicionar_nota(8.5) +aluno.adicionar_nota(7.0) +aluno.adicionar_nota(9.2) + +print(f"Média: {aluno.calcular_media()}") + +aluno.status() \ No newline at end of file diff --git a/respExercicio03.py b/respExercicio03.py new file mode 100644 index 0000000..8745a2e --- /dev/null +++ b/respExercicio03.py @@ -0,0 +1,64 @@ +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.notas = [] + + def info_aluno(self): + return f"Nome: {self.nome}, Matrícula: {self.matricula}, Curso: {self.curso}" + + def adicionar_nota(self, nota): + self.notas.append(nota) + + def calcular_media(self): + if len(self.notas) == 0: + return 0 + + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + if media >= 7: + return "Aprovado!" + else: + return "Reprovado!" + +class Professor: + def __init__(self, nome, departamento, salarioInicial): + self.nome = nome + self.departamento = departamento + self._salario = salarioInicial + + def getSalario(self): # getter + return self._salario + + def setSalario(self, novoSalario): #setter + if novoSalario > 0: + self._salario = novoSalario + else: + return "Erro! O novo salário não pode ser uma valor negativo." + +class Disciplina: + def __init__(self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + + def info_displina(self): + return f"Nome {self.nome}, Código: {self.codigo}, Carga Horária: {self.carga_horaria}" + +# Exemplo de Uso + +prof = Professor("Dr. Silva", "Computação", 5000.0) + +# Usando o getter para obter o salário atual +print(f"Salário atual: R$ {prof.getSalario()}") + +# Usando o setter para alterar o salário +prof.setSalario(6000.0) # Deve funcionar +print(f"Novo salário: R$ {prof.getSalario()}") + +# Tentando definir um salário inválido +prof.setSalario(-1000.0) # Deve dar erro +print(f"Salário após tentativa inválida: R$ {prof.getSalario()}") \ No newline at end of file diff --git a/respExercicio04.py b/respExercicio04.py new file mode 100644 index 0000000..04abaa0 --- /dev/null +++ b/respExercicio04.py @@ -0,0 +1,82 @@ +class Pessoa: + def __init__(self, nome, cpf, data_nascimento): + self.nome = nome + self.cpf = cpf + self.data_nascimento = data_nascimento + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf} e eu nasci em {self.data_nascimento}." + +class Funcionario(Pessoa): + def __init__(self, nome, cpf, data_nascimento, cargo): + super().__init__(nome, cpf, data_nascimento) + self.cargo = cargo + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf}, eu nasci em {self.data_nascimento} e sou {self.cargo}." + +class Tutor(Pessoa): + def __init__(self, nome, cpf, data_nascimento, area_atuacao): + super().__init__(nome, cpf, data_nascimento) + self.area_atuacao = area_atuacao + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf}, eu nasci em {self.data_nascimento} e atuo na área de {self.area_atuacao}." + +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.notas = [] + + def info_aluno(self): + return f"Nome: {self.nome}, Matrícula: {self.matricula}, Curso: {self.curso}" + + def adicionar_nota(self, nota): + self.notas.append(nota) + + def calcular_media(self): + if len(self.notas) == 0: + return 0 + + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + if media >= 7: + return "Aprovado!" + else: + return "Reprovado!" + +class Professor: + def __init__(self, nome, departamento, salarioInicial): + self.nome = nome + self.departamento = departamento + self._salario = salarioInicial + + def getSalario(self): # getter + return self._salario + + def setSalario(self, novoSalario): #setter + if novoSalario > 0: + self._salario = novoSalario + else: + return "Erro! O novo salário não pode ser uma valor negativo." + +class Disciplina: + def __init__(self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + + def info_displina(self): + return f"Nome {self.nome}, Código: {self.codigo}, Carga Horária: {self.carga_horaria}" + +# Exemplo de Uso + +funcionario = Funcionario("João Silva", "123.456.789-00", "01/01/1990", "Secretário") +tutor = Tutor("Maria Santos", "987.654.321-00", "15/05/1985", "Programação") + +print(funcionario.apresentar()) +print(tutor.apresentar()) \ No newline at end of file diff --git a/respExercicio05.py b/respExercicio05.py new file mode 100644 index 0000000..b61f10e --- /dev/null +++ b/respExercicio05.py @@ -0,0 +1,83 @@ +class Pessoa: + def __init__(self, nome, cpf, data_nascimento): + self.nome = nome + self.cpf = cpf + self.data_nascimento = data_nascimento + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf} e eu nasci em {self.data_nascimento}." + +class Funcionario(Pessoa): + def __init__(self, nome, cpf, data_nascimento, cargo, salario): + super().__init__(nome, cpf, data_nascimento) + self.cargo = cargo + self.salario = salario + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf}, eu nasci em {self.data_nascimento} e sou {self.cargo}." + + def exibir_dados(self): + return f"=== Dados do Funcionário ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nCargo: {self.cargo}\nSalário: {self.salario}" + +class Tutor(Pessoa): + def __init__(self, nome, cpf, data_nascimento, area_atuacao): + super().__init__(nome, cpf, data_nascimento) + self.area_atuacao = area_atuacao + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf}, eu nasci em {self.data_nascimento} e atuo na área de {self.area_atuacao}." + +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.notas = [] + + def info_aluno(self): + return f"Nome: {self.nome}, Matrícula: {self.matricula}, Curso: {self.curso}" + + def adicionar_nota(self, nota): + self.notas.append(nota) + + def calcular_media(self): + if len(self.notas) == 0: + return 0 + + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + if media >= 7: + return "Aprovado!" + else: + return "Reprovado!" + +class Professor: + def __init__(self, nome, departamento, salarioInicial): + self.nome = nome + self.departamento = departamento + self._salario = salarioInicial + + def getSalario(self): # getter + return self._salario + + def setSalario(self, novoSalario): #setter + if novoSalario > 0: + self._salario = novoSalario + else: + return "Erro! O novo salário não pode ser uma valor negativo." + +class Disciplina: + def __init__(self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + + def info_displina(self): + return f"Nome {self.nome}, Código: {self.codigo}, Carga Horária: {self.carga_horaria}" + +# Exemplo de Uso + +funcionario = Funcionario("Ana Costa", "111.222.333-44", "20/03/1988", "Coordenadora", 4500.0) +print(funcionario.exibir_dados()) \ No newline at end of file diff --git a/respExercicio06.py b/respExercicio06.py new file mode 100644 index 0000000..7bd7bd4 --- /dev/null +++ b/respExercicio06.py @@ -0,0 +1,110 @@ +class Pessoa: + def __init__(self, nome, cpf, data_nascimento): + self.nome = nome + self.cpf = cpf + self.data_nascimento = data_nascimento + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf} e eu nasci em {self.data_nascimento}." + +class Funcionario(Pessoa): + def __init__(self, nome, cpf, data_nascimento, cargo, salario): + super().__init__(nome, cpf, data_nascimento) + self.cargo = cargo + self.salario = salario + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf}, eu nasci em {self.data_nascimento} e sou {self.cargo}." + + def exibir_dados(self): + return f"=== Dados do Funcionário ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nCargo: {self.cargo}\nSalário: {self.salario}" + +class Tutor(Pessoa): + def __init__(self, nome, cpf, data_nascimento, area_atuacao): + super().__init__(nome, cpf, data_nascimento) + self.area_atuacao = area_atuacao + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf}, eu nasci em {self.data_nascimento} e atuo na área de {self.area_atuacao}." + +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.notas = [] + + def info_aluno(self): + return f"Nome: {self.nome}, Matrícula: {self.matricula}, Curso: {self.curso}" + + def adicionar_nota(self, nota): + self.notas.append(nota) + + def calcular_media(self): + if len(self.notas) == 0: + return 0 + + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + if media >= 7: + return "Aprovado!" + else: + return "Reprovado!" + +class Professor: + def __init__(self, nome, departamento, salarioInicial): + self.nome = nome + self.departamento = departamento + self._salario = salarioInicial + + def getSalario(self): # getter + return self._salario + + def setSalario(self, novoSalario): #setter + if novoSalario > 0: + self._salario = novoSalario + else: + return "Erro! O novo salário não pode ser uma valor negativo." + +class Disciplina: + def __init__(self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + + def info_displina(self): + return f"Nome {self.nome}, Código: {self.codigo}, Carga Horária: {self.carga_horaria}" + +class Curso: + def __init__(self, nome, codigo): + self.nome = nome + self.codigo = codigo + self.disciplinas = [] + + def adicionar_disciplina(self, disciplina): + self.disciplinas.append(disciplina) + + def listar_disciplinas(self): + print(f"=== Disciplinas do Curso: {self.nome} ===") + for disciplina in self.disciplinas: + print(f"- {disciplina.nome} ({disciplina.codigo})") + + def carga_horaria_total(self): + return sum(disciplina.carga_horaria for disciplina in self.disciplinas) + +# Exemplo de Uso +curso = Curso("Engenharia de Software", "ES001") # objeto da classe Curso +disciplina1 = Disciplina("Programação Orientada a Objetos", "POO001", 60) # objeto da classe Disciplina +disciplina2 = Disciplina("Banco de Dados", "BD001", 80) # objeto da classe Disciplina + +# Adicionando disciplinas ao curso +curso.adicionar_disciplina(disciplina1) # objeto da classe Curso chamando um método da classe disciplina +curso.adicionar_disciplina(disciplina2) + +# Listando disciplinas +curso.listar_disciplinas() + +# Exibindo a carga horária total +print(f"Carga horária total: {curso.carga_horaria_total()}h") \ No newline at end of file diff --git a/respExercicio07.py b/respExercicio07.py new file mode 100644 index 0000000..bc04f88 --- /dev/null +++ b/respExercicio07.py @@ -0,0 +1,132 @@ +class Pessoa: + def __init__(self, nome, cpf, data_nascimento): + self.nome = nome + self.cpf = cpf + self.data_nascimento = data_nascimento + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf} e eu nasci em {self.data_nascimento}." + +class Funcionario(Pessoa): + def __init__(self, nome, cpf, data_nascimento, cargo, salario): + super().__init__(nome, cpf, data_nascimento) + self.cargo = cargo + self.salario = salario + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf}, eu nasci em {self.data_nascimento} e sou {self.cargo}." + + def exibir_dados(self): + return f"=== Dados do Funcionário ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nCargo: {self.cargo}\nSalário: {self.salario}" + +class Tutor(Pessoa): + def __init__(self, nome, cpf, data_nascimento, area_atuacao): + super().__init__(nome, cpf, data_nascimento) + self.area_atuacao = area_atuacao + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf}, eu nasci em {self.data_nascimento} e atuo na área de {self.area_atuacao}." + +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.disciplinas_inscritas = [] # Lista de disciplinas em que o aluno está inscrito + + def info_aluno(self): + return f"Nome: {self.nome}, Matrícula: {self.matricula}, Curso: {self.curso}" + + def listar_disciplinas(self): + print(f"=== Disciplinas de {self.nome} ===") + for disciplina in self.disciplinas_inscritas: + print(f"- {disciplina.nome} ({disciplina.codigo})") + + def adicionar_nota(self, nota): + self.notas.append(nota) + + def calcular_media(self): + if len(self.notas) == 0: + return 0 + + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + if media >= 7: + return "Aprovado!" + else: + return "Reprovado!" + +class Professor: + def __init__(self, nome, departamento, salarioInicial): + self.nome = nome + self.departamento = departamento + self._salario = salarioInicial + + def getSalario(self): # getter + return self._salario + + def setSalario(self, novoSalario): #setter + if novoSalario > 0: + self._salario = novoSalario + else: + return "Erro! O novo salário não pode ser uma valor negativo." + +class Disciplina: + def __init__(self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + self.alunos_matriculados = [] # Lista de alunos matriculados na disciplina + + def info_displina(self): + return f"Nome: {self.nome}, Código: {self.codigo}, Carga Horária: {self.carga_horaria}" + + def listar_alunos(self): + print(f"=== Alunos matriculados em {self.nome} ===") + for aluno in self.alunos_matriculados: + print(f"- {aluno.nome} ({aluno.matricula})") + +class Curso: + def __init__(self, nome, codigo): + self.nome = nome + self.codigo = codigo + self.disciplinas = [] + + def adicionar_disciplina(self, disciplina): + self.disciplinas.append(disciplina) + + def listar_disciplinas(self): + print(f"=== Disciplinas do Curso: {self.nome} ===") + for disciplina in self.disciplinas: + print(f"- {disciplina.nome} ({disciplina.codigo})") + + def carga_horaria_total(self): + return sum(disciplina.carga_horaria for disciplina in self.disciplinas) + +class Secretaria: + @staticmethod + def inscrever_aluno(aluno, disciplina): + """Inscreve um aluno em uma disciplina e atualiza as listas de ambos.""" + if disciplina not in aluno.disciplinas_inscritas: + aluno.disciplinas_inscritas.append(disciplina) + if aluno not in disciplina.alunos_matriculados: + disciplina.alunos_matriculados.append(aluno) + +# Exemplo de Uso +aluno1 = Aluno("João Silva", "2023001", "Engenharia de Software") +aluno2 = Aluno("Maria Santos", "2023002", "Ciência da Computação") +disciplina1 = Disciplina("POO", "POO001", 60) +disciplina2 = Disciplina("Banco de Dados", "BD001", 80) + +# Inscrevendo alunos nas disciplinas +Secretaria.inscrever_aluno(aluno1, disciplina1) +Secretaria.inscrever_aluno(aluno1, disciplina2) +Secretaria.inscrever_aluno(aluno2, disciplina1) + +# Listando disciplinas de um aluno +aluno1.listar_disciplinas() + +# Listando alunos de uma disciplina +disciplina1.listar_alunos() \ No newline at end of file diff --git a/respExercicio08.py b/respExercicio08.py new file mode 100644 index 0000000..c14ffed --- /dev/null +++ b/respExercicio08.py @@ -0,0 +1,159 @@ +class Pessoa: + def __init__(self, nome, cpf, data_nascimento): + self.nome = nome + self.cpf = cpf + self.data_nascimento = data_nascimento + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf} e eu nasci em {self.data_nascimento}." + +class Funcionario(Pessoa): + def __init__(self, nome, cpf, data_nascimento, cargo, salario): + super().__init__(nome, cpf, data_nascimento) + self.cargo = cargo + self.salario = salario + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf}, eu nasci em {self.data_nascimento} e sou {self.cargo}." + + def exibir_dados(self): + return f"=== Dados do Funcionário ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nCargo: {self.cargo}\nSalário: {self.salario}" + +class Tutor(Pessoa): + def __init__(self, nome, cpf, data_nascimento, area_atuacao): + super().__init__(nome, cpf, data_nascimento) + self.area_atuacao = area_atuacao + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}, o meu CPF é {self.cpf}, eu nasci em {self.data_nascimento} e atuo na área de {self.area_atuacao}." + +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.disciplinas_inscritas = [] # Lista de disciplinas em que o aluno está inscrito + + def info_aluno(self): + return f"Nome: {self.nome}, Matrícula: {self.matricula}, Curso: {self.curso}" + + def listar_disciplinas(self): + print(f"=== Disciplinas de {self.nome} ===") + for disciplina in self.disciplinas_inscritas: + print(f"- {disciplina.nome} ({disciplina.codigo})") + + def adicionar_nota(self, nota): + self.notas.append(nota) + + def calcular_media(self): + if len(self.notas) == 0: + return 0 + + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + if media >= 7: + return "Aprovado!" + else: + return "Reprovado!" + +class Professor: + def __init__(self, nome, departamento, salarioInicial): + self.nome = nome + self.departamento = departamento + self._salario = salarioInicial + + def getSalario(self): # getter + return self._salario + + def setSalario(self, novoSalario): #setter + if novoSalario > 0: + self._salario = novoSalario + else: + return "Erro! O novo salário não pode ser uma valor negativo." + +class Disciplina: + def __init__(self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + self.alunos_matriculados = [] # Lista de alunos matriculados na disciplina + + def info_displina(self): + return f"Nome: {self.nome}, Código: {self.codigo}, Carga Horária: {self.carga_horaria}" + + def listar_alunos(self): + print(f"=== Alunos matriculados em {self.nome} ===") + for aluno in self.alunos_matriculados: + print(f"- {aluno.nome} ({aluno.matricula})") + +class Curso: + def __init__(self, nome, codigo): + self.nome = nome + self.codigo = codigo + self.disciplinas = [] + + def adicionar_disciplina(self, disciplina): + self.disciplinas.append(disciplina) + + def listar_disciplinas(self): + print(f"=== Disciplinas do Curso: {self.nome} ===") + for disciplina in self.disciplinas: + print(f"- {disciplina.nome} ({disciplina.codigo})") + + def carga_horaria_total(self): + return sum(disciplina.carga_horaria for disciplina in self.disciplinas) + +class Secretaria: + @staticmethod + def inscrever_aluno(aluno, disciplina): + """Inscreve um aluno em uma disciplina e atualiza as listas de ambos.""" + if disciplina not in aluno.disciplinas_inscritas: + aluno.disciplinas_inscritas.append(disciplina) + if aluno not in disciplina.alunos_matriculados: + disciplina.alunos_matriculados.append(aluno) + +class Departamento: + def __init__(self, nome, sigla): + self.nome = nome + self.sigla = sigla + self.professores = [] # Lista de professores associados ao departamento + + @classmethod + def criar_departamento_exatas(cls, nome): + """Cria um departamento com a sigla 'EXA'.""" + return cls(nome, "EXA") + + @classmethod + def criar_departamento_humanas(cls, nome): + """Cria um departamento com a sigla 'HUM'.""" + return cls(nome, "HUM") + + def adicionar_professor(self, professor): + """Adiciona um professor à lista de professores do departamento.""" + self.professores.append(professor) + + def listar_professores(self): + """Lista os professores associados ao departamento.""" + print(f"=== Professores do Departamento: {self.nome} ({self.sigla}) ===") + for professor in self.professores: + print(f"- {professor.nome}") + +# Exemplo de Uso +dept_exatas = Departamento.criar_departamento_exatas("Matemática e Computação") +dept_humanas = Departamento.criar_departamento_humanas("Letras e Filosofia") + +print(f"Departamento: {dept_exatas.nome} - Sigla: {dept_exatas.sigla}") +print(f"Departamento: {dept_humanas.nome} - Sigla: {dept_humanas.sigla}") + +# Criando professores e adicionando aos departamentos +prof1 = Professor("Dr. Silva", dept_exatas, 5000.0) # Corrigido +prof2 = Professor("Dr. Costa", dept_humanas, 4500.0) # Corrigido + +dept_exatas.adicionar_professor(prof1) +dept_humanas.adicionar_professor(prof2) + +# Listando professores de cada departamento +dept_exatas.listar_professores() +dept_humanas.listar_professores() \ No newline at end of file diff --git a/respExercicio09.py b/respExercicio09.py new file mode 100644 index 0000000..f7e1d50 --- /dev/null +++ b/respExercicio09.py @@ -0,0 +1,48 @@ +class Pessoa: + def __init__(self, nome): + self.nome = nome + + def apresentar(self): + return f"Olá! Meu nome é {self.nome}." + + +class Aluno(Pessoa): + def __init__(self, nome, matricula, curso): + super().__init__(nome) + self.matricula = matricula + self.curso = curso + + def apresentar(self): + return f"Olá, sou o aluno {self.nome} e estudo no curso {self.curso}." + + +class Professor(Pessoa): + def __init__(self, nome, departamento, salario): + super().__init__(nome) + self.departamento = departamento + self.salario = salario + + def apresentar(self): + return f"Olá, sou o professor {self.nome} e leciono no departamento {self.departamento}." + + +class Funcionario(Pessoa): + def __init__(self, nome, cpf, data_nascimento, cargo, salario): + super().__init__(nome) + self.cpf = cpf + self.data_nascimento = data_nascimento + self.cargo = cargo + self.salario = salario + + def apresentar(self): + return f"Olá, sou o funcionário {self.nome} e meu cargo é {self.cargo}." + +# Exemplo de Uso +pessoas = [ + Aluno("João Silva", "2023001", "Engenharia de Software"), + Professor("Dr. Maria", "Computação", 8000.0), + Funcionario("Carlos Santos", "123.456.789-00", "01/01/1980", "Secretário", 3000.0), +] + +for pessoa in pessoas: + print(pessoa.apresentar()) \ No newline at end of file diff --git a/respExercicio11.py b/respExercicio11.py new file mode 100644 index 0000000..e255985 --- /dev/null +++ b/respExercicio11.py @@ -0,0 +1,45 @@ +# Classe Funcionario: Responsável apenas por armazenar os dados do funcionário +class Funcionario: + def __init__(self, nome, salario, cargo): + self.nome = nome + self.salario = salario + self.cargo = cargo + +# Classe CalculadoraSalario: Responsável pelos cálculos relacionados ao salário +class CalculadoraSalario: + @staticmethod + def calcular_salario_liquido(funcionario, descontos): + return funcionario.salario - descontos + +# Classe GeradorRelatorio: Responsável pela geração de relatórios +class GeradorRelatorio: + @staticmethod + def gerar_relatorio(funcionario): + return f"Relatório: {funcionario.nome} - {funcionario.cargo} - R$ {funcionario.salario:.2f}" + +# Classe RepositorioFuncionario: Responsável pela persistência de dados +class RepositorioFuncionario: + @staticmethod + def salvar(funcionario): + print(f"Salvando {funcionario.nome} no banco de dados...") + +# Exemplo de Uso +if __name__ == "__main__": + # Criando um funcionário + funcionario = Funcionario("Ana Silva", 5000.0, "Desenvolvedora") + + # Instanciando as classes responsáveis por cada funcionalidade + calculadora = CalculadoraSalario() + gerador = GeradorRelatorio() + repositorio = RepositorioFuncionario() + + # Calculando o salário líquido + salario_liquido = calculadora.calcular_salario_liquido(funcionario, 500.0) + print(f"Salário líquido: R$ {salario_liquido:.2f}") + + # Gerando o relatório + relatorio = gerador.gerar_relatorio(funcionario) + print(relatorio) + + # Salvando o funcionário no banco de dados + repositorio.salvar(funcionario) \ No newline at end of file diff --git a/respExercicio12.py b/respExercicio12.py new file mode 100644 index 0000000..0bf8b58 --- /dev/null +++ b/respExercicio12.py @@ -0,0 +1,65 @@ +from abc import ABC, abstractmethod + +# Classe Funcionario: Responsável apenas por armazenar os dados do funcionário +class Funcionario: + def __init__(self, nome, salario, cargo): + self.nome = nome + self.salario = salario + self.cargo = cargo + +# Classe CalculadoraSalario: Responsável pelos cálculos relacionados ao salário +class CalculadoraSalario: + @staticmethod + def calcular_salario_liquido(funcionario, descontos): + return funcionario.salario - descontos + +# Classe GeradorRelatorio: Responsável pela geração de relatórios +class GeradorRelatorio: + @staticmethod + def gerar_relatorio(funcionario): + return f"Relatório: {funcionario.nome} - {funcionario.cargo} - R$ {funcionario.salario:.2f}" + +# Classe RepositorioFuncionario: Responsável pela persistência de dados +class RepositorioFuncionario: + @staticmethod + def salvar(funcionario): + print(f"Salvando {funcionario.nome} no banco de dados...") + +# Classe abstrata para cálculo de descontos +class CalculadorDesconto(ABC): + @abstractmethod + def calcular(self, valor): + """Método abstrato para calcular o desconto""" + pass + +# Implementação de diferentes tipos de desconto +class DescontoEstudante(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.9 # 10% de desconto + +class DescontoFuncionario(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.85 # 15% de desconto + +# Classe para processar pagamentos com diferentes descontos +class ProcessadorPagamento: + def processar(self, valor, calculador_desconto): + return calculador_desconto.calcular(valor) + +# Exemplo de Uso +if __name__ == "__main__": + # Uso do sistema + pagamento = ProcessadorPagamento() + valor_original = 1000.0 + + # Diferentes tipos de desconto + desconto_estudante = DescontoEstudante() + desconto_funcionario = DescontoFuncionario() + + # Processando pagamentos com diferentes descontos + valor_final1 = pagamento.processar(valor_original, desconto_estudante) + valor_final2 = pagamento.processar(valor_original, desconto_funcionario) + + # Exibindo os resultados + print(f"Estudante: R$ {valor_final1:.2f}") + print(f"Funcionário: R$ {valor_final2:.2f}") \ No newline at end of file diff --git a/respExercicio13.py b/respExercicio13.py new file mode 100644 index 0000000..43b5905 --- /dev/null +++ b/respExercicio13.py @@ -0,0 +1,117 @@ +from abc import ABC, abstractmethod + +# Classe Funcionario: Responsável apenas por armazenar os dados do funcionário +class Funcionario: + def __init__(self, nome, salario, cargo): + self.nome = nome + self.salario = salario + self.cargo = cargo + +# Classe CalculadoraSalario: Responsável pelos cálculos relacionados ao salário +class CalculadoraSalario: + @staticmethod + def calcular_salario_liquido(funcionario, descontos): + return funcionario.salario - descontos + +# Classe GeradorRelatorio: Responsável pela geração de relatórios +class GeradorRelatorio: + @staticmethod + def gerar_relatorio(funcionario): + return f"Relatório: {funcionario.nome} - {funcionario.cargo} - R$ {funcionario.salario:.2f}" + +# Classe RepositorioFuncionario: Responsável pela persistência de dados +class RepositorioFuncionario: + @staticmethod + def salvar(funcionario): + print(f"Salvando {funcionario.nome} no banco de dados...") + +# Classe abstrata para cálculo de descontos +class CalculadorDesconto(ABC): + @abstractmethod + def calcular(self, valor): + """Método abstrato para calcular o desconto""" + pass + +# Implementação de diferentes tipos de desconto +class DescontoEstudante(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.9 # 10% de desconto + +class DescontoFuncionario(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.85 # 15% de desconto + +# Classe para processar pagamentos com diferentes descontos +class ProcessadorPagamento: + def processar(self, valor, calculador_desconto): + return calculador_desconto.calcular(valor) + +# Classe base Veiculo +class Veiculo(ABC): + def __init__(self, velocidade_maxima): + self.velocidade_atual = 0 + self.velocidade_maxima = velocidade_maxima + + @abstractmethod + def acelerar(self): + """Aumenta a velocidade do veículo""" + pass + + @abstractmethod + def frear(self): + """Diminui a velocidade do veículo""" + pass + + def get_velocidade(self): + """Retorna a velocidade atual""" + return self.velocidade_atual + +# Classe Carro +class Carro(Veiculo): + def __init__(self): + super().__init__(180) # Velocidade máxima de 180 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 20, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 20, 0) + +# Classe Bicicleta +class Bicicleta(Veiculo): + def __init__(self): + super().__init__(50) # Velocidade máxima de 50 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 10, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 10, 0) + +# Classe Aviao +class Aviao(Veiculo): + def __init__(self): + super().__init__(900) # Velocidade máxima de 900 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 100, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 100, 0) + +# Função para testar veículos +def testar_veiculo(veiculo): + print(f"Testando {type(veiculo).__name__}") + veiculo.acelerar() + veiculo.acelerar() + print(f"Velocidade: {veiculo.get_velocidade()} km/h") + veiculo.frear() + print(f"Velocidade após frear: {veiculo.get_velocidade()} km/h") + +# Todos os veículos devem funcionar da mesma forma +if __name__ == "__main__": + carro = Carro() + bicicleta = Bicicleta() + + testar_veiculo(carro) + testar_veiculo(bicicleta) \ No newline at end of file diff --git a/respExercicio14.py b/respExercicio14.py new file mode 100644 index 0000000..12bbead --- /dev/null +++ b/respExercicio14.py @@ -0,0 +1,180 @@ +from abc import ABC, abstractmethod + +# Classe Funcionario: Responsável apenas por armazenar os dados do funcionário +class Funcionario: + def __init__(self, nome, salario, cargo): + self.nome = nome + self.salario = salario + self.cargo = cargo + +# Classe CalculadoraSalario: Responsável pelos cálculos relacionados ao salário +class CalculadoraSalario: + @staticmethod + def calcular_salario_liquido(funcionario, descontos): + return funcionario.salario - descontos + +# Classe GeradorRelatorio: Responsável pela geração de relatórios +class GeradorRelatorio: + @staticmethod + def gerar_relatorio(funcionario): + return f"Relatório: {funcionario.nome} - {funcionario.cargo} - R$ {funcionario.salario:.2f}" + +# Classe RepositorioFuncionario: Responsável pela persistência de dados +class RepositorioFuncionario: + @staticmethod + def salvar(funcionario): + print(f"Salvando {funcionario.nome} no banco de dados...") + +# Classe abstrata para cálculo de descontos +class CalculadorDesconto(ABC): + @abstractmethod + def calcular(self, valor): + """Método abstrato para calcular o desconto""" + pass + +# Implementação de diferentes tipos de desconto +class DescontoEstudante(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.9 # 10% de desconto + +class DescontoFuncionario(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.85 # 15% de desconto + +# Classe para processar pagamentos com diferentes descontos +class ProcessadorPagamento: + def processar(self, valor, calculador_desconto): + return calculador_desconto.calcular(valor) + +# Classe base Veiculo +class Veiculo(ABC): + def __init__(self, velocidade_maxima): + self.velocidade_atual = 0 + self.velocidade_maxima = velocidade_maxima + + @abstractmethod + def acelerar(self): + """Aumenta a velocidade do veículo""" + pass + + @abstractmethod + def frear(self): + """Diminui a velocidade do veículo""" + pass + + def get_velocidade(self): + """Retorna a velocidade atual""" + return self.velocidade_atual + +# Classe Carro +class Carro(Veiculo): + def __init__(self): + super().__init__(180) # Velocidade máxima de 180 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 20, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 20, 0) + +# Classe Bicicleta +class Bicicleta(Veiculo): + def __init__(self): + super().__init__(50) # Velocidade máxima de 50 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 10, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 10, 0) + +# Classe Aviao +class Aviao(Veiculo): + def __init__(self): + super().__init__(900) # Velocidade máxima de 900 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 100, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 100, 0) + +# Interfaces específicas +class Trabalhavel(ABC): + @abstractmethod + def trabalhar(self): + pass + +class Alimentavel(ABC): + @abstractmethod + def comer(self): + pass + +class Descansavel(ABC): + @abstractmethod + def dormir(self): + pass + +class Programavel(ABC): + @abstractmethod + def programar(self): + pass + +# Classes concretas +class Desenvolvedor(Trabalhavel, Alimentavel, Descansavel, Programavel): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f"{self.nome} está trabalhando.") + + def comer(self): + print(f"{self.nome} está comendo.") + + def dormir(self): + print(f"{self.nome} está dormindo.") + + def programar(self): + print(f"{self.nome} está programando.") + +class Gerente(Trabalhavel, Alimentavel, Descansavel): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f"{self.nome} está trabalhando.") + + def comer(self): + print(f"{self.nome} está comendo.") + + def dormir(self): + print(f"{self.nome} está dormindo.") + +class Robo(Trabalhavel, Programavel): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f"{self.nome} está trabalhando.") + + def programar(self): + print(f"{self.nome} está programando.") + +# Exemplo de Uso +if __name__ == "__main__": + desenvolvedor = Desenvolvedor("Ana") + gerente = Gerente("Carlos") + robo = Robo("R2D2") + + # Desenvolvedor faz tudo + desenvolvedor.trabalhar() + desenvolvedor.comer() + desenvolvedor.programar() + + # Gerente não programa + gerente.trabalhar() + gerente.comer() + + # Robô não come nem dorme + robo.trabalhar() + robo.programar() \ No newline at end of file diff --git a/respExercicio15.py b/respExercicio15.py new file mode 100644 index 0000000..66a95e0 --- /dev/null +++ b/respExercicio15.py @@ -0,0 +1,208 @@ +from abc import ABC, abstractmethod + +# Classe Funcionario: Responsável apenas por armazenar os dados do funcionário +class Funcionario: + def __init__(self, nome, salario, cargo): + self.nome = nome + self.salario = salario + self.cargo = cargo + +# Classe CalculadoraSalario: Responsável pelos cálculos relacionados ao salário +class CalculadoraSalario: + @staticmethod + def calcular_salario_liquido(funcionario, descontos): + return funcionario.salario - descontos + +# Classe GeradorRelatorio: Responsável pela geração de relatórios +class GeradorRelatorio: + @staticmethod + def gerar_relatorio(funcionario): + return f"Relatório: {funcionario.nome} - {funcionario.cargo} - R$ {funcionario.salario:.2f}" + +# Classe RepositorioFuncionario: Responsável pela persistência de dados +class RepositorioFuncionario: + @staticmethod + def salvar(funcionario): + print(f"Salvando {funcionario.nome} no banco de dados...") + +# Classe abstrata para cálculo de descontos +class CalculadorDesconto(ABC): + @abstractmethod + def calcular(self, valor): + """Método abstrato para calcular o desconto""" + pass + +# Implementação de diferentes tipos de desconto +class DescontoEstudante(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.9 # 10% de desconto + +class DescontoFuncionario(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.85 # 15% de desconto + +# Classe para processar pagamentos com diferentes descontos +class ProcessadorPagamento: + def processar(self, valor, calculador_desconto): + return calculador_desconto.calcular(valor) + +# Classe base Veiculo +class Veiculo(ABC): + def __init__(self, velocidade_maxima): + self.velocidade_atual = 0 + self.velocidade_maxima = velocidade_maxima + + @abstractmethod + def acelerar(self): + """Aumenta a velocidade do veículo""" + pass + + @abstractmethod + def frear(self): + """Diminui a velocidade do veículo""" + pass + + def get_velocidade(self): + """Retorna a velocidade atual""" + return self.velocidade_atual + +# Classe Carro +class Carro(Veiculo): + def __init__(self): + super().__init__(180) # Velocidade máxima de 180 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 20, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 20, 0) + +# Classe Bicicleta +class Bicicleta(Veiculo): + def __init__(self): + super().__init__(50) # Velocidade máxima de 50 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 10, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 10, 0) + +# Classe Aviao +class Aviao(Veiculo): + def __init__(self): + super().__init__(900) # Velocidade máxima de 900 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 100, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 100, 0) + +# Interfaces específicas +class Trabalhavel(ABC): + @abstractmethod + def trabalhar(self): + pass + +class Alimentavel(ABC): + @abstractmethod + def comer(self): + pass + +class Descansavel(ABC): + @abstractmethod + def dormir(self): + pass + +class Programavel(ABC): + @abstractmethod + def programar(self): + pass + +# Classes concretas +class Desenvolvedor(Trabalhavel, Alimentavel, Descansavel, Programavel): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f"{self.nome} está trabalhando.") + + def comer(self): + print(f"{self.nome} está comendo.") + + def dormir(self): + print(f"{self.nome} está dormindo.") + + def programar(self): + print(f"{self.nome} está programando.") + +class Gerente(Trabalhavel, Alimentavel, Descansavel): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f"{self.nome} está trabalhando.") + + def comer(self): + print(f"{self.nome} está comendo.") + + def dormir(self): + print(f"{self.nome} está dormindo.") + +class Robo(Trabalhavel, Programavel): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f"{self.nome} está trabalhando.") + + def programar(self): + print(f"{self.nome} está programando.") + +# Abstração para serviços de notificação +class ServicoNotificacao(ABC): + @abstractmethod + def enviar(self, mensagem): + """Método abstrato para enviar notificações""" + pass + +# Implementação do serviço de email +class EmailService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando email: {mensagem}") + +# Implementação do serviço de SMS +class SMSService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando SMS: {mensagem}") + +# Implementação do serviço de notificação push +class PushService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando push: {mensagem}") + +# Classe NotificacaoService que depende da abstração +class NotificacaoService: + def __init__(self, servico_notificacao: ServicoNotificacao): + self.servico_notificacao = servico_notificacao + + def notificar(self, mensagem): + self.servico_notificacao.enviar(mensagem) + +# Exemplo de Uso +if __name__ == "__main__": + # 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..e444b11 --- /dev/null +++ b/respExercicio16.py @@ -0,0 +1,239 @@ +from abc import ABC, abstractmethod + +# Classe Funcionario: Responsável apenas por armazenar os dados do funcionário +class Funcionario: + def __init__(self, nome, salario, cargo): + self.nome = nome + self.salario = salario + self.cargo = cargo + +# Classe CalculadoraSalario: Responsável pelos cálculos relacionados ao salário +class CalculadoraSalario: + @staticmethod + def calcular_salario_liquido(funcionario, descontos): + return funcionario.salario - descontos + +# Classe GeradorRelatorio: Responsável pela geração de relatórios +class GeradorRelatorio: + @staticmethod + def gerar_relatorio(funcionario): + return f"Relatório: {funcionario.nome} - {funcionario.cargo} - R$ {funcionario.salario:.2f}" + +# Classe RepositorioFuncionario: Responsável pela persistência de dados +class RepositorioFuncionario: + @staticmethod + def salvar(funcionario): + print(f"Salvando {funcionario.nome} no banco de dados...") + +# Classe abstrata para cálculo de descontos +class CalculadorDesconto(ABC): + @abstractmethod + def calcular(self, valor): + """Método abstrato para calcular o desconto""" + pass + +# Implementação de diferentes tipos de desconto +class DescontoEstudante(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.9 # 10% de desconto + +class DescontoFuncionario(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.85 # 15% de desconto + +# Classe para processar pagamentos com diferentes descontos +class ProcessadorPagamentoDesconto: + def processar(self, valor, calculador_desconto): + return calculador_desconto.calcular(valor) + +# Classe base Veiculo +class Veiculo(ABC): + def __init__(self, velocidade_maxima): + self.velocidade_atual = 0 + self.velocidade_maxima = velocidade_maxima + + @abstractmethod + def acelerar(self): + """Aumenta a velocidade do veículo""" + pass + + @abstractmethod + def frear(self): + """Diminui a velocidade do veículo""" + pass + + def get_velocidade(self): + """Retorna a velocidade atual""" + return self.velocidade_atual + +# Classe Carro +class Carro(Veiculo): + def __init__(self): + super().__init__(180) # Velocidade máxima de 180 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 20, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 20, 0) + +# Classe Bicicleta +class Bicicleta(Veiculo): + def __init__(self): + super().__init__(50) # Velocidade máxima de 50 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 10, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 10, 0) + +# Classe Aviao +class Aviao(Veiculo): + def __init__(self): + super().__init__(900) # Velocidade máxima de 900 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 100, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 100, 0) + +# Interfaces específicas +class Trabalhavel(ABC): + @abstractmethod + def trabalhar(self): + pass + +class Alimentavel(ABC): + @abstractmethod + def comer(self): + pass + +class Descansavel(ABC): + @abstractmethod + def dormir(self): + pass + +class Programavel(ABC): + @abstractmethod + def programar(self): + pass + +# Classes concretas +class Desenvolvedor(Trabalhavel, Alimentavel, Descansavel, Programavel): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f"{self.nome} está trabalhando.") + + def comer(self): + print(f"{self.nome} está comendo.") + + def dormir(self): + print(f"{self.nome} está dormindo.") + + def programar(self): + print(f"{self.nome} está programando.") + +class Gerente(Trabalhavel, Alimentavel, Descansavel): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f"{self.nome} está trabalhando.") + + def comer(self): + print(f"{self.nome} está comendo.") + + def dormir(self): + print(f"{self.nome} está dormindo.") + +class Robo(Trabalhavel, Programavel): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f"{self.nome} está trabalhando.") + + def programar(self): + print(f"{self.nome} está programando.") + +# Abstração para serviços de notificação +class ServicoNotificacao(ABC): + @abstractmethod + def enviar(self, mensagem): + """Método abstrato para enviar notificações""" + pass + +# Implementação do serviço de email +class EmailService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando email: {mensagem}") + +# Implementação do serviço de SMS +class SMSService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando SMS: {mensagem}") + +# Implementação do serviço de notificação push +class PushService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando push: {mensagem}") + +# Classe NotificacaoService que depende da abstração +class NotificacaoService: + def __init__(self, servico_notificacao: ServicoNotificacao): + self.servico_notificacao = servico_notificacao + + def notificar(self, mensagem): + self.servico_notificacao.enviar(mensagem) + +# Interface esperada pelo sistema +class ProcessadorPagamento(ABC): + @abstractmethod + def processar_pagamento(self, valor, cartao): + pass + +# Implementação interna do processador de pagamento +class ProcessadorPagamentoInterno(ProcessadorPagamento): + def processar_pagamento(self, valor, cartao): + print(f"Processador Interno: Processando R$ {valor:.2f} no cartão {cartao}") + +# Serviço externo (não pode ser modificado) +class PayPalAPI: + def make_payment(self, amount, credit_card_number): + return f"PayPal: Processando ${amount} no cartão {credit_card_number}" + +# Adapter para integrar PayPalAPI com o sistema +class PayPalAdapter(ProcessadorPagamento): + def __init__(self, paypal_api): + self.paypal_api = paypal_api + + def processar_pagamento(self, valor, cartao): + resultado = self.paypal_api.make_payment(valor, cartao) + print(resultado) + +# Classe SistemaPagamento que usa qualquer ProcessadorPagamento +class SistemaPagamento: + def __init__(self, processador_pagamento: ProcessadorPagamento): + self.processador_pagamento = processador_pagamento + + def realizar_pagamento(self, valor, cartao): + self.processador_pagamento.processar_pagamento(valor, cartao) + +# Exemplo de Uso +if __name__ == "__main__": + # 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..260a580 --- /dev/null +++ b/respExercicio17.py @@ -0,0 +1,298 @@ +from abc import ABC, abstractmethod + +# Classe Funcionario: Responsável apenas por armazenar os dados do funcionário +class Funcionario: + def __init__(self, nome, salario, cargo): + self.nome = nome + self.salario = salario + self.cargo = cargo + +# Classe CalculadoraSalario: Responsável pelos cálculos relacionados ao salário +class CalculadoraSalario: + @staticmethod + def calcular_salario_liquido(funcionario, descontos): + return funcionario.salario - descontos + +# Classe GeradorRelatorio: Responsável pela geração de relatórios +class GeradorRelatorio: + @staticmethod + def gerar_relatorio(funcionario): + return f"Relatório: {funcionario.nome} - {funcionario.cargo} - R$ {funcionario.salario:.2f}" + +# Classe RepositorioFuncionario: Responsável pela persistência de dados +class RepositorioFuncionario: + @staticmethod + def salvar(funcionario): + print(f"Salvando {funcionario.nome} no banco de dados...") + +# Classe abstrata para cálculo de descontos +class CalculadorDesconto(ABC): + @abstractmethod + def calcular(self, valor): + """Método abstrato para calcular o desconto""" + pass + +# Implementação de diferentes tipos de desconto +class DescontoEstudante(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.9 # 10% de desconto + +class DescontoFuncionario(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.85 # 15% de desconto + +# Classe para processar pagamentos com diferentes descontos +class ProcessadorPagamentoDesconto: + def processar(self, valor, calculador_desconto): + return calculador_desconto.calcular(valor) + +# Classe base Veiculo +class Veiculo(ABC): + def __init__(self, velocidade_maxima): + self.velocidade_atual = 0 + self.velocidade_maxima = velocidade_maxima + + @abstractmethod + def acelerar(self): + """Aumenta a velocidade do veículo""" + pass + + @abstractmethod + def frear(self): + """Diminui a velocidade do veículo""" + pass + + def get_velocidade(self): + """Retorna a velocidade atual""" + return self.velocidade_atual + +# Classe Carro +class Carro(Veiculo): + def __init__(self): + super().__init__(180) # Velocidade máxima de 180 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 20, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 20, 0) + +# Classe Bicicleta +class Bicicleta(Veiculo): + def __init__(self): + super().__init__(50) # Velocidade máxima de 50 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 10, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 10, 0) + +# Classe Aviao +class Aviao(Veiculo): + def __init__(self): + super().__init__(900) # Velocidade máxima de 900 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 100, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 100, 0) + +# Interfaces específicas +class Trabalhavel(ABC): + @abstractmethod + def trabalhar(self): + pass + +class Alimentavel(ABC): + @abstractmethod + def comer(self): + pass + +class Descansavel(ABC): + @abstractmethod + def dormir(self): + pass + +class Programavel(ABC): + @abstractmethod + def programar(self): + pass + +# Classes concretas +class Desenvolvedor(Trabalhavel, Alimentavel, Descansavel, Programavel): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f"{self.nome} está trabalhando.") + + def comer(self): + print(f"{self.nome} está comendo.") + + def dormir(self): + print(f"{self.nome} está dormindo.") + + def programar(self): + print(f"{self.nome} está programando.") + +class Gerente(Trabalhavel, Alimentavel, Descansavel): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f"{self.nome} está trabalhando.") + + def comer(self): + print(f"{self.nome} está comendo.") + + def dormir(self): + print(f"{self.nome} está dormindo.") + +class Robo(Trabalhavel, Programavel): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f"{self.nome} está trabalhando.") + + def programar(self): + print(f"{self.nome} está programando.") + +# Abstração para serviços de notificação +class ServicoNotificacao(ABC): + @abstractmethod + def enviar(self, mensagem): + """Método abstrato para enviar notificações""" + pass + +# Implementação do serviço de email +class EmailService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando email: {mensagem}") + +# Implementação do serviço de SMS +class SMSService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando SMS: {mensagem}") + +# Implementação do serviço de notificação push +class PushService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando push: {mensagem}") + +# Classe NotificacaoService que depende da abstração +class NotificacaoService: + def __init__(self, servico_notificacao: ServicoNotificacao): + self.servico_notificacao = servico_notificacao + + def notificar(self, mensagem): + self.servico_notificacao.enviar(mensagem) + +# Interface esperada pelo sistema +class ProcessadorPagamento(ABC): + @abstractmethod + def processar_pagamento(self, valor, cartao): + pass + +# Implementação interna do processador de pagamento +class ProcessadorPagamentoInterno(ProcessadorPagamento): + def processar_pagamento(self, valor, cartao): + print(f"Processador Interno: Processando R$ {valor:.2f} no cartão {cartao}") + +# Serviço externo (não pode ser modificado) +class PayPalAPI: + def make_payment(self, amount, credit_card_number): + return f"PayPal: Processando ${amount} no cartão {credit_card_number}" + +# Adapter para integrar PayPalAPI com o sistema +class PayPalAdapter(ProcessadorPagamento): + def __init__(self, paypal_api): + self.paypal_api = paypal_api + + def processar_pagamento(self, valor, cartao): + resultado = self.paypal_api.make_payment(valor, cartao) + print(resultado) + +# Classe SistemaPagamento que usa qualquer ProcessadorPagamento +class SistemaPagamento: + def __init__(self, processador_pagamento: ProcessadorPagamento): + self.processador_pagamento = processador_pagamento + + def realizar_pagamento(self, valor, cartao): + self.processador_pagamento.processar_pagamento(valor, cartao) + +# Interface base para bebidas +class Bebida(ABC): + @abstractmethod + def get_descricao(self): + pass + + @abstractmethod + def get_preco(self): + pass + +# Bebidas concretas +class Cafe(Bebida): + def get_descricao(self): + return "Café" + + def get_preco(self): + return 5.0 + +class Cha(Bebida): + def get_descricao(self): + return "Chá" + + def get_preco(self): + return 3.0 + +# Decorator base +class BebidaDecorator(Bebida): + def __init__(self, bebida: Bebida): + self.bebida = bebida + + @abstractmethod + def get_descricao(self): + pass + + @abstractmethod + def get_preco(self): + pass + +# Decorators concretos +class LeiteDecorator(BebidaDecorator): + def get_descricao(self): + return f"{self.bebida.get_descricao()} com Leite" + + def get_preco(self): + return self.bebida.get_preco() + 2.0 + +class AcucarDecorator(BebidaDecorator): + def get_descricao(self): + return f"{self.bebida.get_descricao()} com Açúcar" + + def get_preco(self): + return self.bebida.get_preco() + 0.5 + +class ChantillyDecorator(BebidaDecorator): + def get_descricao(self): + return f"{self.bebida.get_descricao()} com Chantilly" + + def get_preco(self): + return self.bebida.get_preco() + 3.0 + +# Exemplo de Uso +if __name__ == "__main__": + # 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..32a26f8 --- /dev/null +++ b/respExercicio18.py @@ -0,0 +1,368 @@ +from abc import ABC, abstractmethod + +# Classe Funcionario: Responsável apenas por armazenar os dados do funcionário +class Funcionario: + def __init__(self, nome, salario, cargo): + self.nome = nome + self.salario = salario + self.cargo = cargo + +# Classe CalculadoraSalario: Responsável pelos cálculos relacionados ao salário +class CalculadoraSalario: + @staticmethod + def calcular_salario_liquido(funcionario, descontos): + return funcionario.salario - descontos + +# Classe GeradorRelatorio: Responsável pela geração de relatórios +class GeradorRelatorio: + @staticmethod + def gerar_relatorio(funcionario): + return f"Relatório: {funcionario.nome} - {funcionario.cargo} - R$ {funcionario.salario:.2f}" + +# Classe RepositorioFuncionario: Responsável pela persistência de dados +class RepositorioFuncionario: + @staticmethod + def salvar(funcionario): + print(f"Salvando {funcionario.nome} no banco de dados...") + +# Classe abstrata para cálculo de descontos +class CalculadorDesconto(ABC): + @abstractmethod + def calcular(self, valor): + """Método abstrato para calcular o desconto""" + pass + +# Implementação de diferentes tipos de desconto +class DescontoEstudante(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.9 # 10% de desconto + +class DescontoFuncionario(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.85 # 15% de desconto + +# Classe para processar pagamentos com diferentes descontos +class ProcessadorPagamentoDesconto: + def processar(self, valor, calculador_desconto): + return calculador_desconto.calcular(valor) + +# Classe base Veiculo +class Veiculo(ABC): + def __init__(self, velocidade_maxima): + self.velocidade_atual = 0 + self.velocidade_maxima = velocidade_maxima + + @abstractmethod + def acelerar(self): + """Aumenta a velocidade do veículo""" + pass + + @abstractmethod + def frear(self): + """Diminui a velocidade do veículo""" + pass + + def get_velocidade(self): + """Retorna a velocidade atual""" + return self.velocidade_atual + +# Classe Carro +class Carro(Veiculo): + def __init__(self): + super().__init__(180) # Velocidade máxima de 180 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 20, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 20, 0) + +# Classe Bicicleta +class Bicicleta(Veiculo): + def __init__(self): + super().__init__(50) # Velocidade máxima de 50 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 10, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 10, 0) + +# Classe Aviao +class Aviao(Veiculo): + def __init__(self): + super().__init__(900) # Velocidade máxima de 900 km/h + + def acelerar(self): + self.velocidade_atual = min(self.velocidade_atual + 100, self.velocidade_maxima) + + def frear(self): + self.velocidade_atual = max(self.velocidade_atual - 100, 0) + +# Interfaces específicas +class Trabalhavel(ABC): + @abstractmethod + def trabalhar(self): + pass + +class Alimentavel(ABC): + @abstractmethod + def comer(self): + pass + +class Descansavel(ABC): + @abstractmethod + def dormir(self): + pass + +class Programavel(ABC): + @abstractmethod + def programar(self): + pass + +# Classes concretas +class Desenvolvedor(Trabalhavel, Alimentavel, Descansavel, Programavel): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f"{self.nome} está trabalhando.") + + def comer(self): + print(f"{self.nome} está comendo.") + + def dormir(self): + print(f"{self.nome} está dormindo.") + + def programar(self): + print(f"{self.nome} está programando.") + +class Gerente(Trabalhavel, Alimentavel, Descansavel): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f"{self.nome} está trabalhando.") + + def comer(self): + print(f"{self.nome} está comendo.") + + def dormir(self): + print(f"{self.nome} está dormindo.") + +class Robo(Trabalhavel, Programavel): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f"{self.nome} está trabalhando.") + + def programar(self): + print(f"{self.nome} está programando.") + +# Abstração para serviços de notificação +class ServicoNotificacao(ABC): + @abstractmethod + def enviar(self, mensagem): + """Método abstrato para enviar notificações""" + pass + +# Implementação do serviço de email +class EmailService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando email: {mensagem}") + +# Implementação do serviço de SMS +class SMSService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando SMS: {mensagem}") + +# Implementação do serviço de notificação push +class PushService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando push: {mensagem}") + +# Classe NotificacaoService que depende da abstração +class NotificacaoService: + def __init__(self, servico_notificacao: ServicoNotificacao): + self.servico_notificacao = servico_notificacao + + def notificar(self, mensagem): + self.servico_notificacao.enviar(mensagem) + +# Interface esperada pelo sistema +class ProcessadorPagamento(ABC): + @abstractmethod + def processar_pagamento(self, valor, cartao): + pass + +# Implementação interna do processador de pagamento +class ProcessadorPagamentoInterno(ProcessadorPagamento): + def processar_pagamento(self, valor, cartao): + print(f"Processador Interno: Processando R$ {valor:.2f} no cartão {cartao}") + +# Serviço externo (não pode ser modificado) +class PayPalAPI: + def make_payment(self, amount, credit_card_number): + return f"PayPal: Processando ${amount} no cartão {credit_card_number}" + +# Adapter para integrar PayPalAPI com o sistema +class PayPalAdapter(ProcessadorPagamento): + def __init__(self, paypal_api): + self.paypal_api = paypal_api + + def processar_pagamento(self, valor, cartao): + resultado = self.paypal_api.make_payment(valor, cartao) + print(resultado) + +# Classe SistemaPagamento que usa qualquer ProcessadorPagamento +class SistemaPagamento: + def __init__(self, processador_pagamento: ProcessadorPagamento): + self.processador_pagamento = processador_pagamento + + def realizar_pagamento(self, valor, cartao): + self.processador_pagamento.processar_pagamento(valor, cartao) + +# Interface base para bebidas +class Bebida(ABC): + @abstractmethod + def get_descricao(self): + pass + + @abstractmethod + def get_preco(self): + pass + +# Bebidas concretas +class Cafe(Bebida): + def get_descricao(self): + return "Café" + + def get_preco(self): + return 5.0 + +class Cha(Bebida): + def get_descricao(self): + return "Chá" + + def get_preco(self): + return 3.0 + +# Decorator base +class BebidaDecorator(Bebida): + def __init__(self, bebida: Bebida): + self.bebida = bebida + + @abstractmethod + def get_descricao(self): + pass + + @abstractmethod + def get_preco(self): + pass + +# Decorators concretos +class LeiteDecorator(BebidaDecorator): + def get_descricao(self): + return f"{self.bebida.get_descricao()} com Leite" + + def get_preco(self): + return self.bebida.get_preco() + 2.0 + +class AcucarDecorator(BebidaDecorator): + def get_descricao(self): + return f"{self.bebida.get_descricao()} com Açúcar" + + def get_preco(self): + return self.bebida.get_preco() + 0.5 + +class ChantillyDecorator(BebidaDecorator): + def get_descricao(self): + return f"{self.bebida.get_descricao()} com Chantilly" + + def get_preco(self): + return self.bebida.get_preco() + 3.0 + +# Sistema complexo +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") + +# Facade para simplificar o uso do sistema +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.pipoca.ligar() + self.pipoca.fazer_pipoca() + self.luzes.diminuir(10) + self.projetor.ligar() + self.projetor.modo_widescreen() + self.amplificador.ligar() + self.amplificador.definir_volume(5) + self.dvd.ligar() + self.dvd.reproduzir(filme) + + def fim_filme(self): + print("Filme finalizado!") + print("Desligando todos os componentes...") + +# Exemplo de Uso +if __name__ == "__main__": + # Uso complexo (sem facade) + amplificador = Amplificador() + dvd = DVDPlayer() + projetor = Projetor() + luzes = Luzes() + pipoca = PipocaPopper() + + # Muitas chamadas necessárias + amplificador.ligar() + amplificador.definir_volume(5) + dvd.ligar() + projetor.ligar() + luzes.diminuir(10) + pipoca.ligar() + pipoca.fazer_pipoca() + dvd.reproduzir("Matrix") + + print("\n--- Usando Facade ---\n") + + # Uso simples (com facade) + home_theater = HomeTheaterFacade() + home_theater.assistir_filme("Matrix") + home_theater.fim_filme() \ No newline at end of file diff --git a/tempCodeRunnerFile.py b/tempCodeRunnerFile.py new file mode 100644 index 0000000..b4fa555 --- /dev/null +++ b/tempCodeRunnerFile.py @@ -0,0 +1 @@ +"João" \ No newline at end of file