Organização de Código em Java: Pacotes e a Diretiva import

À medida que os programas crescem, organizar as classes se torna fundamental. Em Java, essa organização é feita através de pacotes (packages). Um pacote é um agrupamento de classes e outras interfaces relacionadas, funcionando como um diretório que agrupa arquivos com um propósito comum.

A biblioteca padrão do Java é um excelente exemplo dessa organização, com pacotes como java.lang (para funcionalidades básicas da linguagem), java.util (para utilitários e estruturas de dados) e java.io (para entrada e saída de dados).

Organizar o código em pacotes atende a dois objetivos cruciais:

1. Manutenção e Clareza: Agrupa classes com funcionalidades relacionadas, tornando o projeto mais fácil de navegar e entender.
2. Prevenção de Conflitos de Nomes: Pacotes criam um "espaço de nomes" (namespace). Isso permite que existam classes com o mesmo nome, desde que estejam em pacotes diferentes. Por exemplo, uma classe Date no pacote java.util e outra no pacote java.sql coexistem sem conflitos.

A Relação entre Pacotes e Diretórios: Uma Regra Fundamental

Em Java, existe uma regra estrita que conecta o nome de um pacote à estrutura de pastas do seu projeto: o nome do pacote deve espelhar exatamente a hierarquia de diretórios onde o arquivo de código-fonte (.java) está localizado.

Para declarar que uma classe pertence a um pacote, utiliza-se a diretiva package como a primeira linha do arquivo.

Vamos ver isso com um exemplo prático.

Cenário 1: O Pacote Padrão (Não Recomendado)

Se um arquivo .java não tem a declaração package, ele pertence ao pacote padrão (default package).

// Nenhum "package" declarado aqui.
public class TesteRapido {
    // ...
}

Neste caso, o arquivo TesteRapido.java pode estar diretamente na pasta raiz do seu código-fonte (ex: src/). Essa abordagem é aceitável apenas para testes simples e únicos. Para projetos reais, é fortemente desaconselhada.

Cenário 2: Um Pacote Declarado (A Prática Correta)

Vamos organizar nosso código. Se decidirmos que a classe Usuario deve pertencer ao pacote com.meuapp.modelo, adicionamos a seguinte declaração:

package com.meuapp.modelo;

public class Usuario {
    // ...
}

A Regra em Ação: Para que o compilador Java aceite este código, o arquivo Usuario.java precisa estar localizado em uma estrutura de pastas que corresponda ao nome do pacote. Cada ponto . no nome do pacote representa um novo subdiretório.

Estrutura de Pastas Obrigatória:

meu_projeto/
└── src/
    └── com/
        └── meuapp/
            └── modelo/
                └── Usuario.java

Se a localização física do arquivo não corresponder à sua declaração lógica de pacote, o código não irá compilar.

Usando Classes de Outros Pacotes com import

Para usar uma classe que está em outro pacote, você precisa "informar" ao compilador onde encontrá-la. A única exceção é o pacote java.lang (que contém String, System, etc.), que é importado automaticamente.

Uma forma é usar o nome completo qualificado da classe:

java.util.Scanner in = new java.util.Scanner(System.in); // Verboso e impraticável

A abordagem correta e universal é usar a diretiva import, declarada no início do arquivo, logo após a diretiva package.

package com.meuapp;

import java.util.Scanner; // Importa a classe Scanner para este arquivo

public class Program {
    public static void main(String[] args) {
        // Agora podemos usar o nome simples da classe
        Scanner in = new Scanner(System.in);
    }
}

Se precisar de várias classes do mesmo pacote, pode-se usar o caractere curinga (*) para importar todas as classes públicas daquele pacote.

import java.util.*; // Importa ArrayList, HashMap, Date, etc.

Lidando com Conflitos de Nomes na Importação

Ocasionalmente, você pode precisar usar duas classes com o mesmo nome simples de pacotes diferentes. Nesse cenário, o import não pode resolver a ambiguidade para ambas. A solução é importar uma delas e usar o nome completo qualificado para a outra.

import java.util.Date; // Importa a Date do pacote util

class ConexaoBanco {
    void salvar() {
        // Usa a Date importada
        Date utilDate = new Date();

        // Usa a outra Date com seu nome completo para desambiguar
        java.sql.Date sqlDate = new java.sql.Date(utilDate.getTime());
        // ...
    }
}

Importação Estática: Um Atalho para Membros Estáticos

Além de importar classes, o Java permite a importação estática de membros estáticos (campos e métodos) de uma classe. Isso possibilita o uso desses membros diretamente, sem o prefixo do nome da classe.

Para isso, utiliza-se a diretiva import static.

// Importa estaticamente o campo 'out' e os métodos 'sqrt' e 'pow'
import static java.lang.System.out;
import static java.lang.Math.sqrt;
import static java.lang.Math.pow;

public class Program {
    public static void main(String[] args) {
        // Graças à importação estática, o código fica mais conciso.
        double resultado = sqrt(pow(5, 2));
        out.println("O resultado é: " + resultado);
    }
}

Quando usar? A importação estática deve ser usada com moderação para não prejudicar a legibilidade. Ela é mais eficaz quando você usa frequentemente um pequeno número de membros estáticos de uma classe, como constantes (Math.PI) ou métodos de fábrica (factories). Seu uso excessivo pode tornar o código confuso, dificultando a identificação da origem de um método.

📝 Exercícios

Tarefa 1 (Teoria)

Descrição: Um desenvolvedor criou um arquivo Produto.java com o seguinte conteúdo. Ele colocou este arquivo diretamente dentro da pasta src/ de seu projeto. O que acontecerá quando ele tentar compilar o projeto?

package com.loja.modelos;

public class Produto {
    String nome;
}

Estrutura de pastas:

meu_projeto/
└── src/
    └── Produto.java

Alternativas:

• O código irá compilar e executar normalmente.
• O código irá compilar, mas lançará um ClassNotFoundException ao ser executado.
• Ocorrerá um erro de compilação, pois a localização do arquivo não corresponde à declaração do pacote.
• Ocorrerá um erro de compilação, pois a classe Produto precisa de um construtor.
• Ocorrerá um erro em tempo de execução, pois o campo nome não foi inicializado.

Tarefa 2 (Teoria)

Descrição: Analise o código abaixo. Supondo que tanto o pacote java.awt quanto o java.util possuem uma classe chamada List, o que acontecerá ao tentar compilar este arquivo?

package com.meuapp;

import java.awt.*;
import java.util.*;

public class UiComponent {
    void desenhar() {
        List minhaLista;
    }
}

Alternativas:

• O código irá compilar, e minhaLista será do tipo java.util.List por padrão.
• Ocorrerá um erro de compilação devido a uma referência ambígua à classe List.
• O código irá compilar, pois a JVM escolherá a classe mais apropriada em tempo de execução.
• O código irá compilar, e minhaLista será do tipo java.awt.List, pois foi importado primeiro.
• Ocorrerá um NullPointerException ao executar.