# Exemplo de classe em Python
class Carro:
    def __init__(self, marca, modelo, ano):
        self.marca = marca      # Atributo
        self.modelo = modelo    # Atributo
        self.ano = ano          # Atributo
        self.velocidade = 0     # Atributo com valor padrão
    
    def acelerar(self, incremento):
        self.velocidade += incremento
        print(f"{self.marca} {self.modelo} acelerando. Velocidade atual: {self.velocidade} km/h")
    
    def frear(self, decremento):
        self.velocidade = max(0, self.velocidade - decremento)
        print(f"{self.marca} {self.modelo} freando. Velocidade atual: {self.velocidade} km/h")
    
    def obter_informacoes(self):
        return f"Carro: {self.marca} {self.modelo}, Ano: {self.ano}"

# Criando objetos (instâncias) da classe
carro1 = Carro("Fiat", "Uno", 2020)
carro2 = Carro("Volkswagen", "Gol", 2019)

# Usando os métodos dos objetos
print(carro1.obter_informacoes())  # Carro: Fiat Uno, Ano: 2020
carro1.acelerar(30)                # Fiat Uno acelerando. Velocidade atual: 30 km/h
carro1.frear(10)                   # Fiat Uno freando. Velocidade atual: 20 km/h

// Exemplo de classe em Java
public class Carro {
    // Atributos da classe
    private String marca;
    private String modelo;
    private int ano;
    private int velocidade;
    
    // Construtor da classe
    public Carro(String marca, String modelo, int ano) {
        this.marca = marca;
        this.modelo = modelo;
        this.ano = ano;
        this.velocidade = 0;
    }
    
    // Métodos da classe
    public void acelerar(int incremento) {
        this.velocidade += incremento;
        System.out.println(this.marca + " " + this.modelo + " acelerando. Velocidade atual: " + this.velocidade + " km/h");
    }
    
    public void frear(int decremento) {
        this.velocidade = Math.max(0, this.velocidade - decremento);
        System.out.println(this.marca + " " + this.modelo + " freando. Velocidade atual: " + this.velocidade + " km/h");
    }
    
    public String obterInformacoes() {
        return "Carro: " + this.marca + " " + this.modelo + ", Ano: " + this.ano;
    }
    
    // Getters e Setters
    public String getMarca() {
        return marca;
    }
    
    public void setMarca(String marca) {
        this.marca = marca;
    }
    
    public int getVelocidade() {
        return velocidade;
    }
}

// Uso da classe em Java
Carro carro1 = new Carro("Fiat", "Uno", 2020);
Carro carro2 = new Carro("Volkswagen", "Gol", 2019);

System.out.println(carro1.obterInformacoes());
carro1.acelerar(30);
carro1.frear(10);

class ContaBancaria:
    def __init__(self, titular, saldo_inicial=0):
        self.titular = titular
        self.__saldo = saldo_inicial  # Atributo privado (indicado por __)
    
    def depositar(self, valor):
        if valor > 0:
            self.__saldo += valor
            print(f"Depósito de R${valor} realizado. Saldo atual: R${self.__saldo}")
        else:
            print("Valor de depósito inválido")
    
    def sacar(self, valor):
        if 0 < valor <= self.__saldo:
            self.__saldo -= valor
            print(f"Saque de R${valor} realizado. Saldo atual: R${self.__saldo}")
        else:
            print("Saldo insuficiente ou valor inválido")
    
    def consultar_saldo(self):
        return f"Saldo atual: R${self.__saldo}"

# Uso da classe com encapsulamento
conta = ContaBancaria("João Silva", 1000)
conta.depositar(500)
conta.sacar(200)
print(conta.consultar_saldo())

# Tentar acessar o saldo diretamente (não recomendado)
# print(conta.__saldo)  # Isso causaria um erro, pois __saldo é privado

public class ContaBancaria {
    private String titular;
    private double saldo;  // Atributo privado
    
    public ContaBancaria(String titular, double saldo_inicial) {
        this.titular = titular;
        this.saldo = saldo_inicial;
    }
    
    public void depositar(double valor) {
        if (valor > 0) {
            this.saldo += valor;
            System.out.println("Depósito de R$" + valor + " realizado. Saldo atual: R$" + this.saldo);
        } else {
            System.out.println("Valor de depósito inválido");
        }
    }
    
    public void sacar(double valor) {
        if (0 < valor && valor <= this.saldo) {
            this.saldo -= valor;
            System.out.println("Saque de R$" + valor + " realizado. Saldo atual: R$" + this.saldo);
        } else {
            System.out.println("Saldo insuficiente ou valor inválido");
        }
    }
    
    public double getSaldo() {  // Getter para acessar o saldo
        return this.saldo;
    }
    
    public String getTitular() {
        return this.titular;
    }
    
    // Setter para titular (opcional, dependendo dos requisitos)
    public void setTitular(String titular) {
        this.titular = titular;
    }
}

# Classe base (pai)
class Animal:
    def __init__(self, nome, especie):
        self.nome = nome
        self.especie = especie
    
    def fazer_som(self):
        pass  # Método que será sobrescrito pelas subclasses
    
    def informacoes(self):
        return f"Animal: {self.nome}, Espécie: {self.especie}"

# Classes derivadas (filhas)
class Cachorro(Animal):
    def __init__(self, nome, raca):
        super().__init__(nome, "Cachorro")  # Chama o construtor da classe pai
        self.raca = raca
    
    def fazer_som(self):
        return f"{self.nome} faz: Au au!"
    
    def buscar(self):
        return f"{self.nome} está buscando a bola!"

class Gato(Animal):
    def __init__(self, nome, cor):
        super().__init__(nome, "Gato")
        self.cor = cor
    
    def fazer_som(self):
        return f"{self.nome} faz: Miau!"
    
    def arranhar(self):
        return f"{self.nome} está arranhando!"

# Uso da herança
cachorro = Cachorro("Rex", "Labrador")
gato = Gato("Felix", "Preto")

print(cachorro.informacoes())  # Animal: Rex, Espécie: Cachorro
print(cachorro.fazer_som())    # Rex faz: Au au!
print(cachorro.buscar())       # Rex está buscando a bola!

print(gato.informacoes())      # Animal: Felix, Espécie: Gato
print(gato.fazer_som())        # Felix faz: Miau!
print(gato.arranhar())         # Felix está arranhando!

// Classe base (superclasse)
public class Animal {
    protected String nome;    // Atributo protegido
    protected String especie;
    
    public Animal(String nome, String especie) {
        this.nome = nome;
        this.especie = especie;
    }
    
    public String fazerSom() {
        return "Som genérico";
    }
    
    public String informacoes() {
        return "Animal: " + this.nome + ", Espécie: " + this.especie;
    }
    
    // Getters
    public String getNome() {
        return nome;
    }
    
    public String getEspecie() {
        return especie;
    }
}

// Classe derivada (subclasse)
public class Cachorro extends Animal {
    private String raca;
    
    public Cachorro(String nome, String raca) {
        super(nome, "Cachorro");  // Chama o construtor da superclasse
        this.raca = raca;
    }
    
    @Override
    public String fazerSom() {
        return this.nome + " faz: Au au!";
    }
    
    public String buscar() {
        return this.nome + " está buscando a bola!";
    }
    
    public String getRaca() {
        return raca;
    }
}

// Outra classe derivada
public class Gato extends Animal {
    private String cor;
    
    public Gato(String nome, String cor) {
        super(nome, "Gato");
        this.cor = cor;
    }
    
    @Override
    public String fazerSom() {
        return this.nome + " faz: Miau!";
    }
    
    public String arranhar() {
        return this.nome + " está arranhando!";
    }
}

# Demonstração de polimorfismo
def apresentar_animal(animal):
    print(f"Nome: {animal.nome}")
    print(f"Som: {animal.fazer_som()}")
    print("---")

# Criando uma lista de animais de diferentes tipos
animais = [
    Cachorro("Rex", "Golden Retriever"),
    Gato("Mia", "Branco"),
    Cachorro("Bobby", "Poodle")
]

# Polimorfismo em ação
for animal in animais:
    apresentar_animal(animal)

# Exemplo com classes de forma geométrica
class Forma:
    def calcular_area(self):
        pass
    
    def calcular_perimetro(self):
        pass

class Retangulo(Forma):
    def __init__(self, largura, altura):
        self.largura = largura
        self.altura = altura
    
    def calcular_area(self):
        return self.largura * self.altura
    
    def calcular_perimetro(self):
        return 2 * (self.largura + self.altura)

class Circulo(Forma):
    def __init__(self, raio):
        self.raio = raio
    
    def calcular_area(self):
        return 3.14159 * self.raio ** 2
    
    def calcular_perimetro(self):
        return 2 * 3.14159 * self.raio

# Função que trabalha com qualquer forma
def imprimir_informacoes_forma(forma):
    print(f"Área: {forma.calcular_area():.2f}")
    print(f"Perímetro: {forma.calcular_perimetro():.2f}")

# Polimorfismo com formas
formas = [Retangulo(5, 3), Circulo(4), Retangulo(2, 8)]

for forma in formas:
    imprimir_informacoes_forma(forma)
    print("---")

// Demonstração de polimorfismo em Java
public class PolimorfismoExemplo {
    public static void main(String[] args) {
        // Array de animais (polimorfismo)
        Animal[] animais = {
            new Cachorro("Rex", "Labrador"),
            new Gato("Felix", "Preto"),
            new Cachorro("Bobby", "Poodle")
        };
        
        // Tratando todos os animais de forma polimórfica
        for (Animal animal : animais) {
            System.out.println("Nome: " + animal.getNome());
            System.out.println("Som: " + animal.fazerSom());
            System.out.println("---");
        }
    }
}

// Interface para formas geométricas
interface Forma {
    double calcularArea();
    double calcularPerimetro();
}

class Retangulo implements Forma {
    private double largura;
    private double altura;
    
    public Retangulo(double largura, double altura) {
        this.largura = largura;
        this.altura = altura;
    }
    
    @Override
    public double calcularArea() {
        return largura * altura;
    }
    
    @Override
    public double calcularPerimetro() {
        return 2 * (largura + altura);
    }
}

class Circulo implements Forma {
    private double raio;
    
    public Circulo(double raio) {
        this.raio = raio;
    }
    
    @Override
    public double calcularArea() {
        return Math.PI * raio * raio;
    }
    
    @Override
    public double calcularPerimetro() {
        return 2 * Math.PI * raio;
    }
}

// Função que trabalha com qualquer forma
public static void imprimirInformacoesForma(Forma forma) {
    System.out.printf("Área: %.2f%n", forma.calcularArea());
    System.out.printf("Perímetro: %.2f%n", forma.calcularPerimetro());
}

from abc import ABC, abstractmethod

# Classe abstrata
class Funcionario(ABC):
    def __init__(self, nome, salario):
        self.nome = nome
        self.salario = salario
    
    @abstractmethod
    def calcular_pagamento(self):
        pass
    
    @abstractmethod
    def descricao_cargo(self):
        pass
    
    def informacoes_funcionario(self):
        return f"Funcionário: {self.nome}, Salário: R${self.salario}"

# Classes concretas que implementam a classe abstrata
class Gerente(Funcionario):
    def __init__(self, nome, salario, departamento):
        super().__init__(nome, salario)
        self.departamento = departamento
    
    def calcular_pagamento(self):
        # Bônus de 10% para gerentes
        return self.salario * 1.10
    
    def descricao_cargo(self):
        return f"Gerente do departamento de {self.departamento}"

class Desenvolvedor(Funcionario):
    def __init__(self, nome, salario, linguagem):
        super().__init__(nome, salario)
        self.linguagem = linguagem
    
    def calcular_pagamento(self):
        # Bônus de 5% para desenvolvedores
        return self.salario * 1.05
    
    def descricao_cargo(self):
        return f"Desenvolvedor especializado em {self.linguagem}"

# Uso de classes abstratas
funcionarios = [
    Gerente("Carlos Silva", 8000, "TI"),
    Desenvolvedor("Ana Costa", 5000, "Python")
]

for funcionario in funcionarios:
    print(funcionario.informacoes_funcionario())
    print(f"Pagamento: R${funcionario.calcular_pagamento():.2f}")
    print(f"Cargo: {funcionario.descricao_cargo()}")
    print("---")

// Interface em Java
interface FormaGeometrica {
    double calcularArea();
    double calcularPerimetro();
    default String getTipo() {
        return "Forma Geométrica";
    }
}

// Classe abstrata em Java
abstract class Funcionario {
    protected String nome;
    protected double salario;
    
    public Funcionario(String nome, double salario) {
        this.nome = nome;
        this.salario = salario;
    }
    
    // Método concreto
    public String getInformacoes() {
        return "Funcionário: " + this.nome + ", Salário: R$" + this.salario;
    }
    
    // Métodos abstratos (devem ser implementados pelas subclasses)
    public abstract double calcularPagamento();
    public abstract String descricaoCargo();
}

class Gerente extends Funcionario {
    private String departamento;
    
    public Gerente(String nome, double salario, String departamento) {
        super(nome, salario);
        this.departamento = departamento;
    }
    
    @Override
    public double calcularPagamento() {
        return this.salario * 1.10; // Bônus de 10%
    }
    
    @Override
    public String descricaoCargo() {
        return "Gerente do departamento de " + this.departamento;
    }
}

from datetime import datetime, timedelta

class Livro:
    def __init__(self, titulo, autor, isbn):
        self.titulo = titulo
        self.autor = autor
        self.isbn = isbn
        self.disponivel = True
        self.data_emprestimo = None
    
    def emprestar(self):
        if self.disponivel:
            self.disponivel = False
            self.data_emprestimo = datetime.now()
            return True
        return False
    
    def devolver(self):
        self.disponivel = True
        self.data_emprestimo = None
    
    def informacoes(self):
        status = "Disponível" if self.disponivel else "Emprestado"
        return f"'{self.titulo}' por {self.autor} - {status}"

class Usuario:
    def __init__(self, nome, id_usuario):
        self.nome = nome
        self.id_usuario = id_usuario
        self.livros_emprestados = []
    
    def pegar_emprestado(self, livro):
        if livro.emprestar():
            self.livros_emprestados.append(livro)
            return True
        return False
    
    def devolver_livro(self, livro):
        if livro in self.livros_emprestados:
            livro.devolver()
            self.livros_emprestados.remove(livro)
            return True
        return False

class Biblioteca:
    def __init__(self, nome):
        self.nome = nome
        self.livros = []
        self.usuarios = []
    
    def adicionar_livro(self, livro):
        self.livros.append(livro)
    
    def registrar_usuario(self, usuario):
        self.usuarios.append(usuario)
    
    def emprestar_livro(self, id_usuario, isbn):
        usuario = self.encontrar_usuario(id_usuario)
        livro = self.encontrar_livro(isbn)
        
        if usuario and livro:
            return usuario.pegar_emprestado(livro)
        return False
    
    def devolver_livro(self, id_usuario, isbn):
        usuario = self.encontrar_usuario(id_usuario)
        livro = self.encontrar_livro(isbn)
        
        if usuario and livro:
            return usuario.devolver_livro(livro)
        return False
    
    def encontrar_usuario(self, id_usuario):
        for usuario in self.usuarios:
            if usuario.id_usuario == id_usuario:
                return usuario
        return None
    
    def encontrar_livro(self, isbn):
        for livro in self.livros:
            if livro.isbn == isbn:
                return livro
        return None

# Uso do sistema de biblioteca
biblioteca = Biblioteca("Biblioteca Central")

# Adicionar livros
livro1 = Livro("1984", "George Orwell", "978-0-452-28423-4")
livro2 = Livro("O Senhor dos Anéis", "J.R.R. Tolkien", "978-0-544-00341-1")

biblioteca.adicionar_livro(livro1)
biblioteca.adicionar_livro(livro2)

# Registrar usuários
usuario1 = Usuario("Maria Silva", "U001")
usuario2 = Usuario("João Oliveira", "U002")

biblioteca.registrar_usuario(usuario1)
biblioteca.registrar_usuario(usuario2)

# Empréstimo de livro
sucesso = biblioteca.emprestar_livro("U001", "978-0-452-28423-4")
if sucesso:
    print("Livro emprestado com sucesso!")
else:
    print("Não foi possível emprestar o livro.")

# Verificar informações
print(livro1.informacoes())
print(f"{usuario1.nome} tem {len(usuario1.livros_emprestados)} livro(s) emprestado(s)")