// Salve este arquivo como OlaMundo.java
public class OlaMundo {
 
    // Este é o método principal, o ponto de entrada do programa
    public static void main(String[] args) {
        // Imprime a mensagem "Olá, Mundo!" no console
        System.out.println("Olá, Mundo!");
 
        // Explorando variáveis e tipos de dados primitivos
        byte variavelByte = 127; // Armazena números pequenos, de -128 a 127
        short variavelShort = 32767; // Armazena números um pouco maiores
        // char variavelChar = 'A'; // Armazena um único caractere Unicode (0 a 65535)
        int variavelInt = 2000000000; // Tipo comum para números inteiros
        long variavelLong = 9000000000000000000L; // Para números inteiros muito grandes (note o 'L' no final)
        
        float variavelFloat = 3.14f; // Para números de ponto flutuante de precisão simples (note o 'f' no final)
        double variavelDouble = 3.1415926535; // Para números de ponto flutuante de precisão dupla
 
        boolean variavelBoolean = true; // Armazena valores verdadeiros (true) ou falsos (false)
        char umUnicoCaractere = 'C'; // Armazena um único caractere
 
        System.out.println("--- Exemplos de Variáveis Primitivas ---");
        System.out.println("Byte: " + variavelByte);
        System.out.println("Short: " + variavelShort);
        System.out.println("Int: " + variavelInt);
        System.out.println("Long: " + variavelLong);
        System.out.println("Float: " + variavelFloat);
        System.out.println("Double: " + variavelDouble);
        System.out.println("Boolean: " + variavelBoolean);
        System.out.println("Char: " + umUnicoCaractere);
    }
}

// Salve este arquivo como Cao.java (preferencialmente em uma pasta como "Animais")
package Animais; // Opcional, mas bom para organização
 
public class Cao {
    // Atributos (Características do Cão)
    public String nome;
    public String cor;
    public int altura;       // em centímetros
    public double peso;       // em quilogramas
    public int tamanhoRabo;  // em centímetros
    public String estadoEspirito; // Ex: feliz, triste, neutro
 
    // Métodos (Comportamentos do Cão)
 
    // Método simples sem retorno e sem parâmetros
    public void comer() {
        System.out.println(this.nome + " está comendo...");
    }
 
    // Método simples sem retorno, mas com uma ação
    public void latir() {
        System.out.println("AU AU!");
    }
 
    // Método que retorna um valor (String)
    public String pegar() {
        return "Bolinha"; // Simula o cão pegando uma bolinha
    }
 
    // Método que recebe um parâmetro e altera um atributo
    public String interagir(String acao) {
        if (acao.equals("carinho")) {
            this.estadoEspirito = "feliz";
        } else if (acao.equals("nao tem comida")) {
            this.estadoEspirito = "triste";
        } else {
            this.estadoEspirito = "neutro";
        }
        return this.estadoEspirito;
    }
}

// Salve como Main.java (na mesma pasta ou em uma que possa acessar Animais)
package Animais; // Se Cao.java estiver em um pacote
// ou importe a classe: import Animais.Cao;
 
public class Main {
    public static void main(String[] args) {
        // Criando (instanciando) nosso primeiro objeto Cao
        Cao cachorro1 = new Cao(); // 'new Cao()' chama o construtor padrão
 
        // Definindo os atributos do objeto cachorro1
        cachorro1.nome = "Rex";
        cachorro1.cor = "Marrom";
        cachorro1.altura = 50; // cm
        cachorro1.peso = 15.5; // kg
        cachorro1.tamanhoRabo = 10; // cm
        cachorro1.estadoEspirito = "brincalhão";
 
        // Usando os métodos do objeto cachorro1
        System.out.println("Nome do cachorro: " + cachorro1.nome);
        cachorro1.latir(); // Executa o método latir()
        
        String objetoPego = cachorro1.pegar();
        System.out.println(cachorro1.nome + " pegou a: " + objetoPego);
 
        System.out.println("Estado de espírito antes da interação: " + cachorro1.estadoEspirito);
        String novoEstado = cachorro1.interagir("carinho");
        System.out.println("Estado de espírito após o carinho: " + novoEstado);
 
        novoEstado = cachorro1.interagir("nao tem comida");
        System.out.println("Estado de espírito após saber que não tem comida: " + novoEstado);
 
        // Criando um segundo objeto Cao
        Cao cachorro2 = new Cao();
        cachorro2.nome = "Luna";
        cachorro2.cor = "Preta";
        cachorro2.altura = 40;
        cachorro2.interagir("brincadeira"); // Interagindo com o segundo cachorro
 
        System.out.println(cachorro2.nome + " está " + cachorro2.estadoEspirito);
    }
}

// Dentro da classe Cao.java (substitua o método interagir anterior)
 
public String interagir(String acao) {
    switch (acao.toLowerCase()) { // Convertemos para minúsculas para ser case-insensitive
        case "carinho":
            this.estadoEspirito = "feliz e abanando o rabo";
            break; // Importante! Sai do switch após encontrar um case correspondente.
        case "nao tem comida":
        case "sem comida": // Podemos ter múltiplos cases para o mesmo bloco de código
            this.estadoEspirito = "triste e com fome";
            break;
        case "brincadeira":
            this.estadoEspirito = "animado e pulando";
            break;
        case "bronca":
            this.estadoEspirito = "cabisbaixo e com orelhas murchas";
            break;
        default: // Executado se nenhum case corresponder
            this.estadoEspirito = "neutro e observador";
            break;
    }
    return this.estadoEspirito;
}

// Dentro da classe Cao.java
package Animais;
 
public class Cao {
    // Atributos agora são privados
    private String nome;
    private String cor;
    private int altura;       // em centímetros
    private double peso;       // em quilogramas
    private int tamanhoRabo;  // em centímetros
    private String estadoEspirito;
 
    // Métodos Getters (para ler os valores dos atributos)
 
    public String getNome() {
        return this.nome;
    }
 
    public String getCor() {
        return this.cor;
    }
 
    public int getAltura() {
        return this.altura;
    }
 
    public double getPeso() {
        return this.peso;
    }
 
    public int getTamanhoRabo() {
        return this.tamanhoRabo;
    }
 
    public String getEstadoEspirito() {
        return this.estadoEspirito;
    }
 
    // Métodos Setters (para modificar os valores dos atributos)
    // Nos setters, podemos adicionar lógica de validação, se necessário.
 
    public void setNome(String nome) {
        if (nome != null && !nome.trim().isEmpty()) { // Exemplo de validação simples
            this.nome = nome;
        } else {
            System.out.println("Nome inválido!");
        }
    }
 
    public void setCor(String cor) {
        this.cor = cor;
    }
 
    public void setAltura(int altura) {
        if (altura > 0) { // Altura deve ser positiva
            this.altura = altura;
        } else {
            System.out.println("Altura inválida!");
        }
    }
 
    public void setPeso(double peso) {
        if (peso > 0) { // Peso deve ser positivo
            this.peso = peso;
        } else {
            System.out.println("Peso inválido!");
        }
    }
 
    public void setTamanhoRabo(int tamanhoRabo) {
        if (tamanhoRabo >= 0) { // Tamanho do rabo pode ser 0
            this.tamanhoRabo = tamanhoRabo;
        } else {
            System.out.println("Tamanho do rabo inválido!");
        }
    }
 
    // O estado de espírito ainda será modificado pelo método interagir
    // mas podemos ter um setter se quisermos controle direto (e um getter já existe)
    // public void setEstadoEspirito(String estadoEspirito) {
    //     this.estadoEspirito = estadoEspirito;
    // }
 
    // Métodos de comportamento (já definidos anteriormente)
    public void comer() {
        System.out.println(this.nome + " está comendo...");
    }
 
    public void latir() {
        System.out.println("AU AU!");
    }
 
    public String pegar() {
        return "Bolinha";
    }
 
    public String interagir(String acao) {
        switch (acao.toLowerCase()) {
            case "carinho":
                this.estadoEspirito = "feliz e abanando o rabo";
                break;
            case "nao tem comida":
            case "sem comida":
                this.estadoEspirito = "triste e com fome";
                break;
            case "brincadeira":
                this.estadoEspirito = "animado e pulando";
                break;
            case "bronca":
                this.estadoEspirito = "cabisbaixo e com orelhas murchas";
                break;
            default:
                this.estadoEspirito = "neutro e observador";
                break;
        }
        return this.estadoEspirito;
    }
}

// Salve como Main.java
package Animais;
 
public class Main {
    public static void main(String[] args) {
        Cao cachorro1 = new Cao();
 
        // Usando setters para definir os atributos
        cachorro1.setNome("Rex");
        cachorro1.setCor("Marrom");
        cachorro1.setAltura(50);
        cachorro1.setPeso(15.5);
        cachorro1.setTamanhoRabo(10);
        // cachorro1.estadoEspirito = "brincalhão"; // ERRO! Não é mais acessível diretamente
 
        // Usando getters para ler os atributos
        System.out.println("Nome do cachorro: " + cachorro1.getNome());
        System.out.println("Cor: " + cachorro1.getCor());
 
        cachorro1.latir();
        System.out.println(cachorro1.getNome() + " pegou a: " + cachorro1.pegar());
 
        System.out.println("Estado de espírito inicial: " + cachorro1.getEstadoEspirito()); // Pode ser null se não definido
        cachorro1.interagir("carinho");
        System.out.println("Novo estado de espírito: " + cachorro1.getEstadoEspirito());
 
        // Testando validações (exemplos)
        cachorro1.setNome("  "); // Tentativa de nome inválido
        cachorro1.setAltura(-5); // Tentativa de altura inválida
        System.out.println("Nome após tentativa inválida: " + cachorro1.getNome());
        System.out.println("Altura após tentativa inválida: " + cachorro1.getAltura());
    }
}

// Dentro da classe Cao.java (adicione estes construtores)
 
public class Cao {
    // ... (atributos de instância privados como antes: nome, cor, etc.)
    private String nome;
    private String cor;
    private int altura;
    private double peso;
    private int tamanhoRabo;
    private String estadoEspirito;
 
    // Atributo Estático: Compartilhado por todos os objetos Cao
    private static int numeroDeCaes = 0; // Inicializado com 0
 
    // Construtores (modificados para incrementar o contador estático)
    public Cao() {
        this.nome = "Vira-lata Caramelo";
        this.cor = "Caramelo";
        this.estadoEspirito = "curioso";
        numeroDeCaes++; // Incrementa o contador quando um Cao é criado
    }
 
    public Cao(String nome, String cor) {
        this(); // Chama o construtor Cao() sem argumentos para inicializar padrões
        this.setNome(nome); // Usa o setter para aproveitar a validação
        this.setCor(cor);
    }
 
    public Cao(String nome, String cor, int altura, double peso, int tamanhoRabo, String estadoEspirito) {
        this.setNome(nome);
        this.setCor(cor);
        this.setAltura(altura);
        this.setPeso(peso);
        this.setTamanhoRabo(tamanhoRabo);
        this.estadoEspirito = estadoEspirito;
        numeroDeCaes++; // Incrementa o contador
    }
 
    // Getters e Setters para atributos de instância (como antes)
    public String getNome() { return this.nome; }
    public void setNome(String nome) { /* ... com validação ... */ this.nome = nome; }
    public String getCor() { return this.cor; }
    public void setCor(String cor) { this.cor = cor; }
    public int getAltura() { return this.altura; }
    public void setAltura(int altura) { /* ... com validação ... */ this.altura = altura; }
    public double getPeso() { return this.peso; }
    public void setPeso(double peso) { /* ... com validação ... */ this.peso = peso; }
    public int getTamanhoRabo() { return this.tamanhoRabo; }
    public void setTamanhoRabo(int tamanhoRabo) { /* ... com validação ... */ this.tamanhoRabo = tamanhoRabo; }
    public String getEstadoEspirito() { return this.estadoEspirito; }
    // Não teremos um setter público para numeroDeCaes, pois ele é gerenciado internamente.
 
    // Método Estático: Para acessar o atributo estático numeroDeCaes
    public static int getNumeroDeCaes() {
        return numeroDeCaes;
    }
 
    // Métodos de instância (como antes: comer, latir, pegar, interagir)
    public void comer() { System.out.println(this.nome + " está comendo..."); }
    public void latir() { System.out.println("AU AU!"); }
    public String pegar() { return "Bolinha"; }
    public String interagir(String acao) {
        // ... (lógica do switch como antes)
        switch (acao.toLowerCase()) {
            case "carinho":
                this.estadoEspirito = "feliz e abanando o rabo";
                break;
            case "nao tem comida":
            case "sem comida":
                this.estadoEspirito = "triste e com fome";
                break;
            case "brincadeira":
                this.estadoEspirito = "animado e pulando";
                break;
            case "bronca":
                this.estadoEspirito = "cabisbaixo e com orelhas murchas";
                break;
            default:
                this.estadoEspirito = "neutro e observador";
                break;
        }
        return this.estadoEspirito;
    }
}

// Salve como Main.java
package Animais;
 
public class Main {
    public static void main(String[] args) {
        // Usando o construtor sem argumentos
        Cao caoPadrao = new Cao();
        System.out.println("Cão Padrão: " + caoPadrao.getNome() + ", Cor: " + caoPadrao.getCor() + ", Estado: " + caoPadrao.getEstadoEspirito());
 
        // Usando o construtor com nome e cor
        Cao cachorro1 = new Cao("Rex", "Marrom");
        cachorro1.setAltura(50);
        cachorro1.setPeso(15.5);
        cachorro1.setTamanhoRabo(10);
        System.out.println("Cachorro 1: " + cachorro1.getNome() + ", Cor: " + cachorro1.getCor() + ", Altura: " + cachorro1.getAltura());
 
        // Usando o construtor completo
        Cao cachorro2 = new Cao("Luna", "Preta", 40, 12.0, 8, "brincalhona");
        System.out.println("Cachorro 2: " + cachorro2.getNome() + ", Estado: " + cachorro2.getEstadoEspirito());
 
        cachorro2.interagir("carinho");
        System.out.println(cachorro2.getNome() + " agora está: " + cachorro2.getEstadoEspirito());
    }
}

// Dentro da classe Cao.java
package Animais;
 
public class Cao {
    // ... (atributos de instância privados como antes: nome, cor, etc.)
    private String nome;
    private String cor;
    private int altura;
    private double peso;
    private int tamanhoRabo;
    private String estadoEspirito;
 
    // Atributo Estático: Compartilhado por todos os objetos Cao
    private static int numeroDeCaes = 0; // Inicializado com 0
 
    // Construtores (modificados para incrementar o contador estático)
    public Cao() {
        this.nome = "Vira-lata Caramelo"; // Um valor padrão divertido
        this.cor = "Caramelo";
        this.estadoEspirito = "curioso";
        numeroDeCaes++; // Incrementa o contador quando um Cao é criado
    }
 
    public Cao(String nome, String cor) {
        this(); // Chama o construtor Cao() sem argumentos para inicializar padrões
        this.setNome(nome); // Usa o setter para aproveitar a validação
        this.setCor(cor);
    }
 
    public Cao(String nome, String cor, int altura, double peso, int tamanhoRabo, String estadoEspirito) {
        this.setNome(nome);
        this.setCor(cor);
        this.setAltura(altura);
        this.setPeso(peso);
        this.setTamanhoRabo(tamanhoRabo);
        this.estadoEspirito = estadoEspirito;
        numeroDeCaes++; // Incrementa o contador
    }
 
    // Getters e Setters para atributos de instância (como antes)
    public String getNome() { return this.nome; }
    public void setNome(String nome) { /* ... com validação ... */ this.nome = nome; }
    public String getCor() { return this.cor; }
    public void setCor(String cor) { this.cor = cor; }
    public int getAltura() { return this.altura; }
    public void setAltura(int altura) { /* ... com validação ... */ this.altura = altura; }
    public double getPeso() { return this.peso; }
    public void setPeso(double peso) { /* ... com validação ... */ this.peso = peso; }
    public int getTamanhoRabo() { return this.tamanhoRabo; }
    public void setTamanhoRabo(int tamanhoRabo) { /* ... com validação ... */ this.tamanhoRabo = tamanhoRabo; }
    public String getEstadoEspirito() { return this.estadoEspirito; }
    // Não teremos um setter público para numeroDeCaes, pois ele é gerenciado internamente.
 
    // Método Estático: Para acessar o atributo estático numeroDeCaes
    public static int getNumeroDeCaes() {
        return numeroDeCaes;
    }
 
    // Métodos de instância (como antes: comer, latir, pegar, interagir)
    public void comer() { System.out.println(this.nome + " está comendo..."); }
    public void latir() { System.out.println("AU AU!"); }
    public String pegar() { return "Bolinha"; }
    public String interagir(String acao) {
        // ... (lógica do switch como antes)
        switch (acao.toLowerCase()) {
            case "carinho":
                this.estadoEspirito = "feliz e abanando o rabo";
                break;
            case "nao tem comida":
            case "sem comida":
                this.estadoEspirito = "triste e com fome";
                break;
            case "brincadeira":
                this.estadoEspirito = "animado e pulando";
                break;
            case "bronca":
                this.estadoEspirito = "cabisbaixo e com orelhas murchas";
                break;
            default:
                this.estadoEspirito = "neutro e observador";
                break;
        }
        return this.estadoEspirito;
    }
}

// Salve como Main.java
package Animais;
 
public class Main {
    public static void main(String[] args) {
        // Acessando o método estático ANTES de criar qualquer objeto
        System.out.println("Número inicial de cães: " + Cao.getNumeroDeCaes()); // Saída: 0
 
        Cao cachorro1 = new Cao("Rex", "Marrom");
        System.out.println("Número de cães após criar Rex: " + Cao.getNumeroDeCaes()); // Saída: 1
 
        Cao cachorro2 = new Cao("Luna", "Preta", 40, 12.0, 8, "brincalhona");
        System.out.println("Número de cães após criar Luna: " + Cao.getNumeroDeCaes()); // Saída: 2
 
        Cao caoPadrao = new Cao();
        System.out.println("Número de cães após criar cão padrão: " + Cao.getNumeroDeCaes()); // Saída: 3
 
        // Note que chamamos getNumeroDeCaes() diretamente na classe Cao,
        // não em uma instância como cachorro1.getNumeroDeCaes() (embora isso também funcione em Java, não é a prática recomendada).
    }
}

package Sistema;
 
import Animais.Cao; // Supondo que Cao esteja em outro pacote
 
public class TesteGC {
    public static void main(String[] args) {
        System.out.println("Número inicial de cães (antes de criar no TesteGC): " + Cao.getNumeroDeCaes());
 
        Cao caoA = new Cao("Objeto Cao A", "Azul");
        Cao caoB = new Cao("Objeto Cao B", "Verde");
 
        System.out.println("Referências iniciais:");
        System.out.println("caoA aponta para: " + caoA.getNome()); // Mostra o nome do objeto
        System.out.println("caoB aponta para: " + caoB.getNome());
        System.out.println("Número de cães agora: " + Cao.getNumeroDeCaes());
 
        // caoA agora aponta para o mesmo objeto que caoB
        caoA = caoB;
        System.out.println("\nApós 'caoA = caoB;':");
        System.out.println("caoA aponta para: " + caoA.getNome());
        System.out.println("caoB aponta para: " + caoB.getNome());
 
        // O objeto original "Objeto Cao A" não tem mais nenhuma referência apontando para ele.
        // Ele se tornou elegível para ser coletado pelo Garbage Collector.
        // Não podemos prever exatamente QUANDO o GC vai rodar e liberar essa memória.
 
        Cao caoC = new Cao("Objeto Cao C", "Vermelho");
        System.out.println("\ncaoC aponta para: " + caoC.getNome());
        System.out.println("Número de cães agora: " + Cao.getNumeroDeCaes());
 
        // Tornando caoC elegível para coleta
        caoC = null;
        // Agora, o objeto "Objeto Cao C" também está elegível se não houver outras referências.
 
        // Você pode sugerir ao sistema para executar o GC, mas não há garantia.
        // System.gc(); 
 
        System.out.println("\nFim do método main. Objetos podem ser coletados após este ponto se não mais referenciados.");
    }
}

package Animais;
 
public class Animal {
    protected String nome;
    protected String cor;
    protected double peso; // em kg
    protected String somQueFaz;
    protected String estadoEspirito; // Ex: feliz, com fome, alerta
 
    // Construtor da superclasse
    public Animal(String nome, String cor, double peso, String somQueFaz) {
        this.nome = nome;
        this.cor = cor;
        this.peso = peso;
        this.somQueFaz = somQueFaz;
        this.estadoEspirito = "neutro"; // Estado inicial padrão
    }
 
    // Getters
    public String getNome() {
        return nome;
    }
 
    public String getCor() {
        return cor;
    }
 
    public double getPeso() {
        return peso;
    }
 
    public String getSomQueFaz() {
        return somQueFaz;
    }
 
    public String getEstadoEspirito() {
        return estadoEspirito;
    }
 
    // Setters (exemplo para nome e estadoEspirito)
    public void setNome(String nome) {
        if (nome != null && !nome.trim().isEmpty()) {
            this.nome = nome;
        } else {
            System.out.println("Nome de animal inválido!");
        }
    }
 
    public void setEstadoEspirito(String estadoEspirito) {
        this.estadoEspirito = estadoEspirito;
    }
 
    // Métodos comuns a todos os animais
    public void comer() {
        System.out.println(this.nome + " está comendo.");
        this.estadoEspirito = "satisfeito";
    }
 
    public void dormir() {
        System.out.println(this.nome + " está dormindo... ZzzZz...");
        this.estadoEspirito = "descansando";
    }
 
    public void emitirSom() {
        System.out.println(this.nome + " faz: " + this.somQueFaz);
    }
}

package Animais;
 
public class Cao extends Animal { // Cao HERDA de Animal
    private int tamanhoRabo; // Atributo específico do cão
    private static int numeroDeCaes = 0; // Contador específico para cães
 
    // Construtor da subclasse Cao
    public Cao(String nome, String cor, double peso, int tamanhoRabo) {
        // 1. Chama o construtor da superclasse (Animal) OBRIGATORIAMENTE
        super(nome, cor, peso, "Au Au!"); // "Au Au!" é o som padrão para cães
        this.tamanhoRabo = tamanhoRabo;
        numeroDeCaes++;
    }
 
    // Getter e Setter para o atributo específico
    public int getTamanhoRabo() {
        return tamanhoRabo;
    }
 
    public void setTamanhoRabo(int tamanhoRabo) {
        if (tamanhoRabo >= 0) {
            this.tamanhoRabo = tamanhoRabo;
        } else {
            System.out.println("Tamanho do rabo inválido.");
        }
    }
 
    public static int getNumeroDeCaes() {
        return numeroDeCaes;
    }
 
    // Comportamentos específicos ou modificados do cão
    public void abanarRabo() {
        System.out.println(this.nome + " está abanando o rabo alegremente!");
        this.estadoEspirito = "feliz";
    }
 
    public String interagir(String acao) {
        switch (acao.toLowerCase()) {
            case "carinho":
                this.abanarRabo(); // Reutiliza o método específico
                break;
            case "buscar bolinha":
                this.estadoEspirito = "brincalhão e focado";
                System.out.println(this.nome + " correu para buscar a bolinha!");
                break;
            default:
                this.estadoEspirito = "neutro";
                break;
        }
        return this.estadoEspirito;
    }
 
    // Sobrescrevendo um método da superclasse (Polimorfismo)
    @Override
    public void emitirSom() {
        System.out.println(this.nome + " late vigorosamente: AU AU AUUUU!");
    }
 
    // Opcional: Sobrescrever comer para adicionar comportamento específico
    @Override
    public void comer() {
        super.comer(); // Chama o método comer() da classe Animal
        System.out.println(this.nome + " realmente adora sua ração!");
    }
}

package Animais;
 
public class Gato extends Animal {
    private boolean gostaDeLaser;
    private static int numeroDeGatos = 0;
 
    public Gato(String nome, String cor, double peso, boolean gostaDeLaser) {
        super(nome, cor, peso, "Miau!");
        this.gostaDeLaser = gostaDeLaser;
        numeroDeGatos++;
    }
 
    public boolean isGostaDeLaser() { // Getter para boolean é frequentemente "isNomeDoAtributo"
        return gostaDeLaser;
    }
 
    public void setGostaDeLaser(boolean gostaDeLaser) {
        this.gostaDeLaser = gostaDeLaser;
    }
 
    public static int getNumeroDeGatos() {
        return numeroDeGatos;
    }
 
    public void ronronar() {
        System.out.println(this.nome + " está ronronando suavemente... Purrrr...");
        this.estadoEspirito = "contente";
    }
 
    @Override
    public void emitirSom() {
        System.out.println(this.nome + " mia: Miaaauuuu!");
    }
 
    // Gatos podem ter uma forma particular de interagir
    public void interagir(String estimulo) {
        if (estimulo.equals("laser") && this.gostaDeLaser) {
            System.out.println(this.nome + " persegue o ponto de laser freneticamente!");
            this.estadoEspirito = "brincalhão";
        } else if (estimulo.equals("sache")) {
            this.comer(); // Reutiliza o método herdado
            this.ronronar();
        } else {
            System.out.println(this.nome + " observa com desdém.");
            this.estadoEspirito = "indiferente";
        }
    }
}

package Animais;
 
public class Passaro extends Animal {
    private double envergaduraAsa; // em cm
    private static int numeroDePassaros = 0;
 
    public Passaro(String nome, String cor, double peso, double envergaduraAsa) {
        super(nome, cor, peso, "Piu Piu!"); // Som padrão para pássaros
        this.envergaduraAsa = envergaduraAsa;
        numeroDePassaros++;
    }
 
    public double getEnvergaduraAsa() {
        return envergaduraAsa;
    }
 
    public void setEnvergaduraAsa(double envergaduraAsa) {
        if (envergaduraAsa > 0) {
            this.envergaduraAsa = envergaduraAsa;
        } else {
            System.out.println("Envergadura da asa inválida.");
        }
    }
 
    public static int getNumeroDePassaros() {
        return numeroDePassaros;
    }
 
    public void voar() {
        System.out.println(this.nome + " está voando alto com suas asas de " + this.envergaduraAsa + "cm!");
        this.estadoEspirito = "livre";
    }
 
    @Override
    public void emitirSom() {
        System.out.println(this.nome + " canta melodiosamente: Piu piu piu!");
    }
 
    // Pássaros também comem de forma específica
    @Override
    public void comer() {
        System.out.println(this.nome + " está bicando sementes.");
        this.estadoEspirito = "satisfeito";
    }
}

package Main;
 
import Animais.*; // Importa todas as classes do pacote Animais
 
public class Zoologico {
    public static void main(String[] args) {
        // Criando objetos das subclasses
        Cao rex = new Cao("Rex", "Marrom", 15.5, 10);
        Gato felix = new Gato("Felix", "Preto e Branco", 4.2, true);
        Passaro tweety = new Passaro("Tweety", "Amarelo", 0.2, 15.0);
 
        System.out.println("--- Informações e Ações do Rex (Cão) ---");
        System.out.println("Nome: " + rex.getNome());
        System.out.println("Cor: " + rex.getCor());
        System.out.println("Tamanho do Rabo: " + rex.getTamanhoRabo() + "cm");
        rex.comer();         // Chama o comer() sobrescrito do Cao
        rex.emitirSom();     // Chama o emitirSom() sobrescrito do Cao
        rex.abanarRabo();
        rex.interagir("carinho");
        System.out.println("Estado do Rex: " + rex.getEstadoEspirito());
 
        System.out.println("\n--- Informações e Ações do Felix (Gato) ---");
        System.out.println("Nome: " + felix.getNome());
        System.out.println("Gosta de laser? " + felix.isGostaDeLaser());
        felix.comer();       // Chama o comer() herdado de Animal
        felix.emitirSom();   // Chama o emitirSom() sobrescrito do Gato
        felix.ronronar();
        felix.interagir("laser");
 
        System.out.println("\n--- Informações e Ações do Tweety (Pássaro) ---");
        System.out.println("Nome: " + tweety.getNome());
        System.out.println("Envergadura da Asa: " + tweety.getEnvergaduraAsa() + "cm");
        tweety.comer();      // Chama o comer() sobrescrito do Passaro
        tweety.emitirSom();  // Chama o emitirSom() sobrescrito do Passaro
        tweety.voar();
 
        System.out.println("\n--- Contagem de Animais (Estático) ---");
        System.out.println("Número total de cães criados: " + Cao.getNumeroDeCaes());
        System.out.println("Número total de gatos criados: " + Gato.getNumeroDeGatos());
        System.out.println("Número total de pássaros criados: " + Passaro.getNumeroDePassaros());
 
        System.out.println("\n--- Polimorfismo em Ação ---");
        // Criando um array de Animal que pode conter qualquer subclasse de Animal
        Animal[] meusAnimais = new Animal[3];
        meusAnimais[0] = rex;    // Cao É UM Animal
        meusAnimais[1] = felix;  // Gato É UM Animal
        meusAnimais[2] = tweety; // Passaro É UM Animal
 
        for (Animal animal : meusAnimais) {
            System.out.println("\nAnimal: " + animal.getNome());
            animal.emitirSom(); // Chama o método específico da subclasse!
            animal.comer();     // Chama o método específico da subclasse (se sobrescrito) ou da superclasse
            // animal.abanarRabo(); // ERRO! O tipo da referência é Animal, e Animal não tem abanarRabo().
                                 // Para chamar métodos específicos, precisaríamos de um cast com verificação (instanceof).
        }
    }
}

public class Pessoa {
    private String nome;
    private String cpf;
    private String endereco;
 
    public Pessoa(String cpf, String nome) {
        this.cpf = cpf;
        this.nome = nome;
    }
 
    public String getNome() {
        return nome;
    }
 
    public void setNome(String nome) {
        this.nome = nome;
    }
 
    public String getCpf() {
        return cpf;
    }
 
    public void setCpf(String cpf) {
        this.cpf = cpf;
    }
 
    public String getEndereco() {
        return endereco;
    }
 
    public void setEndereco(String endereco) {
        this.endereco = endereco;
    }
}

public class Main {
    public static void main(String[] args) {
        Pessoa pessoa = new Pessoa("123456789", "Clon");
        pessoa.setEndereco("Rua Exemplo, 123");
        System.out.println(pessoa.getNome() + " - " + pessoa.getEndereco());
    }
}

// Definição do enum
public enum DiaDaSemana {
    SEGUNDA, 
    TERCA, 
    QUARTA, 
    QUINTA, 
    SEXTA, 
    SABADO, 
    DOMINGO
}
 
// Uso em outra classe
public class Agendamento {
    private DiaDaSemana diaPreferido;
    
    public void agendar(DiaDaSemana dia) {
        this.diaPreferido = dia;
        System.out.println("Agendado para " + dia);
    }
    
    public static void main(String[] args) {
        Agendamento consulta = new Agendamento();
        consulta.agendar(DiaDaSemana.QUINTA);
        
        // Isto não compilaria, pois "FERIADO" não é um valor válido:
        // consulta.agendar("FERIADO"); 
    }
}

public enum DiaSemana {
    // Constantes com parâmetros para o construtor
    SEGUNDA("Segunda-feira", false),
    TERCA("Terça-feira", false),
    QUARTA("Quarta-feira", false),
    QUINTA("Quinta-feira", false),
    SEXTA("Sexta-feira", false),
    SABADO("Sábado", true),
    DOMINGO("Domingo", true);
 
    // Atributos privados
    private final String nomeAmigavel;
    private final boolean ehFimDeSemana;
 
    // Construtor (sempre private em enums)
    private DiaSemana(String nomeAmigavel, boolean ehFimDeSemana) {
        this.nomeAmigavel = nomeAmigavel;
        this.ehFimDeSemana = ehFimDeSemana;
    }
 
    // Métodos de acesso (getters)
    public String getNomeAmigavel() {
        return nomeAmigavel;
    }
 
    public boolean isEhFimDeSemana() {
        return ehFimDeSemana;
    }
    
    // Método personalizado
    public String getSaudacao() {
        if (this == SEGUNDA) {
            return "Começando a semana com energia!";
        } else if (this == SEXTA) {
            return "Sextou! Bom fim de semana!";
        } else if (ehFimDeSemana) {
            return "Aproveite seu descanso!";
        } else {
            return "Tenha um ótimo dia!";
        }
    }
    
    // Sobrescrevendo método toString
    @Override
    public String toString() {
        return nomeAmigavel;
    }
}

public class ExemploEnum {
    public static void main(String[] args) {
        // Acessando constantes do enum
        DiaSemana hoje = DiaSemana.QUARTA;
        
        // Usando métodos e propriedades
        System.out.println("Hoje é: " + hoje.getNomeAmigavel());
        System.out.println("É fim de semana? " + (hoje.isEhFimDeSemana() ? "Sim" : "Não"));
        System.out.println("Saudação: " + hoje.getSaudacao());
        
        // Iterando sobre todos os valores possíveis
        System.out.println("\n--- Todos os dias da semana ---");
        for (DiaSemana dia : DiaSemana.values()) {
            System.out.printf("%s - %s%n", 
                dia.getNomeAmigavel(), 
                dia.isEhFimDeSemana() ? "Final de semana" : "Dia útil");
        }
        
        // Usando enum em switch - uma combinação poderosa!
        System.out.println("\n--- Planejamento semanal ---");
        planejamentoDoDia(DiaSemana.SEGUNDA);
        planejamentoDoDia(DiaSemana.SABADO);
    }
    
    public static void planejamentoDoDia(DiaSemana dia) {
        System.out.println("Plano para " + dia + ":");
        
        switch (dia) {
            case SEGUNDA:
                System.out.println("- Reunião de planejamento semanal");
                System.out.println("- Responder emails do fim de semana");
                break;
            case TERCA:
            case QUARTA:
            case QUINTA:
                System.out.println("- Dia normal de trabalho");
                System.out.println("- Desenvolvimento de projetos");
                break;
            case SEXTA:
                System.out.println("- Revisão semanal");
                System.out.println("- Happy hour com colegas");
                break;
            case SABADO:
            case DOMINGO:
                System.out.println("- Descanso e lazer");
                System.out.println("- Tempo com família e amigos");
                break;
        }
    }
}

public enum StatusPedido {
    AGUARDANDO_PAGAMENTO("Aguardando Pagamento", false),
    PAGO("Pago", false),
    EM_SEPARACAO("Em Separação", false),
    ENVIADO("Enviado", true),
    ENTREGUE("Entregue", true),
    CANCELADO("Cancelado", false);
    
    private final String descricao;
    private final boolean foiEnviado;
    
    private StatusPedido(String descricao, boolean foiEnviado) {
        this.descricao = descricao;
        this.foiEnviado = foiEnviado;
    }
    
    public String getDescricao() {
        return descricao;
    }
    
    public boolean isFoiEnviado() {
        return foiEnviado;
    }
    
    // Verifica se a transição para o próximo status é válida
    public boolean podeMudarPara(StatusPedido novoStatus) {
        switch (this) {
            case AGUARDANDO_PAGAMENTO:
                return novoStatus == PAGO || novoStatus == CANCELADO;
                
            case PAGO:
                return novoStatus == EM_SEPARACAO || novoStatus == CANCELADO;
                
            case EM_SEPARACAO:
                return novoStatus == ENVIADO || novoStatus == CANCELADO;
                
            case ENVIADO:
                return novoStatus == ENTREGUE;
                
            case ENTREGUE:
            case CANCELADO:
                return false; // Estados finais
                
            default:
                return false;
        }
    }
}

public class Pedido {
    private long id;
    private StatusPedido status;
    private LocalDateTime dataCriacao;
    private double valorTotal;
    
    public Pedido(long id, double valorTotal) {
        this.id = id;
        this.valorTotal = valorTotal;
        this.dataCriacao = LocalDateTime.now();
        this.status = StatusPedido.AGUARDANDO_PAGAMENTO;
    }
    
    public boolean atualizarStatus(StatusPedido novoStatus) {
        if (status.podeMudarPara(novoStatus)) {
            System.out.printf("Pedido #%d: Mudando status de %s para %s%n", 
                id, status.getDescricao(), novoStatus.getDescricao());
            this.status = novoStatus;
            return true;
        } else {
            System.out.printf("Erro: Não é possível mudar de %s para %s%n", 
                status.getDescricao(), novoStatus.getDescricao());
            return false;
        }
    }
    
    // Métodos getters e setters omitidos
}

public class SistemaPedidos {
    public static void main(String[] args) {
        Pedido pedido = new Pedido(12345, 199.90);
        
        // Fluxo válido
        pedido.atualizarStatus(StatusPedido.PAGO);           // OK
        pedido.atualizarStatus(StatusPedido.EM_SEPARACAO);   // OK
        pedido.atualizarStatus(StatusPedido.ENVIADO);        // OK
        pedido.atualizarStatus(StatusPedido.ENTREGUE);       // OK
        
        // Tentativa inválida
        pedido.atualizarStatus(StatusPedido.CANCELADO);      // Erro
        
        // Criando outro pedido com cancelamento
        Pedido pedido2 = new Pedido(12346, 59.90);
        pedido2.atualizarStatus(StatusPedido.CANCELADO);     // OK
        pedido2.atualizarStatus(StatusPedido.PAGO);          // Erro
    }
}

// String para Enum
String entradaUsuario = "QUINTA";
try {
    DiaSemana dia = DiaSemana.valueOf(entradaUsuario.toUpperCase());
    System.out.println("Dia selecionado: " + dia.getNomeAmigavel());
} catch (IllegalArgumentException e) {
    System.out.println("Dia inválido! Os valores permitidos são: " + 
        Arrays.toString(DiaSemana.values()));
}
 
// Enum para String
DiaSemana dia = DiaSemana.DOMINGO;
String nomeTecnico = dia.name();         // "DOMINGO"
String nomeExibicao = dia.toString();    // "Domingo" (usando nosso toString personalizado)
int posicao = dia.ordinal();             // 6 (índice baseado em zero)

public interface Notificavel {
    void enviarNotificacao(String mensagem);
}
 
public enum TipoNotificacao implements Notificavel {
    EMAIL {
        @Override
        public void enviarNotificacao(String mensagem) {
            System.out.println("Enviando EMAIL: " + mensagem);
            // Lógica para enviar email
        }
    },
    SMS {
        @Override
        public void enviarNotificacao(String mensagem) {
            System.out.println("Enviando SMS: " + mensagem);
            // Lógica para enviar SMS
        }
    },
    PUSH {
        @Override
        public void enviarNotificacao(String mensagem) {
            System.out.println("Enviando PUSH: " + mensagem);
            // Lógica para enviar notificação push
        }
    };
}

import java.util.ArrayList;
import java.util.List;
 
public class ListaDeCompras {
    public static void main(String[] args) {
        // Criando uma lista de compras
        List<String> compras = new ArrayList<>();
        
        // Adicionando itens
        compras.add("Leite");
        compras.add("Pão");
        compras.add("Queijo");
        compras.add("Leite");  // Duplicata permitida!
        
        System.out.println("Lista de compras: " + compras);
        System.out.println("Número de itens: " + compras.size());
        System.out.println("Segundo item: " + compras.get(1));  // Acesso por índice
        
        // Verificando se contém um item
        if (compras.contains("Pão")) {
            System.out.println("Pão já está na lista.");
        }
        
        // Removendo um item
        compras.remove("Queijo");
        System.out.println("Lista após remoção: " + compras);
        
        // Iterando sobre a lista
        System.out.println("\nItens para comprar:");
        for (int i = 0; i < compras.size(); i++) {
            System.out.println((i+1) + ". " + compras.get(i));
        }
        
        // Limpar toda a lista
        compras.clear();
        System.out.println("Lista vazia? " + compras.isEmpty());
    }
}

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
 
public class RegistroAlunos {
    public static void main(String[] args) {
        // HashSet: Conjunto sem ordem garantida
        Set<String> alunos = new HashSet<>();
        
        // Adicionando alunos
        alunos.add("Maria");
        alunos.add("João");
        alunos.add("Pedro");
        alunos.add("Maria");  // Não será adicionado novamente!
        
        System.out.println("Alunos registrados (HashSet): " + alunos);
        // Saída pode ser: [Pedro, João, Maria] (ordem não garantida)
        
        // TreeSet: Conjunto ordenado
        Set<String> alunosOrdenados = new TreeSet<>();
        alunosOrdenados.addAll(alunos);  // Adiciona todos do outro conjunto
        alunosOrdenados.add("Ana");
        
        System.out.println("Alunos em ordem alfabética (TreeSet): " + alunosOrdenados);
        // Saída será: [Ana, João, Maria, Pedro]
        
        // Operações de conjunto
        System.out.println("Total de alunos: " + alunosOrdenados.size());
        System.out.println("Contém Maria? " + alunosOrdenados.contains("Maria"));
        
        // Iterando com for-each (funciona para qualquer Collection)
        System.out.println("\nLista de chamada:");
        for (String aluno : alunosOrdenados) {
            System.out.println("- " + aluno);
        }
    }
}

import java.util.HashMap;
import java.util.Map;
 
public class NotasAlunos {
    public static void main(String[] args) {
        // Mapa de alunos e suas notas
        Map<String, Double> notas = new HashMap<>();
        
        // Adicionando pares chave-valor
        notas.put("Ana", 9.5);
        notas.put("Bruno", 7.8);
        notas.put("Carla", 8.7);
        notas.put("Ana", 9.8);  // Sobrescreve o valor anterior!
        
        System.out.println("Registros de notas: " + notas);
        System.out.println("Nota de Bruno: " + notas.get("Bruno"));
        
        // Verificando existência
        System.out.println("Contém registro de Danilo? " + notas.containsKey("Danilo"));
        System.out.println("Alguém tirou 8.7? " + notas.containsValue(8.7));
        
        // Iterando sobre o mapa
        System.out.println("\nRelatório de notas:");
        for (Map.Entry<String, Double> entrada : notas.entrySet()) {
            System.out.println(entrada.getKey() + ": " + entrada.getValue());
        }
        
        // Forma mais moderna (Java 8+)
        System.out.println("\nAlunos com nota acima de 9.0:");
        notas.forEach((aluno, nota) -> {
            if (nota > 9.0) {
                System.out.println(aluno + ": " + nota);
            }
        });
        
        // Removendo um registro
        notas.remove("Bruno");
        System.out.println("\nApós remoção: " + notas);
    }
}

import java.util.*;
 
public class OperacoesAvancadas {
    public static void main(String[] args) {
        List<Integer> numeros = new ArrayList<>(Arrays.asList(5, 2, 9, 1, 7, 3));
        
        // Ordenação
        Collections.sort(numeros);
        System.out.println("Ordenados: " + numeros);  // [1, 2, 3, 5, 7, 9]
        
        // Ordem reversa
        Collections.reverse(numeros);
        System.out.println("Reverso: " + numeros);    // [9, 7, 5, 3, 2, 1]
        
        // Embaralhamento
        Collections.shuffle(numeros);
        System.out.println("Embaralhados: " + numeros);  // Ordem aleatória
        
        // Valor máximo/mínimo
        int max = Collections.max(numeros);
        int min = Collections.min(numeros);
        System.out.println("Máximo: " + max + ", Mínimo: " + min);
        
        // Coleção imutável
        List<String> naoModificavel = Collections.unmodifiableList(
            Arrays.asList("Este", "é", "imutável")
        );
        System.out.println("Lista imutável: " + naoModificavel);
        // naoModificavel.add("Erro!"); // Lança UnsupportedOperationException
        
        // Preenchimento
        List<String> repetidos = new ArrayList<>(Collections.nCopies(5, "Repetido"));
        System.out.println("5 repetições: " + repetidos);
    }
}

import java.util.*;
import java.util.stream.*;
 
public class ExemploStream {
    public static void main(String[] args) {
        List<Integer> numeros = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        
        // Sem Stream API (forma imperativa)
        List<Integer> paresDobrados = new ArrayList<>();
        for (Integer n : numeros) {
            if (n % 2 == 0) {
                paresDobrados.add(n * 2);
            }
        }
        System.out.println("Pares dobrados (imperativo): " + paresDobrados);
        
        // Com Stream API (forma declarativa)
        List<Integer> paresDobradosStream = numeros.stream()
                                                 .filter(n -> n % 2 == 0)  // Filtra pares
                                                 .map(n -> n * 2)          // Dobra
                                                 .collect(Collectors.toList());  // Coleta em lista
        System.out.println("Pares dobrados (declarativo): " + paresDobradosStream);
        
        // Outras operações úteis com Stream
        // Soma dos números ímpares
        int somaImpares = numeros.stream()
                                .filter(n -> n % 2 != 0)
                                .reduce(0, Integer::sum);
        System.out.println("Soma dos ímpares: " + somaImpares);
        
        // Estatísticas
        IntSummaryStatistics estatisticas = numeros.stream()
                                                .mapToInt(Integer::intValue)
                                                .summaryStatistics();
        System.out.println("\nEstatísticas dos números:");
        System.out.println("Contagem: " + estatisticas.getCount());
        System.out.println("Soma: " + estatisticas.getSum());
        System.out.println("Mínimo: " + estatisticas.getMin());
        System.out.println("Máximo: " + estatisticas.getMax());
        System.out.println("Média: " + estatisticas.getAverage());
    }
}