Java - Pacotes

Os pacotes são usados em Java para evitar conflitos de nomenclatura, para controlar o acesso, para tornar a pesquisa / localização e uso de classes, interfaces, enumerações e anotações mais fáceis, etc.

UMA Package pode ser definido como um agrupamento de tipos relacionados (classes, interfaces, enumerações e anotações) fornecendo proteção de acesso e gerenciamento de namespace.

Alguns dos pacotes existentes em Java são -

java.lang - agrupa as classes fundamentais
java.io - classes para funções de entrada e saída são agrupadas neste pacote

Os programadores podem definir seus próprios pacotes para agrupar grupos de classes / interfaces, etc. É uma boa prática agrupar classes relacionadas implementadas por você para que um programador possa determinar facilmente que as classes, interfaces, enumerações e anotações estão relacionadas.

Como o pacote cria um novo namespace, não haverá conflitos de nome com nomes de outros pacotes. Usando pacotes, é mais fácil fornecer controle de acesso e também localizar as classes relacionadas.

Criando um Pacote

Ao criar um pacote, você deve escolher um nome para o pacote e incluir um package juntamente com esse nome no topo de cada arquivo de origem que contém as classes, interfaces, enumerações e tipos de anotação que você deseja incluir no pacote.

A instrução do pacote deve ser a primeira linha no arquivo de origem. Pode haver apenas uma instrução de pacote em cada arquivo de origem e se aplica a todos os tipos no arquivo.

Se uma instrução de pacote não for usada, a classe, as interfaces, as enumerações e os tipos de anotação serão colocados no pacote padrão atual.

Para compilar os programas Java com instruções de pacote, você deve usar a opção -d conforme mostrado abaixo.

javac -d Destination_folder file_name.java

Em seguida, uma pasta com o nome de pacote fornecido é criada no destino especificado e os arquivos de classe compilados serão colocados nessa pasta.

Exemplo

Vejamos um exemplo que cria um pacote chamado animals. É uma boa prática usar nomes de pacotes com letras minúsculas para evitar conflitos com os nomes das classes e interfaces.

O exemplo de pacote a seguir contém uma interface chamada animals -

/* File name : Animal.java */
package animals;

interface Animal {
   public void eat();
   public void travel();
}

Agora, vamos implementar a interface acima no mesmo pacote de animais -

package animals;
/* File name : MammalInt.java */

public class MammalInt implements Animal {

   public void eat() {
      System.out.println("Mammal eats");
   }

   public void travel() {
      System.out.println("Mammal travels");
   } 

   public int noOfLegs() {
      return 0;
   }

   public static void main(String args[]) {
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

Agora compile os arquivos java conforme mostrado abaixo -

$ javac -d . Animal.java 
$ javac -d . MammalInt.java

Agora um pacote / pasta com o nome animals será criado no diretório atual e esses arquivos de classe serão colocados nele conforme mostrado abaixo.

Você pode executar o arquivo de classe dentro do pacote e obter o resultado conforme mostrado abaixo.

Mammal eats
Mammal travels

A palavra-chave de importação

Se uma classe deseja usar outra classe no mesmo pacote, o nome do pacote não precisa ser usado. As classes no mesmo pacote se encontram sem nenhuma sintaxe especial.

Exemplo

Aqui, uma classe chamada Boss é adicionada ao pacote da folha de pagamento que já contém Employee. O Boss pode então referir-se à classe Employee sem usar o prefixo da folha de pagamento, conforme demonstrado pela seguinte classe Boss.

package payroll;
public class Boss {
   public void payEmployee(Employee e) {
      e.mailCheck();
   }
}

O que acontece se a classe Funcionário não estiver no pacote de folha de pagamento? A classe Boss deve então usar uma das seguintes técnicas para se referir a uma classe em um pacote diferente.

O nome totalmente qualificado da classe pode ser usado. Por exemplo -

payroll.Employee

O pacote pode ser importado usando a palavra-chave import e o curinga (*). Por exemplo -

import payroll.*;

A própria classe pode ser importada usando a palavra-chave import. Por exemplo -

import payroll.Employee;

Note- Um arquivo de classe pode conter qualquer número de instruções de importação. As instruções de importação devem aparecer após a instrução do pacote e antes da declaração da classe.

A Estrutura do Diretório dos Pacotes

Dois resultados principais ocorrem quando uma classe é colocada em um pacote -

O nome do pacote passa a fazer parte do nome da classe, conforme discutimos na seção anterior.
O nome do pacote deve corresponder à estrutura de diretório onde reside o bytecode correspondente.

Esta é uma maneira simples de gerenciar seus arquivos em Java -

Coloque o código-fonte de uma classe, interface, enumeração ou tipo de anotação em um arquivo de texto cujo nome é o nome simples do tipo e cuja extensão é .java.

Por exemplo -

// File Name :  Car.java
package vehicle;

public class Car {
   // Class implementation.   
}

Agora, coloque o arquivo de origem em um diretório cujo nome reflita o nome do pacote ao qual a classe pertence -

....\vehicle\Car.java

Agora, o nome de classe qualificado e o nome do caminho seriam os seguintes -

Nome da classe → veículo.Carro
Nome do caminho → veículo \ Car.java (no Windows)

Em geral, uma empresa usa seu nome de domínio da Internet invertido para seus nomes de pacote.

Example- O nome de domínio da Internet de uma empresa é apple.com, então todos os nomes de seus pacotes começam com com.apple. Cada componente do nome do pacote corresponde a um subdiretório.

Example - A empresa tinha um pacote com.apple.computers que continha um arquivo de origem Dell.java, que estaria contido em uma série de subdiretórios como este -

....\com\apple\computers\Dell.java

No momento da compilação, o compilador cria um arquivo de saída diferente para cada classe, interface e enumeração definida nele. O nome base do arquivo de saída é o nome do tipo e sua extensão é.class.

Por exemplo -

// File Name: Dell.java
package com.apple.computers;

public class Dell {
}

class Ups {
}

Agora, compile este arquivo como segue usando a opção -d -

$javac -d . Dell.java

Os arquivos serão compilados da seguinte forma -

.\com\apple\computers\Dell.class
.\com\apple\computers\Ups.class

Você pode importar todas as classes ou interfaces definidas em \ com \ apple \ computers \ como segue -

import com.apple.computers.*;

Como os arquivos de origem .java, os arquivos .class compilados devem estar em uma série de diretórios que refletem o nome do pacote. No entanto, o caminho para os arquivos .class não precisa ser igual ao caminho para os arquivos de origem .java. Você pode organizar seus diretórios de origem e de classe separadamente, como -

<path-one>\sources\com\apple\computers\Dell.java

<path-two>\classes\com\apple\computers\Dell.class

Fazendo isso, é possível dar acesso ao diretório de classes a outros programadores sem revelar suas fontes. Você também precisa gerenciar os arquivos de origem e de classe dessa maneira para que o compilador e a Java Virtual Machine (JVM) possam encontrar todos os tipos que seu programa usa.

O caminho completo para o diretório de classes, <path-two> \ classes, é chamado de caminho de classe e é definido com a variável de sistema CLASSPATH. Tanto o compilador quanto a JVM constroem o caminho para seus arquivos .class adicionando o nome do pacote ao caminho da classe.

Digamos que <path-two> \ classes é o caminho da classe e o nome do pacote é com.apple.computers, então o compilador e a JVM procurarão por arquivos .class em <path-two> \ classes \ com \ apple \ computers.

Um caminho de classe pode incluir vários caminhos. Os caminhos múltiplos devem ser separados por ponto e vírgula (Windows) ou dois pontos (Unix). Por padrão, o compilador e a JVM procuram o diretório atual e o arquivo JAR que contém as classes da plataforma Java para que esses diretórios estejam automaticamente no caminho da classe.