Public, protected, private e package-private em Java: análise completa

O que os modificadores de acesso escondem em Java? Mergulhando no encapsulamento

Todo mundo que começou a estudar Java já se deparou com as palavras misteriosas public, private e protected antes de campos e métodos. Mas o que elas realmente significam? Por que não podemos simplesmente tornar tudo public e viver em paz? E o que é esse misterioso package-private, sobre o qual a maioria dos tutoriais não fala?

Neste artigo, vamos analisar a diferença entre public, protected, package-private e private em Java com exemplos reais de código. Você aprenderá como cada modificador funciona, em quais situações aplicá-los e por que a escolha correta do modificador de acesso é um sinal de bom pensamento arquitetônico. Vamos lá!

Por que os modificadores de acesso são necessários?

Imagine que você está construindo uma casa. Você tem uma porta de entrada (acessível a todos), uma sala de estar (acessível a amigos), um escritório pessoal (apenas para a família) e um cofre (apenas para você). Os modificadores de acesso em Java funcionam exatamente da mesma forma: eles definem quem pode "entrar" na sua classe, método ou campo.

O objetivo principal é o encapsulamento. Escondemos os detalhes internos de implementação da classe e fornecemos para fora apenas o que é realmente necessário. Isso protege os dados de alterações acidentais e simplifica a manutenção do código.

Visão geral dos quatro níveis de acesso

Em Java, existem quatro níveis de acesso (do mais restritivo ao mais aberto):

\n
• private — acesso apenas dentro da classe
\n
• package-private (padrão) — acesso dentro da classe e do pacote
\n
• protected — classe + pacote + subclasses
\n
• public — acesso de qualquer lugar
\n

Private: "Meu, e de mais ninguém"

O modificador private é o mais restritivo. Um campo ou método marcado como private é acessível apenas dentro da mesma classe. Nem subclasses, nem classes do mesmo pacote podem acessá-lo.

public class BankAccount {\n    private double balance;  // Acessível apenas dentro da classe\n\n    public BankAccount(double initialBalance) {\n        this.balance = initialBalance;\n    }\n\n    public void deposit(double amount) {\n        if (amount > 0) {\n            balance += amount;\n        }\n    }\n\n    // Este método vê o campo private porque está dentro da classe\n    public double getBalance() {\n        return balance;\n    }\n}\n\npublic class Main {\n    public static void main(String[] args) {\n        BankAccount account = new BankAccount(1000);\n        // account.balance = 5000;  // Erro de compilação! balance é private\n        System.out.println(account.getBalance());  // Funciona através do método público\n    }\n}

Quando usar: para dados internos da classe que não devem ser alterados externamente (por exemplo, contador, estado interno do objeto).

Package-private (default): "O vizinho quieto"

Se você não especificar nenhum modificador, o Java torna automaticamente o acesso package-private. Isso significa que o campo ou método é visível para todas as classes dentro do mesmo pacote, mas não é visível fora dele.

package com.pythonlib.utils;\n\nclass Helper {  // Classe package-private (sem modificador)\n    String secretMessage = "Visível apenas dentro do pacote";  // Campo package-private\n\n    void displayMessage() {  // Método package-private\n        System.out.println(secretMessage);\n    }\n}\n\npackage com.pythonlib.app;\n\nimport com.pythonlib.utils.Helper;\n\npublic class App {\n    public static void main(String[] args) {\n        Helper helper = new Helper();\n        // helper.secretMessage = "Erro!";  // Não visível — pacote diferente\n        // helper.displayMessage();  // Erro de compilação\n    }\n}

Quando usar: para classes auxiliares