Exercícios POO
# Exercício 1: Figuras Geométricas


from abc import ABC, abstractmethod
import math

class FiguraGeometrica(ABC):
    @abstractmethod
    def calcular_area(self):
        pass

class Retangulo(FiguraGeometrica):
    def __init__(self, base, altura):
        self.base = base
        self.altura = altura

    def calcular_area(self):
        return self.base * self.altura

class Circulo(FiguraGeometrica):
    def __init__(self, raio):
        self.raio = raio

    def calcular_area(self):
        return math.pi * self.raio ** 2

class Triangulo(FiguraGeometrica):
    def __init__(self, base, altura):
        self.base = base
        self.altura = altura

    def calcular_area(self):
        return (self.base * self.altura) / 2

# Exemplo de uso
retangulo = Retangulo(5, 10)
circulo = Circulo(3)
triangulo = Triangulo(4, 6)

print(f"\nÁrea do Retângulo: {retangulo.calcular_area()}")
print(f"Área do Círculo: {circulo.calcular_area()}")
print(f"Área do Triângulo: {triangulo.calcular_area()}")
exercicio_abstracao/exercicio_1.py
davinyleticia/exercicio_poo_python
from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def emitir_som(self):
        pass

    @abstractmethod
    def mover(self):
        pass

class Cachorro(Animal):
    def emitir_som(self):
        return "Au Au"

    def mover(self):
        return "Correndo"

class Gato(Animal):
    def emitir_som(self):
        return "Miau"

    def mover(self):
        return "Andando"

class Pato(Animal):
    def emitir_som(self):
        return "Quack"

    def mover(self):
        return "Nadando"

# Exemplo de uso
cachorro = Cachorro()
gato = Gato()
pato = Pato()

print(f"\nCachorro faz: {cachorro.emitir_som()}, Movendo-se: {cachorro.mover()}")
print(f"Gato faz: {gato.emitir_som()}, Movendo-se: {gato.mover()}")
print(f"Pato faz: {pato.emitir_som()}, Movendo-se: {pato.mover()}")
exercicio_abstracao/exercicio_2.py
davinyleticia/exercicio_poo_python
# Exercício 3: Veículos


from abc import ABC, abstractmethod

class Veiculo(ABC):
    @abstractmethod
    def acelerar(self):
        pass

    @abstractmethod
    def frear(self):
        pass

class Carro(Veiculo):
    def acelerar(self):
        return "Carro acelerando"

    def frear(self):
        return "Carro freando"

class Moto(Veiculo):
    def acelerar(self):
        return "Moto acelerando"

    def frear(self):
        return "Moto freando"

class Caminhao(Veiculo):
    def acelerar(self):
        return "Caminhão acelerando"

    def frear(self):
        return "Caminhão freando"

# Exemplo de uso
carro = Carro()
moto = Moto()
caminhao = Caminhao()

print(carro.acelerar())
print(carro.frear())

print(moto.acelerar())
print(moto.frear())

print(caminhao.acelerar())
print(caminhao.frear())
exercicio_abstracao/exercicio_3.py
davinyleticia/exercicio_poo_python
#Exercício 4: Produtos


from abc import ABC, abstractmethod

class Produto(ABC):
    @abstractmethod
    def calcular_preco(self):
        pass

    @abstractmethod
    def descricao(self):
        pass

class Livro(Produto):
    def __init__(self, titulo, autor, preco):
        self.titulo = titulo
        self.autor = autor
        self.preco = preco

    def calcular_preco(self):
        return self.preco

    def descricao(self):
        return f"Livro: {self.titulo}, Autor: {self.autor}"

class Eletronico(Produto):
    def __init__(self, nome, preco, marca):
        self.nome = nome
        self.preco = preco
        self.marca = marca

    def calcular_preco(self):
        return self.preco

    def descricao(self):
        return f"Eletrônico: {self.nome}, Marca: {self.marca}"

class Alimento(Produto):
    def __init__(self, nome, preco, data_validade):
        self.nome = nome
        self.preco = preco
        self.data_validade = data_validade

    def calcular_preco(self):
        return self.preco

    def descricao(self):
        return f"Alimento: {self.nome}, Data de Validade: {self.data_validade}"

# Exemplo de uso
livro = Livro("\nO Senhor dos Anéis", "J.R.R. Tolkien", 49.99)
eletronico = Eletronico("\nSmartphone", 999.99, "Samsung")
alimento = Alimento("\nMaçã", 2.50, "2023-09-30")

print(livro.descricao())
print(f"\nPreço: R${livro.calcular_preco():.2f}")

print(eletronico.descricao())
print(f"\nPreço: R${eletronico.calcular_preco():.2f}")

print(alimento.descricao())
print(f"\nPreço: R${alimento.calcular_preco():.2f}")
exercicio_abstracao/exercicio_4.py
davinyleticia/exercicio_poo_python
#Exercício 5: Formas de Pagamento


from abc import ABC, abstractmethod

class FormaPagamento(ABC):
    @abstractmethod
    def calcular_desconto(self, valor):
        pass

    @abstractmethod
    def calcular_parcelas(self, valor, numero_parcelas):
        pass

class CartaoCredito(FormaPagamento):
    def calcular_desconto(self, valor):
        return valor * 0.05

    def calcular_parcelas(self, valor, numero_parcelas):
        return valor / numero_parcelas

class Boleto(FormaPagamento):
    def calcular_desconto(self, valor):
        return valor * 0.03

    def calcular_parcelas(self, valor, numero_parcelas):
        return valor / numero_parcelas

class Transferencia(FormaPagamento):
    def calcular_desconto(self, valor):
        return valor * 0.02

    def calcular_parcelas(self, valor, numero_parcelas):
        return valor / numero_parcelas

# Exemplo de uso
cartao = CartaoCredito()
boleto = Boleto()
transferencia = Transferencia()

valor_compra = 1000.0
numero_parcelas = 3

desconto_cartao = cartao.calcular_desconto(valor_compra)
parcelas_cartao = cartao.calcular_parcelas(valor_compra, numero_parcelas)

desconto_boleto = boleto.calcular_desconto(valor_compra)
parcelas_boleto = boleto.calcular_parcelas(valor_compra, numero_parcelas)

desconto_transferencia = transferencia.calcular_desconto(valor_compra)
parcelas_transferencia = transferencia.calcular_parcelas(valor_compra, numero_parcelas)

print("Pagamento com Cartão de Crédito:")
print(f"Desconto: R${desconto_cartao:.2f}")
print(f"Parcelas de R${parcelas_cartao:.2f} cada")

print("\nPagamento com Boleto:")
print(f"Desconto: R${desconto_boleto:.2f}")
print(f"Parcelas de R${parcelas_boleto:.2f} cada")

print("\nPagamento com Transferência:")
print(f"Desconto: R${desconto_transferencia:.2f}")
print(f"Parcelas de R${parcelas_transferencia:.2f} cada")
exercicio_abstracao/exercicio_5.py
davinyleticia/exercicio_poo_python
class Veiculo:
    def __init__(self, modelo, ano, preco):
        self.modelo = modelo
        self.ano = ano
        self.preco = preco

    def calcular_imposto(self):
        return 0.10 * self.preco

class Carro(Veiculo):
    def __init__(self, modelo, ano, preco, marca):
        super().__init__(modelo, ano, preco)
        self.marca = marca

    def desconto(self):
        return 0.05 * self.preco

class Moto(Veiculo):
    def __init__(self, modelo, ano, preco, cilindrada):
        super().__init__(modelo, ano, preco)
        self.cilindrada = cilindrada

    def calcular_imposto(self):
        return 0.05 * self.preco

# Criar instâncias de Carro e Moto
carro = Carro("Toyota Corolla", 2022, 60000.0, "Toyota")
moto = Moto("Honda CBR", 2021, 12000.0, 600)

# Calcular e imprimir o imposto a ser pago por cada veículo
print(f"Imposto do carro: R${carro.calcular_imposto()}")
print(f"Imposto da moto: R${moto.calcular_imposto()}")
exercicio_casa/resolucao_1.py
davinyleticia/exercicio_poo_python
from abc import ABC, abstractmethod

class Funcionario(ABC):
    def __init__(self, nome, salario=0):
        self.nome = nome
        self.salario = salario

    @abstractmethod
    def calcular_pagamento(self):
        pass

class FuncionarioTemporario(Funcionario):
    def __init__(self, nome, salario_por_hora, horas_trabalhadas):
        super().__init__(nome)
        self.salario_por_hora = salario_por_hora
        self.horas_trabalhadas = horas_trabalhadas

    def calcular_pagamento(self):
        return self.salario_por_hora * self.horas_trabalhadas

class FuncionarioIntegral(Funcionario):
    def __init__(self, nome, salario_mensal):
        super().__init__(nome, salario_mensal)

    def calcular_pagamento(self):
        return self.salario

# Criar instâncias de FuncionarioTemporario e FuncionarioIntegral
temporario = FuncionarioTemporario("João", 15.0, 40)
integral = FuncionarioIntegral("Maria", 3000.0)

# Calcular e imprimir o pagamento de cada funcionário
print(f"Salário de {temporario.nome}: R${temporario.calcular_pagamento()}")
print(f"Salário de {integral.nome}: R${integral.calcular_pagamento()}")
exercicio_casa/resolucao_2.py
davinyleticia/exercicio_poo_python
# exercício 1 - Conta Bancaria

class ContaBancaria:
    def __init__(self, numero_conta, titular_conta):
        self.numero_conta = numero_conta
        self.titular_conta = titular_conta
        self.saldo = 0.0 # saldo inicial definido com 0.0
    
    def depositar(self, valor):
        if valor > 0:
            text = f'Valor depositado de R${valor}, realizado com sucesso.'
            self.saldo =+ valor   # self.saldo = self.saldo + valor
            print(text)
        else:
            print('O valor do depósito deve ser maior que 0')
        
    def sacar(self, valor):
        if valor > 0:
            if self.saldo >= valor:
                self.saldo -= valor
                print(f'Saque de R${valor} realizado com sucesso')
            else: 
                print("saldo insuficiente para realizar o saque")
        else:
            print("O valor do saque deve ser maior que zero.")
            

contaDaviny = ContaBancaria(202301, "Daviny Letícia")

contaDaviny.depositar(100)

contaDaviny.sacar(10)

print(contaDaviny.saldo)

contaLais = ContaBancaria(202302, "Lais")

contaLais.depositar(80)

contaLais.sacar(1000)
exercicio_class/resolucao_1.py
davinyleticia/exercicio_poo_python
# exercício 2 - Retangulo

class Retangulo:
    def __init__(self, largura, altura):
        self.largura = largura
        self.altura = altura
        
    def calcular_area(self):
        # print(f'calcular a área{self.largura * self.altura}')
        return self.largura * self.altura
    
    def calcular_perimetro(self):
        return 2 * (self.largura + self.altura)
    
    
casa_fabiana = Retangulo(5.0, 3.0)

print(f'A casa da Fabiana, tem: {casa_fabiana.calcular_area()} área')

print(f'a casa da fabiana tem {casa_fabiana.calcular_perimetro()} de perímetro')
    


casa_daviny = Retangulo(9.0, 10.5)

print(casa_daviny.calcular_area())
print(casa_daviny.calcular_perimetro())
print(casa_daviny.largura)
exercicio_class/resolucao_2.py
davinyleticia/exercicio_poo_python
# Exercício 1: Catálogo de Produtos

class Produto:
    def __init__(self, nome, preco):
        self._nome = nome   # Atributo protegido
        self._preco = preco # Atributo protegido

    def get_nome(self):
        return self._nome

    def set_nome(self, nome):
        self._nome = nome

    def get_preco(self):
        return self._preco

    def set_preco(self, preco):
        if preco >= 0:
            self._preco = preco

    def __str__(self):
        return f"Produto: {self._nome}, Preço: R${self._preco:.2f}"

# Exemplo de uso
produto1 = Produto("Camiseta", 29.99)
print(produto1)
produto1.set_preco(24.99)
print(produto1)
exercicio_encapsulamento/resolucao_1.py
davinyleticia/exercicio_poo_python
# Exercício 2: Biblioteca

class Livro:
    def __init__(self, titulo, autor):
        self._titulo = titulo    # Atributo protegido
        self._autor = autor      # Atributo protegido
        self._disponivel = True  # Atributo protegido (inicialmente disponível)

    def emprestar(self):
        if self._disponivel:
            self._disponivel = False
            return "Livro emprestado com sucesso!"
        else:
            return "Livro já emprestado."

    def devolver(self):
        if not self._disponivel:
            self._disponivel = True
            return "Livro devolvido com sucesso!"
        else:
            return "Livro já está disponível."

    def __str__(self):
        status = "disponível" if self._disponivel else "emprestado"
        return f"Título: {self._titulo}, Autor: {self._autor}, Status: {status}"

# Exemplo de uso
livro1 = Livro("Harry Potter", "J.K. Rowling")
print(livro1)
print(livro1.emprestar())
print(livro1.devolver())
exercicio_encapsulamento/resolucao_2.py
davinyleticia/exercicio_poo_python
# Exercício 3: Banco de Dados de Funcionários

class Funcionario:
    def __init__(self, nome, cargo):
        self._nome = nome   # Atributo protegido
        self._cargo = cargo # Atributo protegido

    def get_nome(self):
        return self._nome

    def set_nome(self, nome):
        self._nome = nome

    def get_cargo(self):
        return self._cargo

    def set_cargo(self, cargo):
        self._cargo = cargo

    def __str__(self):
        return f"Nome: {self._nome}, Cargo: {self._cargo}"

# Exemplo de uso
funcionario1 = Funcionario("João", "Analista")
print(funcionario1)
funcionario1.set_cargo("Gerente")
print(funcionario1)
exercicio_encapsulamento/resolucao_3.py
davinyleticia/exercicio_poo_python
# Exercício 4: Agenda de Compromissos

class Compromisso:
    def __init__(self, data, descricao):
        self._data = data       # Atributo protegido
        self._descricao = descricao # Atributo protegido

    def get_data(self):
        return self._data

    def set_data(self, data):
        self._data = data

    def get_descricao(self):
        return self._descricao

    def set_descricao(self, descricao):
        self._descricao = descricao

    def __str__(self):
        return f"Data: {self._data}, Descrição: {self._descricao}"

# Exemplo de uso
compromisso1 = Compromisso("2023-09-10", "Reunião de equipe")
print(compromisso1)
compromisso1.set_descricao("Treinamento")
print(compromisso1)

exercicio_encapsulamento/resolucao_4.py
davinyleticia/exercicio_poo_python
# exercício 1 - Veiculo

class Veiculo:
    def __init__(self, marca, modelo, ano):
        self.marca = marca
        self.modelo = modelo
        self.ano = ano
        
    def descricao(self):
        return f'Marca: {self.marca}, Modelo: {self.modelo}, Ano: {self.ano}'
    
class Carro(Veiculo):
    def __init__(self, marca, modelo, ano, num_portas):
        super().__init__(marca, modelo, ano)
        self.num_portas = num_portas
        
    def descricao(self):
        return super().descricao() + f', Números de portas: {self.num_portas}'
    
    
class Moto(Veiculo):
    def __init__(self, marca, modelo, ano, tipo_motor):
        super().__init__(marca, modelo, ano)
        self.tipo_motor = tipo_motor
        
    def descricao(self):
        return super().descricao() + f'tipo de motor: {self.tipo_motor}'
    
    
carro = Carro('Toyota', 'Corolla', 2023, 4)

moto = Moto('honda', 'CBR500R', 2022, '4 tempos')


print(carro.descricao())

print(moto.descricao())


carro_joao = Carro('Fiat', 'Siena', 2018, 4)


print(carro_joao.descricao())
exercicio_heranca/resolucao_1.py
davinyleticia/exercicio_poo_python
# exercício 2 - Produtos

class Produto:
    def __init__(self, nome, preco):
        self.nome = nome
        self.preco = preco
        
    def descricao(self):
        return f'nome: {self.nome}, Preço R$ {self.preco}'
    
class ProdutoFisico(Produto):
    def __init__(self, nome, preco, peso, dimensoes):
        super().__init__(nome, preco)
        self.peso = peso
        self.dimensoes = dimensoes
        
        
    def descricao(self):
        return super().descricao() + f", Peso: {self.peso} kg, Dimensões: {self.dimensoes} cm"
    
class ProdutoDigital(Produto):
    def __init__(self, nome, preco, tamanho_arquivo):
        super().__init__(nome,preco)
        self.tamanho_arquivo = tamanho_arquivo
        
    def descricao(self):
        return super().descricao() + f", Tamanho do Arquivo: {self.tamanho_arquivo} MB"
    
    
produto_fisico_darla = ProdutoFisico('livro', 30.00, 0.5, '20x15x3')

print(produto_fisico_darla.descricao()) 

produto_digital_darla = ProdutoDigital('E-book', 50.00, 10)

print(produto_digital_darla.descricao())
exercicio_heranca/resolucao_2.py
davinyleticia/exercicio_poo_python
# extra - exercício - Imovel


class Imovel:
    def __init__(self, endereco, nome_do_proprietario, preco_base):
        self.endereco = endereco
        self.nome_do_proprietario = nome_do_proprietario
        self.preco_base = preco_base
        
    def calcular_aluguel(self):
            return self.preco_base
        
class Casa(Imovel):
    def __init__(self, endereco, nome_do_proprietario, preco_base, area_terreno):
        super().__init__(endereco, nome_do_proprietario, preco_base)
        self.area_terreno = area_terreno
        
    def calcular_aluguel(self):
        resp =  self.preco_base + (self.area_terreno * 5)
        return resp
    
class Apartamento(Imovel):
    def __init__(self, endereco, nome_do_proprietario, preco_base, numero_quartos):
        super().__init__(endereco,nome_do_proprietario, preco_base)
        self.numero_quartos = numero_quartos
        
    def calcular_aluguel(self):
        resp =  self.preco_base + (self.numero_quartos * 300)
        return resp
    
    
casa_maria = Casa("122 Rua das Flores", "Maria", 1500, 300)
apartamento_carlos = Apartamento("333, Av. João Mendes", 'Carlos Jose', 1200, 2)


print(casa_maria.calcular_aluguel())
exercicio_heranca/resolucao_3_extra.py
davinyleticia/exercicio_poo_python