Os objetos em Java encapsulam atributos e comportamentos. O acesso direto e indiscriminado às propriedades internas de um objeto é uma prática arriscada, pois impede a validação de regras de negócio.

Para gerenciar a visibilidade e proteger o estado de nossas classes, utilizamos os modificadores de acesso:

2.1 O que é Encapsulamento?

O **encapsulamento** consiste em ocultar os detalhes de implementação e o estado interno de uma classe, expondo apenas uma interface pública de métodos. Definimos os atributos como `private` e controlamos sua leitura/escrita por meio de métodos especiais: **Getters** (leitura) e **Setters** (escrita).

Barreira de Segurança: Getters/Setters controlando o acesso a atributos Privados

2.2 O Conceito de Alta Coesão

Uma classe possui alta coesão quando é extremamente focada e tem uma única responsabilidade. As validações das regras de negócio devem ocorrer dentro dela mesma. Se permitirmos que classes externas alterem ou façam as validações do nosso objeto, criamos dependências acopladas e perigosas (baixa coesão).

public class Paciente {
    private int idade; // Atributo protegido (private)

    // Construtor vazio
    public Paciente() {
    }

    // Construtor parametrizado chamando o setter para aplicar a regra
    public Paciente(int idade) {
        this.setIdade(idade);
    }

    // Getter tradicional
    public int getIdade() {
        return this.idade;
    }

    // Setter com validação interna (Alta Coesão)
    public void setIdade(int idade) {
        if (idade <= 0 || idade > 120) {
            System.out.println("[Alerta] Idade inválida de paciente ignorada!");
            this.idade = 1; // Valor padrão de consistência
        } else {
            this.idade = idade;
        }
    }
}

Uma nova classe em Java funciona como um tipo de dado personalizado. O relacionamento de **associação** ocorre quando usamos instâncias de uma classe como atributos internos de outra.

Imagine uma classe `Sorvete` que possui uma associação de um-para-um com a classe `Calda`:

// Classe auxiliar
public class Calda {
    private String sabor;
    
    public Calda(String sabor) {
        this.sabor = sabor;
    }
    public String getSabor() { return this.sabor; }
}

// Classe Principal com associação 1-1
public class Sorvete {
    private String saborSorvete;
    private Calda caldaAdicionada; // Associação 1-1

    public Sorvete(String saborSorvete) {
        this.saborSorvete = saborSorvete;
    }

    public Calda getCalda() { return this.caldaAdicionada; }
    public void setCalda(Calda calda) { this.caldaAdicionada = calda; }
}

Quando precisamos expandir a relação para permitir múltiplos objetos associados (ex: um sorvete com várias caldas), recorremos a coleções dinâmicas como o `ArrayList` da biblioteca padrão do Java.

Regra de Ouro do ArrayList

Por se tratar de um objeto complexo, um `ArrayList` **deve ser obrigatoriamente instanciado** no construtor da classe proprietária. Se você esquecer essa inicialização, tentar acessar um membro de uma referência `null` causará um erro em tempo de execução do tipo NullPointerException.

import java.util.ArrayList; // Importação da estrutura dinâmica

public class SorveteCompleto {
    private String sabor;
    private ArrayList<Calda> caldas; // Associação de 1 para N

    public SorveteCompleto(String sabor) {
        this.sabor = sabor;
        // Instanciação preventiva do objeto lista no construtor
        this.caldas = new ArrayList<Calda>();
    }

    public String getSabor() {
        return this.sabor;
    }

    // Setter adaptado para inserção unitária de objetos
    public void adicionarCalda(Calda calda) {
        this.caldas.add(calda);
    }

    public ArrayList<Calda> getCaldas() {
        return this.caldas;
    }
}

Para recuperar e iterar de forma limpa e legível os elementos armazenados dentro de uma coleção de objetos, utilizamos a simplificada estrutura do laço for-each:

public class AppSorveteria {
    public static void main(String[] args) {
        SorveteCompleto sorvete = new SorveteCompleto("Baunilha");

        // Instanciando caldas e associando ao sorvete
        sorvete.adicionarCalda(new Calda("Chocolate"));
        sorvete.adicionarCalda(new Calda("Morango"));

        System.out.println("Sorvete de: " + sorvete.getSabor());
        System.out.println("Caldas Adicionadas:");

        // Laço for-each para percorrer a coleção associada
        for (Calda c : sorvete.getCaldas()) {
            System.out.println("- Sabor da calda: " + c.getSabor());
        }
    }
}