Programação orientada a objetos

import java.util.ArrayList;
import java.util.List;

public class Pessoa {
    public String nome = "UB Social";
    private List<String> endereco = new ArrayList<>(2);
    private final int cpf;

    public String getNome() {
        return nome;
    }

    public void setEndereco(String endereco, char tipo) {
        if (this.endereco.size() < 2) {
            this.endereco.add(endereco + " (" + tipo + ")");
        } else {
            System.out.println("Máximo de 2 endereços já atingido.");
        }
    }
}

// Definição de classe
public class Livro {
    // Atributos
    private String titulo;
    private String autor;
    private int paginas;

    // Construtor
    public Livro(String titulo, String autor, int paginas) {
        this.titulo = titulo;
        this.autor = autor;
        this.paginas = paginas;
    }

    // Getters e Setters
    public String getTitulo() {
        return titulo;
    }
    public void setTitulo(String titulo) {
        this.titulo = titulo;
    }
    public String getAutor() {
        return autor;
    }
    public void setAutor(String autor) {
        this.autor = autor;
    }
    public int getPaginas() {
        return paginas;
    }
    public void setPaginas(int paginas) {
        this.paginas = paginas;
    }

    public void lerLivro() {
        System.out.println("Lendo o livro: " + titulo + " de " + autor);
    }

    public String virarPagina(int pagina) {
        this.paginas = pagina;
        String ler = "Virando para página " + pagina + " do livro: " + titulo;
        return ler;
    }

    // Método main para testar a classe
    public static void main(String[] args) {
        Livro meuLivro = new Livro("O Alquimista", "Paulo Coelho", 208);
        meuLivro.lerLivro();
        System.out.println(meuLivro.virarPagina(23));
        System.out.println("Título: " + meuLivro.getTitulo());
        System.out.println("Autor: " + meuLivro.getAutor());
        System.out.println("Páginas: " + meuLivro.getPaginas());
    }
}

class Exemplo {
    static int contador = 0;

    static void incrementar() {
        contador++;
    }
}

class Exemplo2 {
    static final double PI = 3.14;
}

public class Estatico {

    static int contador = 0;
    static final double PI = 3.14;

    static void incrementarContador() {
        contador++;
        System.out.println("Contador: " + contador);
    }

    static final void mostrarPI() {
        System.out.println("Valor de PI: " + PI);
    }

    public static void main(String[] args) {
        Exemplo.contador = 5;
        Exemplo.incrementarContador();
        System.out.println("PI: " + Exemplo.PI);
        Exemplo.mostrarPI();
    }
}

public class Livro {
    // Atributo de classe
    public static int contadorLivros = 0;

    // Atributo de objeto (não-static)
    public String nome;

    public Livro(String nome) {
        this.nome = nome;
        contadorLivros++;
    }

    public void mostrarInformacoes() {
        System.out.println("Nome: " + this.nome);
        System.out.println("Contador de livros: " + Livro.contadorLivros);
    }

    public static void main(String[] args) {
        Livro livro1 = new Livro("Livro 1");
        Livro livro2 = new Livro("Livro 2");
        livro1.mostrarInformacoes();
        livro2.mostrarInformacoes();

        // Acessar atributo de classe diretamente
        System.out.println("Contador de livros (diretamente): " + Livro.contadorLivros);
    }
}

public class Retangulo {
    private double largura;
    private double altura;

    public Retangulo(double largura, double altura) {
        this.largura = largura;
        this.altura = altura;
    }

    public double getLargura() {return largura;}
    public void setLargura(double largura) {this.largura = largura;}
    public double getAltura() {return altura;}
    public void setAltura(double altura) {this.altura = altura;}

    // Método para calcular área (atributo derivado - area)
    public double getArea() {
        return largura * altura;
    }

    public static void main(String[] args) {
        Retangulo retangulo = new Retangulo(5, 10);
        System.out.println("Largura: " + retangulo.getLargura());
        System.out.println("Altura: " + retangulo.getAltura());
        System.out.println("Área: " + retangulo.getArea());

        retangulo.setLargura(7);
        retangulo.setAltura(3);
        System.out.println("Nova Largura: " + retangulo.getLargura());
        System.out.println("Nova Altura: " + retangulo.getAltura());
        System.out.println("Nova Área: " + retangulo.getArea());
    }
}

public class Calculadora {
    // Método de classe (static)
    public static int somar(int a, int b) {
        return a + b;
    }

    public static int subtrair(int a, int b) {
        return a - b;
    }

    public static int multiplicar(int a, int b) {
        return a * b;
    }

    public static double dividir(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("Divisor não pode ser zero");
        }
        return (double) a / b;
    }

    public static void main(String[] args) {
        // Invocar métodos de classe sem criar instância de Calculadora
        int soma = Calculadora.somar(10, 5);
        int subtracao = Calculadora.subtrair(10, 5);
        int multiplicacao = Calculadora.multiplicar(10, 5);
        double divisao = Calculadora.dividir(10, 5);

        System.out.println("Soma: " + soma);
        System.out.println("Subtração: " + subtracao);
        System.out.println("Multiplicação: " + multiplicacao);
        System.out.println("Divisão: " + divisao);
    }
}

public class Pessoa {
    private String nome;
    private int idade;

    public Pessoa(String nome, int idade) {
        this.nome = nome;
        this.idade = idade;
    }

    // Método sem parâmetros
    public void mostrarInformacoes() {
        System.out.println("Nome: " + nome);
        System.out.println("Idade: " + idade);
    }

    // Método com parâmetros
    public void atualizarInformacoes(String novoNome, int novaIdade) {
        this.nome = novoNome;
        this.idade = novaIdade;
    }

    public static void main(String[] args) {
        Pessoa pessoa = new Pessoa("João", 25);

        // Invocar método sem parâmetros
        pessoa.mostrarInformacoes();

        // Atualizando as informações da pessoa
        pessoa.atualizarInformacoes("Maria", 30);

        // Invocar método sem parâmetros novamente para ver alterações
        pessoa.mostrarInformacoes();
    }
}

public class ContaBancaria {
    private String titular;
    private double saldo;

    public ContaBancaria(String titular, double saldoInicial) {
        this.titular = titular;
        this.saldo = saldoInicial;
    }

    // Método sem retorno (void)
    public void depositar(double valor) {
        if (valor > 0) {
            saldo += valor;
            System.out.println("Depósito de R$ " + valor + " realizado com sucesso.");
        }
    }

    // Método com retorno (double)
    public double obterSaldo() {
        return saldo;
    }

    public static void main(String[] args) {
        ContaBancaria conta = new ContaBancaria("Alice", 1000.0);

        // Invocar método sem retorno (void)
        conta.depositar(500.0);

        // Invocar método com retorno (double) e armazenar valor retornado
        double saldoAtual = conta.obterSaldo();
        System.out.println("Saldo atual: R$ " + saldoAtual);
    }
}

public class Livro {
    private String titulo;
    private String autor;
    private double preco;

    // Método construtor
    public Livro(String titulo, String autor, double preco) {
        this.titulo = titulo;
        this.autor = autor;
        this.preco = preco;
    }

    // Método getter para o título
    public String getTitulo() {
        return titulo;
    }

    // Método setter para o título
    public void setTitulo(String titulo) {
        this.titulo = titulo;
    }

    // Método getter para o autor
    public String getAutor() {
        return autor;
    }

    // Método setter para o autor
    public void setAutor(String autor) {
        this.autor = autor;
    }

    // Método getter para o preço
    public double getPreco() {
        return preco;
    }

    // Método setter para o preço
    public void setPreco(double preco) {
        this.preco = preco;
    }

    public void mostrarInformacoes() {
        System.out.println("Título: " + titulo);
        System.out.println("Autor: " + autor);
        System.out.println("Preço: R$ " + preco);
    }

    public static void main(String[] args) {
        // Criar objeto Livro
        Livro livro = new Livro("1984", "George Orwell", 39.90);

        livro.mostrarInformacoes();

        // Invocar método getTitulo
        System.out.println(livro.getTitulo());

        // Invocar métodos set
        livro.setTitulo("Admirável Mundo Novo");
        livro.setAutor("Aldous Huxley");
        livro.setPreco(29.90);

        livro.mostrarInformacoes();
    }
}

// classe Livro é subclasse de Publicacao, onde, no construtor da classe Livro, importa-se (via super) atributos da superclasse Publicacao. Construtor Livro instanciará objetos Livros, com dados de Livro e também Publicacao
public class Publicacao {
    private String titulo;
    private String autor;

    public Publicacao(String titulo, String autor) {
        this.titulo = titulo;
        this.autor = autor;
    }
}

public class Livro extends Publicacao {
    private int paginas;

    public Livro(String titulo, String autor, int paginas) {
        super(titulo, autor);
        this.paginas = paginas;
    }

}

public static void main(String[] args) {
    Livro meuLivro = new Livro("1984", "George Orwell", 328);
}

public class ContaBancaria {
    // Atributos privados (encapsulados)
    private String titular;
    private double saldo;

    public ContaBancaria(String titular, double saldoInicial) {
        this.titular = titular;
        this.saldo = saldoInicial;
    }

    // Método público getter para acessar atributo privado titular
    public String getTitular() {
        return titular;
    }

    // Método público setter para acessar atributo privado titular
    public void setTitular(String titular) {
        this.titular = titular;
    }

    // Método público getter para acessar atributo privado saldo
    public double getSaldo() {
        return saldo;
    }

    public static void main(String[] args) {
        // Criar objeto ContaBancaria (criar, via método público construct, objeto de atributos privados encapsulados)
        ContaBancaria conta = new ContaBancaria("Alice", 1000.0);

        // Exibir saldo inicial (acessar, via método público get, valor de atributo privado encapsulado)
        System.out.println("Saldo inicial: R$ " + conta.getSaldo());

        // Exibir titular
        System.out.println("Titular: " + conta.getTitular());

        // Modificar titular (modificar, via método público set, valor de atributo privado encapsulado)
        String novoTitular = "Fulana";
        setTitular(novoTitular);

        // Exibir novo titular
        System.out.println("Novo titular: " + conta.getTitular());
    }
}

public class Cafe {
    private String tipo;
    private double precoPorXicara;

    public Cafe(String tipo, double precoPorXicara) {
        this.tipo = tipo;
        this.precoPorXicara = precoPorXicara;
    }

    // Método com return (return precisa ser String, já que método também é String)
    public String getTipo() {
        return tipo;
    }

    // Método void (não possui return, mas tem parâmetros)
    public void setTipo(String tipo) {
        this.tipo = tipo;
    }

    public double getPrecoPorXicara() {return precoPorXicara;}
    public void setPrecoPorXicara(double precoPorXicara) {this.precoPorXicara = precoPorXicara;}

    // Método com valor de retorno que calcula o preço total
    public double calcularPrecoTotal(int quantidade) {
        return quantidade * precoPorXicara;
    }

    public static void main(String[] args) {
        Cafe cafe = new Cafe("Expresso", 5.0);

        System.out.println("Tipo de café: " + cafe.getTipo());
        System.out.println("Preço por xícara: R$ " + cafe.getPrecoPorXicara());

        int quantidade = 3;
        double precoTotal = cafe.calcularPrecoTotal(quantidade);
        System.out.println("Preço total para " + quantidade + " xícaras: R$ " + precoTotal);

        cafe.setTipo("Latte");
        cafe.setPrecoPorXicara(6.0);
        quantidade = 2;
        precoTotal = cafe.calcularPrecoTotal(quantidade);
        System.out.println("Preço total para " + quantidade + " xícaras: R$ " + precoTotal);
    }
}

import java.util.ArrayList;
import java.util.List;

// Classe Professor
class Professor {
    private String nome;
    private List<Disciplina> disciplinas;

    public Professor(String nome) {
        this.nome = nome;
        this.disciplinas = new ArrayList<>();
    }

    // Método para adicionar disciplina que professor leciona
    public void adicionarDisciplina(Disciplina disciplina) {
        disciplinas.add(disciplina);
    }

    // Método para exibir disciplinas que professor leciona
    public void mostrarDisciplinas() {
        System.out.println("Professor: " + nome);
        System.out.println("Disciplinas lecionadas:");
        for (Disciplina disciplina : disciplinas) {
            System.out.println("- " + disciplina.getNome());
        }
    }
}

// Classe Disciplina
class Disciplina {
    private String nome;
    private List<Professor> professores;

    public Disciplina(String nome) {
        this.nome = nome;
        this.professores = new ArrayList<>();
    }

    public String getNome() {return nome;}

    // Método para adicionar professor que leciona a disciplina
    public void adicionarProfessor(Professor professor) {
        professores.add(professor);
    }

    // Método para exibir professores que lecionam a disciplina
    public void mostrarProfessores() {
        System.out.println("Disciplina: " + nome);
        System.out.println("Professores que lecionam:");
        for (Professor professor : professores) {
            System.out.println("- " + professor.nome);
        }
    }
}

// Exemplo de uso das classes
public class ExemploAssociacao {
    public static void main(String[] args) {
        // Criar objetos professores
        Professor p1 = new Professor("João");
        Professor p2 = new Professor("Maria");

        // Criar objetos disciplinas
        Disciplina d1 = new Disciplina("Matemática");
        Disciplina d2 = new Disciplina("História");

        // Associar professores às disciplinas
        d1.adicionarProfessor(p1);
        d1.adicionarProfessor(p2);
        d2.adicionarProfessor(p2);

        // Associar disciplinas aos professores
        p1.adicionarDisciplina(d1);
        p2.adicionarDisciplina(d1);
        p2.adicionarDisciplina(d2);

        // Exibir disciplinas lecionadas por cada professor
        p1.mostrarDisciplinas();
        System.out.println();
        p2.mostrarDisciplinas();

        // Exibir professores que lecionam cada disciplina
        System.out.println();
        d1.mostrarProfessores();
        System.out.println();
        d2.mostrarProfessores();
    }
}

import java.util.ArrayList;
import java.util.List;

// Classe Funcionário
class Funcionário {
    private String nome;
    private int idade;

    public Funcionário(String nome, int idade) {
        this.nome = nome;
        this.idade = idade;
    }

    public String getNome() {return nome;}
    public int getIdade() {return idade;}
}

// Classe Departamento
class Departamento {
    private String nome;
    private List<Funcionário> funcionários;

    public Departamento(String nome) {
        this.nome = nome;
        this.funcionários = new ArrayList<>();
    }

    // Método para adicionar funcionários ao departamento
    public void adicionarFuncionário(Funcionário funcionário) {
        funcionários.add(funcionário);
    }

    // Método para exibir funcionários do departamento
    public void mostrarFuncionários() {
        System.out.println("Departamento: " + nome);
        System.out.println("Funcionários:");
        for (Funcionário funcionário : funcionários) {
            System.out.println("- " + funcionário.getNome() + ", " + funcionário.getIdade() + " anos");
        }
    }
}

// Exemplo de uso das classes
public class ExemploAgregacao {
    public static void main(String[] args) {
        // Criar objetos funcionários
        Funcionário f1 = new Funcionário("João", 30);
        Funcionário f2 = new Funcionário("Maria", 25);
        Funcionário f3 = new Funcionário("José", 28);

        // Criar objeto departamento
        Departamento d1 = new Departamento("Recursos Humanos");

        // Adicionar funcionários ao departamento
        d1.adicionarFuncionário(f1);
        d1.adicionarFuncionário(f2);
        d1.adicionarFuncionário(f3);

        // Exibir funcionários do departamento
        d1.mostrarFuncionários();
    }
}

// Classe externa
class ClasseExterna {
    private int valorExterno;

    public ClasseExterna(int valorExterno) {
        this.valorExterno = valorExterno;
    }

    // Método da classe externa
    public void mostrarValor() {
        System.out.println("Valor externo: " + valorExterno);
    }

    // Classe interna (nested class)
    class ClasseInterna {
        private int valorInterno;

        public ClasseInterna(int valorInterno) {
            this.valorInterno = valorInterno;
        }

        // Método da classe interna
        public void mostrarValorInterno() {
            System.out.println("Valor interno: " + valorInterno);
        }
    }
}

// Classes aninhadas
public class ExemploClassesAninhadas {
    public static void main(String[] args) {
        // Criar instância da classe externa
        ClasseExterna externa = new ClasseExterna(10);

        // Criar instância da classe interna usando a instância da classe externa
        ClasseExterna.ClasseInterna interna = externa.new ClasseInterna(5);

        externa.mostrarValor(); // Saída: Valor externo: 10
        interna.mostrarValorInterno(); // Saída: Valor interno: 5
    }
}

// Classe CPU (parte do composto)
class CPU {
    private String tipo;
    private int velocidade;

    public CPU(String tipo, int velocidade) {
        this.tipo = tipo;
        this.velocidade = velocidade;
    }

    public String getTipo() {return tipo;}
    public int getVelocidade() {return velocidade;}
}

// Classe PlacaMae (parte do composto)
class PlacaMae {
    private String modelo;
    private int slotsMemoria;

    public PlacaMae(String modelo, int slotsMemoria) {
        this.modelo = modelo;
        this.slotsMemoria = slotsMemoria;
    }

    public String getModelo() {return modelo;}
    public int getSlotsMemoria() {return slotsMemoria;}
}

// Classe MemoriaRAM (parte do composto)
class MemoriaRAM {
    private int capacidade;
    private String tipo;

    public MemoriaRAM(int capacidade, String tipo) {
        this.capacidade = capacidade;
        this.tipo = tipo;
    }

    public int getCapacidade() {return capacidade;}
    public String getTipo() {return tipo;}
}

// Classe Computador (composto/todo: composição com CPU, PlacaMae e MemoriaRAM)
class Computador {
    private CPU cpu;
    private PlacaMae placaMae;
    private MemoriaRAM memoriaRam;

    public Computador(CPU cpu, PlacaMae placaMae, MemoriaRAM memoriaRam) {
        this.cpu = cpu;
        this.placaMae = placaMae;
        this.memoriaRam = memoriaRam;
    }

    // Método para exibir informações do computador
    public void exibirInfo() {
        System.out.println("Computador:");
        System.out.println("- CPU: " + cpu.getTipo() + ", " + cpu.getVelocidade() + " GHz");
        System.out.println("- Placa Mãe: " + placaMae.getModelo() + ", " + placaMae.getSlotsMemoria() + " slots de memória");
        System.out.println("- Memória RAM: " + memoriaRam.getCapacidade() + " GB, " + memoriaRam.getTipo());
    }
}

// Exemplo de uso das classes
public class ExemploComposicaoJava {
    public static void main(String[] args) {
        // Criar componentes individuais do computador
        CPU cpu = new CPU("Intel Core i7", 3);
        PlacaMae placaMae = new PlacaMae("ASUS Prime Z590", 4);
        MemoriaRAM memoriaRAM = new MemoriaRAM(16, "DDR4");

        // Criar objeto computador com os componentes criados
        Computador meuComputador = new Computador(cpu, placaMae, memoriaRAM);

        // Exibir informações do computador
        meuComputador.exibirInfo();
    }
}

public class Canil {
    private Cachorro[];
    ArrayList<Cachorro> listac;
    public void addCachorro(Cachorro c){}
    public void addCachorro(String nome, Date) {
        Cachorro c = new Cachorro(nome, dtNasc);
        this.listac.add(c); -> Associação: entre as classes gera o listac, pois possibilita instanciar o objeto que representa a parte fora de seu todo
    } -> Composição: Canil depende de NotaFiscal, pois para criar um objeto NotaFiscal é necessário ter a classe da mesma
    public NotaFiscal geraNota(Date data, double valor) {
        NotaFiscal f = new NotaFiscal();
        return f;
    }
}

// Classe Rascunho (superclasse)
class Rascunho {
    protected String titulo;
    protected String autor;

    public Rascunho(String titulo, String autor) {
        this.titulo = titulo;
        this.autor = autor;
    }

    public String getTitulo() {return titulo;}
    public String getAutor() {return autor;}

    public void exibirInfo() {
        System.out.println("Título: " + titulo);
        System.out.println("Autor: " + autor);
    }
}

// Classe Livro (subclasse, herda de Rascunho)
class Livro extends Rascunho {
    private String isbn;
    private int numeroPaginas;

    public Livro(String titulo, String autor, String isbn, int numeroPaginas) {
        super(titulo, autor); // Chama construtor da Rascunho
        this.isbn = isbn;
        this.numeroPaginas = numeroPaginas;
    }

    public String getIsbn() {return isbn;}
    public int getNumeroPaginas() {return numeroPaginas;}

    // Método para exibir informações do livro (sobrescreve exibirInfo da classe Rascunho)
    @Override
    public void exibirInfo() {
        super.exibirInfo(); // Invoca método da classe Rascunho
        System.out.println("ISBN: " + isbn);
        System.out.println("Número de Páginas: " + numeroPaginas);
    }
}

// Exemplo de uso das classes
public class ExemploHeranca {
    public static void main(String[] args) {
        // Criar objeto rascunho
        Rascunho r1 = new Rascunho("Rascunho de Java", "João Silva");

        // Criar objeto livro
        Livro l1 = new Livro("Java Completo", "Maria Oliveira", "978-3-16-148410-0", 450);

        // Exibir informações do rascunho
        System.out.println("Informações do Rascunho:");
        r1.exibirInfo();

        // Exibir informações do livro
        System.out.println("\nInformações do Livro:");
        l1.exibirInfo();
    }
}

// Classe base Animal
class Animal {
    protected String nome;
    protected int idade;

    public Animal(String nome, int idade) {
        this.nome = nome;
        this.idade = idade;
    }

    public String getNome() {return nome;}
    public int getIdade() {return idade;}

    public void emitirSom() {
        System.out.println("O animal emite um som.");
    }
}

// Classe derivada Cachorro
class Cachorro extends Animal {

    public Cachorro(String nome, int idade) {
        super(nome, idade); // Invoca construtor da classe base Animal
    }

    public void latir() {
        System.out.println("O cachorro late: Au Au!");
    }

    // Sobrescrer método emitirSom da classe base Animal
    @Override
    public void emitirSom() {
        System.out.println("O cachorro faz: Au Au!");
    }
}

// Classe final (folha,leaf) Poodle que herda de Cachorro
public final class Poodle extends Cachorro {

    public Poodle(String nome, int idade) {
        super(nome, idade); // Invoca construtor da classe base Cachorro
    }

    // Método específico para o poodle
    public void mostrarEstilo() {
        System.out.println("O poodle está exibindo seu estilo.");
    }

    // Sobrescrever método emitirSom da classe Cachorro
    @Override
    public void emitirSom() {
        System.out.println("O poodle faz: Au Au, com um toque de elegância!");
    }
}

public class ExemploHerancaFinal {
    public static void main(String[] args) {
        // Criar objeto Animal
        Animal a1 = new Animal("Animal Genérico", 5);
        a1.emitirSom();

        // Criar objeto Cachorro
        Cachorro c1 = new Cachorro("Rex", 3);
        c1.emitirSom();
        c1.latir();

        // Criar objeto Poodle
        Poodle p1 = new Poodle("Bella", 2);
        p1.emitirSom();
        p1.latir();
        p1.mostrarEstilo();

        // Exibir informações do Poodle
        System.out.println("Nome: " + p1.getNome());
        System.out.println("Idade: " + p1.getIdade());
    }
}

class Animal {
    protected String nome;

    public Animal(String nome) {
        this.nome = nome;
    }

    public String getNome() {return nome;}

    // Método emitir som (será sobrescrito nas subclasses)
    public void emitirSom() {
        System.out.println("O animal emite um som.");
    }

    // Sobrecarga de métodos - diferentes parâmetros
    public void emitirSom(String som) {
        System.out.println("O animal faz: " + som);
    }
}

class Cachorro extends Animal {

    public Cachorro(String nome) {
        super(nome);
    }

    // Sobrescrever método emitirSom da classe base Animal
    @Override
    public void emitirSom() {
        System.out.println("O cachorro faz: Au Au!");
    }
}

class Gato extends Animal {

    public Gato(String nome) {
        super(nome);
    }

    // Sobrescrever método emitirSom da classe base Animal
    @Override
    public void emitirSom() {
        System.out.println("O gato faz: Miau!");
    }
}

public class ExemploPolimorfismo {
    public static void main(String[] args) {
        Animal animal = new Animal("Animal Genérico");
        Cachorro cachorro = new Cachorro("Rex");
        Gato gato = new Gato("Mimi");

        // Sobrescrita de métodos
        animal.emitirSom(); // Invocar método da classe base Animal
        cachorro.emitirSom(); // Invocar método sobrescrito da classe Cachorro
        gato.emitirSom(); // Invocar método sobrescrito da classe Gato

        // Sobrecarga de métodos
        animal.emitirSom("Roar"); // Invocar método sobrecarregado da classe base

        // Usando polimorfismo com um array de animais
        Animal[] animais = {animal, cachorro, gato};
        for (Animal a : animais) {
            System.out.println("Nome: " + a.getNome());
            a.emitirSom(); // Invocar método apropriado baseado no tipo do objeto
        }
    }
}

public class Main {
    public static void main (String[] args) {
        Pessoa p = new Pessoa("Ana");
        Brasileiro b = new Brasileiro("Bob");
        Cachorro c = new Cachorro();
        Pessoa p1 = new Brasileiro("Rick");
        b.setPet(c);
    }
}   
public class Cachorro {
    private String nome;
    public void setNome(String n) {this.nome = n;}
}   
public class Pessoa {
    private String nome;
    public Pessoa(String nome) {this.nome = nome;}
    public void comer() {QUADRADO}
    public boolean comer(float qtde) {return false; BOLA}
}
public class Brasileiro extends Pessoa {
    private Cachorro pet;
    public Brasileiro(String  nome) {super(nome);}
    public void comer() {TRIÂNGULO}
    public void setPet(Cachorro c) {this.pet = c;}
}

p1.comer(); //resultado TRIÂNGULO
p.comer(); //resultado QUADRADO
p1.comer(0.5); //resultado BOLA
b.comer(); //resultado TRIÂNGULO

import java.util.ArrayList;
import java.util.List;

// Classe Produto (independente)
class Produto {
    private String nome;
    private double preco;

    public Produto(String nome, double preco) {
        this.nome = nome;
        this.preco = preco;
    }

    public String getNome() {return nome;}
    public double getPreco() {return preco;}
}

// Classe Pedido (dependente de Produto)
class Pedido {
    private List<Produto> produtos;

    public Pedido() {
        this.produtos = new ArrayList<>();
    }

    // Método para adicionar produto ao pedido
    public void adicionarProduto(Produto produto) {
        produtos.add(produto);
    }

    // Método para calcular total do pedido
    public double calcularTotal() {
        double total = 0.0;
        for (Produto produto : produtos) {
            total += produto.getPreco();
        }
        return total;
    }

    // Método para exibir produtos do pedido
    public void exibirPedido() {
        System.out.println("Produtos no pedido:");
        for (Produto produto : produtos) {
            System.out.println("- " + produto.getNome() + ": R$ " + produto.getPreco());
        }
    }
}

public class ExemploDependencia {
    public static void main(String[] args) {
        Produto prod1 = new Produto("Camiseta", 49.90);
        Produto prod2 = new Produto("Calça", 89.90);
        Produto prod3 = new Produto("Tênis", 129.90);
        Pedido ped = new Pedido();

        // Adicionar produtos ao pedido
        ped.adicionarProduto(prod1);
        ped.adicionarProduto(prod2);
        ped.adicionarProduto(prod3);

        // Exibir produtos do pedido
        ped.exibirPedido();

        // Calcular e exibir total do pedido
        double total = ped.calcularTotal();
        System.out.println("Total do pedido: R$ " + total);
    }
}

import java.util.ArrayList;
import java.util.List;

// Classe Livro
class Livro {
    private String titulo;
    private String isbn;

    public Livro(String titulo, String isbn) {
        this.titulo = titulo;
        this.isbn = isbn;
    }

    public String getTitulo() {return titulo;}
    public String getIsbn() {return isbn;}
}

// Classe Autor
class Autor {
    private String nome;
    private String biografia;

    public Autor(String nome, String biografia) {
        this.nome = nome;
        this.biografia = biografia;
    }

    public String getNome() {return nome;}
    public String getBiografia() {return biografia;}
}

// Classe associativa LivroAutor (Livro pode ter vários Autores, e Autor pode ter vários Livros)
class LivroAutor {
    private Livro livro;
    private Autor autor;
    private String papel; // Papel do autor no livro (ex: "Escritor", "Editor")

    public LivroAutor(Livro livro, Autor autor, String papel) {
        this.livro = livro;
        this.autor = autor;
        this.papel = papel;
    }

    public Livro getLivro() {return livro;}
    public Autor getAutor() {return autor;}
    public String getPapel() {return papel;}
}

public class ExemploClasseAssociativa {
    public static void main(String[] args) {
        Livro livro1 = new Livro("Java Programming", "123-456-789");
        Livro livro2 = new Livro("Advanced Java", "987-654-321");
        Autor autor1 = new Autor("John Doe", "Experienced Java developer.");
        Autor autor2 = new Autor("Jane Smith", "Java enthusiast and writer.");

        LivroAutor associacao1 = new LivroAutor(livro1, autor1, "Escritor");
        LivroAutor associacao2 = new LivroAutor(livro1, autor2, "Co-escritor");
        LivroAutor associacao3 = new LivroAutor(livro2, autor1, "Editor");

        // Exibir associações
        System.out.println("Livro: " + associacao1.getLivro().getTitulo() + ", Autor: " + associacao1.getAutor().getNome() + ", Papel: " + associacao1.getPapel());
        System.out.println("Livro: " + associacao2.getLivro().getTitulo() + ", Autor: " + associacao2.getAutor().getNome() + ", Papel: " + associacao2.getPapel());
        System.out.println("Livro: " + associacao3.getLivro().getTitulo() + ", Autor: " + associacao3.getAutor().getNome() + ", Papel: " + associacao3.getPapel());
    }
}

class Animal {
    protected String nome;

    public Animal(String nome) {
        this.nome = nome;
    }

    public String getNome() {return nome;}

    // Método final que não pode ser sobrescrito
    public final void dormir() {
        System.out.println(nome + " está dormindo.");
    }

    // Método que pode ser sobrescrito
    public void emitirSom() {
        System.out.println(nome + " está fazendo um som.");
    }
}

class Cachorro extends Animal {
    public Cachorro(String nome) {
        super(nome);
    }

    // Sobrescrevendo método emitirSom da classe base Animal
    @Override
    public void emitirSom() {
        System.out.println(nome + " está fazendo: Au Au!");
    }
}

public class ExemploMetodoFinal {
    public static void main(String[] args) {
        Cachorro cachorro = new Cachorro("Rex");

        // Invocar métodos dormir (final) e emitirSom (sobrescrito)
        cachorro.dormir();  // Invocar método final da classe base Animal
        cachorro.emitirSom(); // Invocar método sobrescrito da classe Cachorro
    }
}

interface Pessoa {
    String getNome();
}

interface Estudante extends Pessoa {
    String getCurso();
}

interface Funcionario extends Pessoa {
    String getCargo();
}

// Classe que implementa todas interfaces
class PessoaEstudanteFuncionario implements Estudante, Funcionario {
    private String nome;
    private String curso;
    private String cargo;

    public PessoaEstudanteFuncionario(String nome, String curso, String cargo) {
        this.nome = nome;
        this.curso = curso;
        this.cargo = cargo;
    }

    // Implementação do método getNome da interface Pessoa
    @Override
    public String getNome() {return nome;}

    // Implementação do método getCurso da interface Estudante
    @Override
    public String getCurso() {return curso;}

    // Implementação do método getCargo da interface Funcionario
    @Override
    public String getCargo() {return cargo;}
}

public class ExemploOverlapping {
    public static void main(String[] args) {
        PessoaEstudanteFuncionario pessoa = new PessoaEstudanteFuncionario("Ana", "Engenharia", "Estagiária");

        // Usar instância como Pessoa
        System.out.println("Nome: " + pessoa.getNome());

        // Usar instância como Estudante
        System.out.println("Curso: " + pessoa.getCurso());

        // Usar instância como Funcionario
        System.out.println("Cargo: " + pessoa.getCargo());
    }
}

// Classe abstrata Animal
abstract class Animal {
    protected String nome;

    public Animal(String nome) {
        this.nome = nome;
    }

    // Método abstrato que deve ser implementado pelas subclasses concretas
    public abstract void emitirSom();

    // Método concreto
    public void dormir() {
        System.out.println(nome + " está dormindo.");
    }

    public String getNome() {return nome;}
}

class Cachorro extends Animal {
    public Cachorro(String nome) {
        super(nome);
    }

    // Implementação do método abstrato emitirSom
    @Override
    public void emitirSom() {
        System.out.println(nome + " está fazendo: Au Au!");
    }
}

class Gato extends Animal {
    public Gato(String nome) {
        super(nome);
    }

    // Implementação do método abstrato emitirSom
    @Override
    public void emitirSom() {
        System.out.println(nome + " está fazendo: Miau!");
    }
}

public class ExemploClasseAbstrata {
    public static void main(String[] args) {
        Animal cachorro = new Cachorro("Rex");
        Animal gato = new Gato("Mimi");

        cachorro.emitirSom();
        cachorro.dormir();

        gato.emitirSom();
        gato.dormir();
    }
}

public interface OperacoesMatematicas {
    // Constante (atributo final estático)
    double PI = 3.141592653589793;

    // Método abstrato (deve ser implementado pelas classes concretas)
    double calcular(double a, double b);

    // Método default (com implementação)
    default double calcularCircunferencia(double raio) {
        return 2 * PI * raio;
    }

    // Método estático (com implementação)
    static double calcularAreaCirculo(double raio) {
        return PI * raio * raio;
    }
}

public class Soma implements OperacoesMatematicas {
    // Implementação do método abstrato calcular
    @Override
    public double calcular(double a, double b) {
        return a + b;
    }
}

public class Multiplicacao implements OperacoesMatematicas {
    // Implementação do método abstrato calcular
    @Override
    public double calcular(double a, double b) {
        return a * b;
    }
}

public class TestaOperacoesMatematicas {
    public static void main(String[] args) {
        OperacoesMatematicas soma = new Soma();
        OperacoesMatematicas multiplicacao = new Multiplicacao();

        // Utilizar métodos abstratos
        System.out.println("Soma: " + soma.calcular(5, 3)); // Output: Soma: 8.0
        System.out.println("Multiplicação: " + multiplicacao.calcular(5, 3)); // Output: Multiplicação: 15.0

        // Utilizar método default
        System.out.println("Circunferência: " + soma.calcularCircunferencia(3)); // Output: Circunferência: 18.84955592153876

        // Utilizar método estático
        System.out.println("Área do círculo: " + OperacoesMatematicas.calcularAreaCirculo(3)); // Output: Área do círculo: 28.274333882308138
    }
}

public interface OperacoesMatematicas {
    double calcular(double a, double b);
}

public interface OperacoesGeometricas {
    double calcularArea(double raio);
    double calcularPerimetro(double lado);
}

public class CalculadoraAvancada implements OperacoesMatematicas, OperacoesGeometricas {
    // Implementação do método calcular da interface OperacoesMatematicas
    @Override
    public double calcular(double a, double b) {
        return a + b;
    }

    // Implementação do método calcularArea da interface OperacoesGeometricas
    @Override
    public double calcularArea(double raio) {
        return Math.PI * raio * raio;
    }

    // Implementação do método calcularPerimetro da interface OperacoesGeometricas
    @Override
    public double calcularPerimetro(double lado) {
        return 4 * lado;
    }

    // Método adicional para exibir os resultados
    public void exibirResultados(double a, double b, double raio, double lado) {
        System.out.println("Soma: " + calcular(a, b));
        System.out.println("Área do círculo: " + calcularArea(raio));
        System.out.println("Perímetro do quadrado: " + calcularPerimetro(lado));
    }
}

public class TestaCalculadoraAvancada {
    public static void main(String[] args) {
        CalculadoraAvancada calculadora = new CalculadoraAvancada();

        double a = 5.0;
        double b = 3.0;
        double raio = 2.0;
        double lado = 4.0;

        calculadora.exibirResultados(a, b, raio, lado);
    }
}

// Interface fornecida (provided interface)
public interface Service {
    void execute();
}

// Interface requerida (required interface)
public interface Logger {
    void log(String message);
}

// Implementação da interface fornecida (provided interface)
public class ServiceImpl implements Service {
    private Logger logger; // Interface requerida

    // Injeção da interface requerida via construtor
    public ServiceImpl(Logger logger) {
        this.logger = logger;
    }

    @Override
    public void execute() {
        logger.log("Service is being executed.");
        System.out.println("Service execution logic here.");
    }
}

// Implementação da interface requerida (required interface)
public class ConsoleLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("Log: " + message);
    }
}

public class Main {
    public static void main(String[] args) {
        // Criar instância da implementação da interface requerida
        Logger logger = new ConsoleLogger();

        // Passar instância da interface requerida para a implementação da interface fornecida
        Service service = new ServiceImpl(logger);

        // Executar serviço
        service.execute();
    }
}

// Entity (classe entidade)
// Representa conta bancária com métodos para depositar, sacar e consultar saldo
public class Account {
    private String accountNumber;
    private double balance;

    public Account(String accountNumber) {
        this.accountNumber = accountNumber;
        this.balance = 0.0;
    }

    public void deposit(double amount) {
        balance += amount;
    }

    public void withdraw(double amount) {
        if (amount <= balance) {
            balance -= amount;
        }
    }

    public double getBalance() {return balance;}
    public String getAccountNumber() {return accountNumber;}
}

// Control (classe controle)
// Gerencia lógica de controle, coordenando criação de contas e consulta de saldos
public class AccountController {
    private Account account;

    public void createAccount(String accountNumber) {
        account = new Account(accountNumber);
    }

    public double getBalance() {
        if (account != null) {
            return account.getBalance();
        }
        return 0.0;
    }

    // Métodos adicionais para depositar e sacar podem ser adicionados aqui
}

// Boundary (classe fronteira/limite)
// Interage com usuário, obtendo entradas e exibindo saídas
import java.util.Scanner;
public class AccountUI {
    private AccountController controller;
    private Scanner scanner;

    public AccountUI() {
        controller = new AccountController();
        scanner = new Scanner(System.in);
    }

    public void createAccount() {
        System.out.print("Enter account number: ");
        String accountNumber = scanner.nextLine();
        controller.createAccount(accountNumber);
        System.out.println("Account created successfully!");
    }

    public void displayBalance() {
        double balance = controller.getBalance();
        System.out.println("Current balance: " + balance);
    }

    public static void main(String[] args) {
        AccountUI ui = new AccountUI();
        ui.createAccount();
        ui.displayBalance();
    }
}

public ArrayList<Livro> meusLivros = new ArrayList<Livro>();

public class Caixa<T> {
    // Variável de instância do tipo genérico T
    private T item;

    public Caixa(T item) {
        this.item = item;
    }

    public T getItem() {return item;}
    public void setItem(T item) {this.item = item;}

    public void exibirItem() {
        System.out.println("Item: " + item);
    }
}

public class TestaCaixa {
    public static void main(String[] args) {
        // Criar instância de Caixa para armazenar Integer
        Caixa<Integer> caixaInteger = new Caixa<>(123);
        caixaInteger.exibirItem();

        // Criar instância de Caixa para armazenar String
        Caixa<String> caixaString = new Caixa<>("Olá Mundo");
        caixaString.exibirItem();

        // Criar instância de Caixa para armazenar Double
        Caixa<Double> caixaDouble = new Caixa<>(3.14);
        caixaDouble.exibirItem();

        caixaString.setItem("Nova String");
        System.out.println("Item atualizado: " + caixaString.getItem());
    }
}

package com.empresa.produto;
import com.empresa.util.Utilitario; // Importar classe do outro pacote

public class Produto {
    private String nome;
    private double preco;

    public Produto(String nome, double preco) {
        this.nome = nome;
        this.preco = preco;
    }

    // Método para calcular preço com desconto usando uma classe do outro pacote
    public double calcularPrecoComDesconto(double descontoPercentual) {
        // Utilizar método da classe do pacote com.empresa.util
        double desconto = Utilitario.calcularDesconto(preco, descontoPercentual);
        return preco - desconto;
    }
}
------------------------------
package com.empresa.util;

public class Utilitario {
    // Método estático para calcular desconto
    public static double calcularDesconto(double valor, double percentual) {
        return valor * (percentual / 100);
    }
}

Subsystem de Produtos:
// Arquivo: Produto.java
package com.empresa.produtos.cadastro;

public class Produto {
    private String nome;
    private double preco;
    // Getters e setters omitidos para simplicidade
}

// Arquivo: Estoque.java
package com.empresa.produtos.estoque;

public class Estoque {
    private int quantidadeDisponivel;

    public void atualizarEstoque(int quantidade) {
        // Lógica para atualizar o estoque
    }
}

// Arquivo: Venda.java
package com.empresa.produtos.vendas;
import com.empresa.produtos.cadastro.Produto;
import com.empresa.produtos.estoque.Estoque;

public class Venda {
    public void realizarVenda(Produto produto, int quantidade) {
        // Lógica para processar venda e atualizar estoque
        Estoque estoque = new Estoque();
        estoque.atualizarEstoque(-quantidade); // Reduz quantidade do estoque após venda
    }
}

Subsistema de Clientes e Pedidos:
// Arquivo: Cliente.java
package com.empresa.clientes;

public class Cliente {
    private String nome;
    private String endereco;
    // Getters e setters omitidos para simplicidade
}

// Arquivo: Pedido.java
package com.empresa.clientes.pedidos;
import com.empresa.produtos.cadastro.Produto;

public class Pedido {
    private Cliente cliente;
    private Produto produto;
    private int quantidade;
    // Construtor, getters e setters omitidos para simplicidade
}

Classe Main:
// Arquivo: Main.java
package com.empresa;
import com.empresa.clientes.Cliente;
import com.empresa.clientes.pedidos.Pedido;
import com.empresa.produtos.cadastro.Produto;
import com.empresa.produtos.vendas.Venda;

public class Main {
    public static void main(String[] args) {
        // Exemplo de uso do subsistema de produtos
        Produto produto = new Produto();
        produto.setNome("Camiseta");
        produto.setPreco(29.99);

        Venda venda = new Venda();
        venda.realizarVenda(produto, 1);

        // Exemplo de uso do subsistema de clientes e pedidos
        Cliente cliente = new Cliente();
        cliente.setNome("João");
        cliente.setEndereco("Rua A, 123");

        Pedido pedido = new Pedido();
        pedido.setCliente(cliente);
        pedido.setProduto(produto);
        pedido.setQuantidade(2);

        // Lógica para processar pedido
        processarPedido(pedido);
    }

    private static void processarPedido(Pedido pedido) {
        // Lógica para processar pedido
    }
}

// BusinessEntity
public class Customer {
    private String id;
    private String name;

    public Customer(String id, String name) {
        this.id = id;
        this.name = name;
    }

    public String getId() {return id;}
    public String getName() {return name;}
}

// BusinessEntity
import java.util.List;
public class Order {
    private String orderId;
    private String customerId;
    private List<Product> productList;

    public Order(String orderId, String customerId, List<Product> productList) {
        this.orderId = orderId;
        this.customerId = customerId;
        this.productList = productList;
    }

    public String getOrderId() {return orderId;}
    public String getCustomerId() {return customerId;}
    public List<Product> getProductList() {return productList;}
    public double getTotalAmount() {return productList.stream().mapToDouble(Product::getPrice).sum();}
}

// BusinessEntity
public class Product {
    private String productId;
    private String productName;
    private double price;

    public Product(String productId, String productName, double price) {
        this.productId = productId;
        this.productName = productName;
        this.price = price;
    }

    public String getProductId() {return productId;}
    public String getProductName() {return productName;}
    public double getPrice() {return price;}
}

// BusinessWorker
import java.util.List;
public class OrderProcessor {
    public Order createOrder(String orderId, String customerId, List<Product> productList) {
        return new Order(orderId, customerId, productList);
    }

    public void processOrder(Order order) {
        // Implementar lógica para processar order
        System.out.println("Processing order for customer ID: " + order.getCustomerId());
        System.out.println("Order total amount: " + order.getTotalAmount());
    }
}

// Integração
import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        Customer customer = new Customer("C123", "John Doe");
        Product product1 = new Product("P101", "Laptop", 1200.00);
        Product product2 = new Product("P102", "Mouse", 25.00);

        OrderProcessor orderProcessor = new OrderProcessor();
        Order order = orderProcessor.createOrder("O1001", customer.getId(), Arrays.asList(product1, product2));       
        orderProcessor.processOrder(order);
    }
}

// Classes
public class Book {
    private String title;
    private String author;
    private String isbn;

    public Book(String title, String author, String isbn) {
        this.title = title;
        this.author = author;
        this.isbn = isbn;
    }

    public String getTitle() {return title;}
    public String getAuthor() {return author;}
    public String getIsbn() {return isbn;}
}

public class LibraryMember {
    private String name;
    private String memberId;

    public LibraryMember(String name, String memberId) {
        this.name = name;
        this.memberId = memberId;
    }

    public String getName() {return name;}
    public String getMemberId() {return memberId;}
}

// InstanceSpecifications
public class Main {
    public static void main(String[] args) {
        Book book = new Book("1984", "George Orwell", "123456789");
        LibraryMember member = new LibraryMember("Alice", "M001");

        System.out.println("Book Title: " + book.getTitle());
        System.out.println("Book Author: " + book.getAuthor());
        System.out.println("Book ISBN: " + book.getIsbn());
        
        System.out.println("Member Name: " + member.getName());
        System.out.println("Member ID: " + member.getMemberId());
    }
}

public static void main(String[] args) {}