Java - Pacotes
Os pacotes são usados em Java para evitar conflitos de nomenclatura, controlar o acesso, facilitar a busca/localização e uso de classes, interfaces, enumerações e anotações, etc.
Um Pacote 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 empacotadas 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 se 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 em outros pacotes. Usando pacotes, é mais fácil fornecer controle de acesso e também é mais fácil localizar as classes relacionadas.
Criando um pacote
Ao criar um pacote, você deve escolher um nome para o pacote e incluir um pacote juntamente com esse nome na parte superior 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 ela 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 de 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 animals −
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 como mostrado abaixo -
$ javac -d . Animal.java $ javac -d . MammalInt.java
Agora um pacote/pasta com o nome animais 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 quiser usar outra classe no mesmo pacote, o nome do pacote não precisa ser usado. Classes no mesmo pacote se encontram sem nenhuma sintaxe especial.
Exemplo
Aqui, uma classe chamada Boss é adicionada ao pacote de folha de pagamento que já contém Employee. O Chefe pode então se referir à classe Funcionário sem usar o prefixo da folha de pagamento, conforme demonstrado pela classe Chefe a seguir.
package payroll;
public class Boss {
public void payEmployee(Employee e) {
e.mailCheck();
}
}
O que acontece se a classe Employee 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;
Observação − 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 de diretórios de pacotes
Dois resultados principais ocorrem quando uma classe é colocada em um pacote -
-
O nome do pacote se torna parte do nome da classe, como acabamos de discutir na seção anterior.
-
O nome do pacote deve corresponder à estrutura de diretórios onde reside o bytecode correspondente.
Aqui está 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 seja o nome simples do tipo e cuja extensão seja .java .
Por exemplo -
// File Name : Car.java
package vehicle;
public class Car {
// Class implementation.
}
Agora, coloque o arquivo fonte em um diretório cujo nome reflita o nome do pacote ao qual a classe pertence -
....\vehicle\Car.java
Agora, o nome da classe qualificada e o nome do caminho seriam os seguintes -
- Nome da classe → veículo.Carro
- Nome do caminho → veículo\Carro.java (no Windows)
Em geral, uma empresa usa seu nome de domínio da Internet invertido para seus nomes de pacotes.
Exemplo − O nome de domínio da Internet de uma empresa é apple.com, então todos os nomes de seus pacotes começariam com com.apple. Cada componente do nome do pacote corresponde a um subdiretório.
Exemplo − A empresa tinha um pacote com.apple.computers que continha um arquivo fonte 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 da seguinte forma 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.*;
Assim 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 fonte e classe separadamente, como −
<path-one>\sources\com\apple\computers\Dell.java <path-two>\classes\com\apple\computers\Dell.class
Ao fazer isso, é possível dar acesso ao diretório de classes para outros programadores sem revelar suas fontes. Você também precisa gerenciar arquivos de origem e de classe dessa maneira para que o compilador e a Java Virtual Machine (JVM) possam localizar todos os tipos que seu programa usa.
O caminho completo para o diretório de classes,
Digamos que
Um caminho de classe pode incluir vários caminhos. Vários caminhos devem ser separados por ponto e vírgula (Windows) ou dois pontos (Unix). Por padrão, o compilador e a JVM pesquisam 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.
Definir variável de sistema CLASSPATH
Para exibir a variável CLASSPATH atual, use os seguintes comandos no Windows e UNIX (shell Bourne) -
- No Windows → C:\> defina CLASSPATH
- No UNIX → % echo $CLASSPATH
Para excluir o conteúdo atual da variável CLASSPATH, use −
- No Windows → C:\> defina CLASSPATH =
- No UNIX → % unset CLASSPATH; exportar CLASSPATH
Para definir a variável CLASSPATH −
- No Windows → defina CLASSPATH =C:\users\jack\java\classes
- No UNIX → % CLASSPATH =/home/jack/java/classes; exportar CLASSPATH
Java