Pacote (Package) Java

Para melhor organizar classes, o Java oferece o mecanismo de pacotes, usado para distinguir o espaço de nomes dos nomes das classes.

O papel do pacote

• 1、Organizar classes ou interfaces semelhantes ou relacionadas no mesmo pacote, facilitando a pesquisa e uso das classes.

• 2、Como uma pasta, o pacote também adota o método de armazenamento de diretório hierárquico. O nome das classes dentro do mesmo pacote é diferente, enquanto os nomes das classes em pacotes diferentes podem ser os mesmos. Quando se chama classes com o mesmo nome em pacotes diferentes ao mesmo tempo, deve-se adicionar o nome do pacote para distingui-las. Portanto, o pacote pode evitar conflitos de nomes.

• 3、O pacote também limita o acesso, apenas as classes com permissão de acesso ao pacote podem acessar classes dentro desse pacote.

O Java usa o mecanismo de pacote (package) para evitar conflitos de nomes, controle de acesso, fornecer pesquisa e localização de classes (class), interfaces, enumerações (enumerations) e anotações (annotations).

O formato da sintaxe da declaração de pacote é:

package pkg1[．pkg2[．pkg3...]];

Por exemplo, um arquivo Something.java com o seguinte conteúdo

package net.java.util;
public class Something{
　　　...
}

Então, o seu caminho deve ser net/java/util/Something.java Dessa forma é salvo. O papel do pacote (package) é classificar diferentes programas java e facilitar que outros programas java os chamem.

Um pacote (package) pode ser definido como um grupo de tipos relacionados (classes, interfaces, enumerações e comentários), fornecendo funcionalidades de proteção de acesso e gerenciamento de espaço de nomes para esses tipos.

A seguir estão alguns pacotes do Java:

• java.lang-Empacotar classes básicas

• java.io-Funções que contêm funcionalidades de entrada e saída

Desenvolvedores podem empacotar um grupo de classes e interfaces, e definir seus próprios pacotes. E na prática, fazer isso é altamente recomendável, quando você completar a implementação da classe, agrupar classes relacionadas torna mais fácil para outros desenvolvedores determinar quais classes, interfaces, enumerações e comentários são relacionados.

Como o pacote cria um novo espaço de nomes (namespace), não haverá conflito de nomes com qualquer outro pacote. Usar esse mecanismo de pacote torna mais fácil implementar controle de acesso e tornar mais simples a localização de classes relacionadas.

Criar pacote

Ao criar um pacote, você precisa escolher um nome apropriado para esse pacote. Depois, se outro arquivo de origem contiver classes, interfaces, enumerações ou tipos de comentários fornecidos por esse pacote, é necessário colocar a declaração desse pacote no início desse arquivo de origem.

A declaração de pacote deve estar na primeira linha do arquivo de origem, cada arquivo pode ter apenas uma declaração de pacote, e todos os tipos neste arquivo se aplicam a ela.

Se um arquivo de origem não usar declaração de pacote, as classes, funções, enumerações, comentários e outros serão colocados em um pacote anônimo (unnamed package).

实例

Vamos ver um exemplo, neste exemplo é criado um pacote chamado animals. Usar letras minúsculas para o nome é comum para evitar conflitos com nomes de classes e interfaces.

Adicione uma interface (interface) ao pacote animals:

/*　Nome do arquivo: Animal.java　*/
package animals;
　
interface Animal {
　　　public void eat();
　　　public void travel();
}

Em seguida, adicione a implementação dessa interface no mesmo pacote:

package animals;
　
/*　Nome do arquivo: 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();
　　　}
}

Em seguida, compile esses dois arquivos e coloque-os em um subdiretório chamado animals. Use o seguinte comando para executar:

$ mkdir animals
$ cp Animal.class	MammalInt.class animals
$ java animals/MammalInt
Mammal eats
Mammal travel

Palavra-chave import

Para poder usar os membros de um pacote específico, precisamos importá-lo explicitamente no programa Java. A instrução "import" pode realizar essa função.

No arquivo fonte Java, a instrução import deve estar localizada após a instrução package e antes de todas as definições de classes, pode não haver e pode haver várias, sua forma gramatical é:

import package1[.package2...].(classname|*);

Se uma classe dentro de um pacote quiser usar outra classe dentro do mesmo pacote, o nome do pacote pode ser omitido.

实例

以下 payroll 包已经包含了 Employee 类，接下来向 payroll 包中添加一个 Boss 类。Boss 类引用 Employee 类时可以不使用 payroll 前缀，Boss 类的示例如下。

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

如果 Boss 类不在 payroll 包中又会怎样？Boss 类必须使用以下几种方法之一来引用其他包中的类。

使用类全名描述，例如：

payroll.Employee

用 import 关键字引入，使用通配符 "*"

import  payroll.*;

使用 import 关键字引入 Employee 类：

import  payroll.Employee;

注意：

类文件中可以包含任意数量的 import 声明。import 声明必须在包声明之后，类声明之前。

包的目录结构

将类放在包中会有两种主要的结果：

• 包名成为类名的一部分，正如我们前面讨论的那样。

• 包名必须与相应的字节码所在的目录结构相匹配。

以下是管理您 java 中文件的一种简单方法：

将类、接口等类型的源代码放在一个文本中，该文件名就是这个类型的名字，并以 .java 作为扩展名。例如：

//　文件名  :  Car.java
　
package  vehicle;
　
public   class  Car  {
　　　//　类实现　　
}

接下来，将源文件放在一个目录中，该目录对应类所在的包名。

....\vehicle\Car.java

现在，正确的类名和路径将是如下所示：

• 类名 -> vehicle.Car

• 路径名 -> vehicle\Car.java (在 Windows 系统中)

通常，公司使用其互联网域名的颠倒形式作为其包名。例如：互联网域名是 oldtoolbag.com，所有包名都以 com.w3codebox 开头。包名中的每个部分对应一个子目录。

例如：有一个 com.w3codebox.test 包，此包包含一个名为 w 的3Se o arquivo fonte codebox.java, então, deve haver uma série de subdiretórios conforme mostrado a seguir:

....\com\w3codebox\test\w3codebox.java

Durante a compilação, o compilador cria um arquivo de saída diferente para cada classe, interface e outros tipos definidos no pacote, e o nome do arquivo de saída é o nome do tipo, seguido do sufixo .class. Por exemplo:

//　Nome do arquivo: w3codebox.java
　
package com.w3codebox.test;
public class w3codebox {
　　　　　　
}
class Google {
　　　　　　
}

Agora, vamos usar-usar a opção d para compilar este arquivo, conforme mostrado a seguir:

$javac　-d　.　w3codebox.java

Assim, os arquivos compilados serão colocados da seguinte forma:

.\com\w3codebox\test\w3codebox.class
.\com\w3codebox\test\Google.class

Você pode importar todos da seguinte forma: \com\w3codebox\test\ Classe, interface e outros definidos no seguinte:

import com.w3codebox.test.*;

Os arquivos .class gerados após a compilação devem estar no mesmo diretório que o arquivo .java de origem, e o diretório deve corresponder ao nome do pacote. No entanto, não é necessário que o caminho do arquivo .class seja o mesmo que o caminho do arquivo .java. Você pode organizar separadamente os diretórios de código-fonte e classes.

<path-one>\sources\com\w3codebox\test\w3codebox.java
<path-two>\classes\com\w3codebox\test\Google.class

Dessa forma, você pode compartilhar seu diretório de classes com outros programadores sem revelar seu código-fonte. Gerenciar o código-fonte e os arquivos de classes dessa maneira permite que o compilador e o JVM (Java Virtual Machine) encontrem todos os tipos usados em seu programa.

O caminho absoluto do diretório de classes é chamado de class path. Configurado na variável de sistema CLASSPATH no qual o compilador e o Java Virtual Machine (JVM) constroem o caminho do arquivo .class adicionando o nome do pacote ao class path.

<path- two>\classes é o class path, e o nome do pacote é com.w3codebox.test, enquanto o compilador e o JVM procuram no <path-two>\classes\com\w3procurar por arquivos .class dentro de codebox\test.

Um caminho de class path pode conter várias rotas, e as rotas múltiplas devem ser separadas por delimitadores. Pelo padrão, o compilador e o JVM procuram no diretório atual. Os arquivos JAR contêm classes relacionadas ao Java Platform, então seus diretórios são colocados no class path por padrão.

Configurar variável de sistema CLASSPATH

Use o comando a seguir para exibir a variável CLASSPATH atual:

• Plataforma Windows (Linha de Comandos DOS): C:\> set CLASSPATH

• Plataforma UNIX (Bourne shell): # echo $CLASSPATH

Excluir o conteúdo atual da variável CLASSPATH:

• Plataforma Windows (Linha de Comandos DOS): C:\> set CLASSPATH=

• Plataforma UNIX (Bourne shell): # unset CLASSPATH; export CLASSPATH

Configurar variável CLASSPATH:

• Plataforma Windows (Linha de Comandos DOS): C:\> set CLASSPATH=C:\users\jack\java\classes

• Plataforma UNIX (Bourne shell): # CLASSPATH=/home/jack/java/classes; export CLASSPATH