Pacotes em Java são um mecanismo que encapsula um grupo de subpacotes de classes e interfaces. Os pacotes são usados ​​para:

• Evite conflitos de nomenclatura permitindo que classes com o mesmo nome existam em pacotes diferentes, como college.staff.cse.Employee e college.staff.ee.Employee.
• Facilite a organização, localização e uso de interfaces de classes e outros componentes.
• Fornece acesso controlado para membros protegidos que podem ser acessados ​​no mesmo pacote e por subclasses. Membros padrão (sem especificador de acesso) são acessíveis somente dentro do mesmo pacote.

Ao agrupar classes relacionadas em pacotes, Java promove o encapsulamento de dados, tornando o código reutilizável e mais fácil de gerenciar. Basta importar a classe desejada de um pacote para usá-la em seu programa.

Criando pacotes personalizados

Etapa 1: Crie um diretório no qual criamos nossos pacotes e arquivos Java.

PROGRAMAÇÃO mkdir

chave de inserção do laptop

Etapa 2: Agora mude o diretório e crie outra pasta dentro da pasta principal

PROGRAMAÇÃO DE CD
mkdir JavaProgramação
cd JavaProgramação
matrizes mkdir

Etapa 3: Agora crie um arquivo de texto vazio e escreva o código Java abaixo e não se esqueça de salvá-lo com o mesmo nome da classe com extensão .java (TwoPointers.java)

Classe Dois Ponteiros.

package JavaProgramming.arrays; // Main class present inside the package  public class TwoPointers {  public static void main(String[] args) {  System.out.println('Inside the package');  } } 

Observação: Não se esqueça de adicionar o nome do pacote dentro do arquivo do programa.

Etapa 4: Agora execute o programa com o caminho da pasta definida

javac srcJavaProgrammingarraysTwoPointers.java

java srcJavaProgrammingarraysTwoPointers.java

Saída:

Estrutura de pastas:

Esta é a representação visual de um pacote customizado em Java na imagem abaixo. Primeiro criamos uma pasta chamada Progamming e dentro dela criamos um pacote Javaprogramming e depois criamos outro subpacote que se chama matrizes . Em seguida, criamos um arquivo de classe Java dentro dele, mostrado na imagem abaixo:

Trabalho de pacotes Java

Estrutura de diretório: Os nomes dos pacotes e as estruturas de diretório estão intimamente relacionados. Por exemplo, se o nome de um pacote for college.staff.cse, então três diretórios são college staff e cse, onde cse está dentro de staff e staff está dentro da faculdade.

Convenções de nomenclatura : os nomes dos pacotes são escritos na ordem inversa dos nomes de domínio, por exemplo. org.geeksforgeeks.practice. Em uma faculdade a convenção pode ser:

• faculdade.tech.cse
• faculdade.tech.ee
• faculdade.história.da.arte

Exemplo:

como retornar um array java

importar java.util.*;

Aqui, util é um subpacote criado dentro do pacote java.  

Acessando classes dentro de um pacote

Em Java podemos importar classes de um pacote usando um dos seguintes métodos:

1. Importe uma classe específica :

importar java.util.Vector;

Isso importa apenas a classe Vector do pacote java.util.

2. Importe todas as classes de um pacote :

importar java.util.*;

Isto importa todas as classes e interfaces do pacote java.util, mas não inclui subpacotes.

Exemplo: Importe a classe Vector

import java.util.Vector; public class Geeks {    public Geeks() {    // java.util.Vector is imported We are able to access it directly in our code.  Vector v = new Vector();    java.util.ArrayList l = new java.util.ArrayList();  l.add(3);  l.add(5);  l.add(7);    System.out.println(l);  }  public static void main(String[] args) {      new Geeks();  } } 

[3 5 7] 

Observação:

• Usando pacote de importação.*; importa todas as classes de um pacote, mas não as classes de seus subpacotes.
• Quando dois pacotes possuem classes com o mesmo nome (por exemplo, java.util.Date e my.package.Date) use o nome totalmente qualificado para evitar conflitos:

importar java.util.Date;

importar meu.pacote.Date;

Tipos de pacotes Java

• Pacotes integrados
• Pacotes definidos pelo usuário

1. Pacotes integrados

Esses pacotes consistem em um grande número de classes que fazem parte do Java API .Alguns dos pacotes integrados comumente usados ​​são:

• java.lang : Contém classes de suporte à linguagem (por exemplo, classes que definem operações matemáticas de tipos de dados primitivos). Este pacote é importado automaticamente.
• java.io: Contém classes para suporte a operações de entrada/saída.
• java.util : Contém classes utilitárias que implementam estruturas de dados como Linked List Dictionary e suporte; para operações de data/hora.
• java.applet: Contém classes para criação de miniaplicativos.
• java.aut: Contém classes para implementar os componentes para interfaces gráficas de usuário (como botões, menus, etc.). 6)
• java.net: Contém classes para dar suporte a operações de rede.

2. Pacotes definidos pelo usuário

Estes são os pacotes definidos pelo usuário.

1. Crie o pacote:

Primeiro criamos um diretório myPackage (o nome deve ser igual ao nome do pacote). Em seguida, crie MyClass dentro do diretório com a primeira instrução sendo os nomes dos pacotes.

Exemplo:

package myPackage; public class MyClass {  public void getNames(String s)  {   System.out.println(s);   } } 

2. Use o programa Class in:

Agora usaremos o MinhaClasse aula em nosso programa.

 import myPackage.MyClass; public class Geeks {  public static void main(String args[]) {     // Initializing the String variable with a value   String s = 'GeeksforGeeks';    // Creating an instance of class MyClass in the package.  MyClass o = new MyClass();    o.getNames(s);  } } 

Observação: MyClass.java deve ser salvo dentro do diretório myPackage, pois faz parte do pacote.  

Importação estática em Java

A importação estática em Java visa simplificar o acesso a membros estáticos e separa-o da discussão mais ampla de pacotes definidos pelo usuário.

Importação estática é um recurso introduzido na linguagem de programação Java (versões 5 e superiores) que permite que membros (campos e métodos) sejam definidos em uma classe como públicos estático para ser usado no código Java sem especificar a classe na qual o campo está definido.

camelo python

Exemplo:

import static java.lang.System.*; class Geeks {  public static void main(String args[]) {    // We don't need to use 'System.out' as imported using static.  out.println('GeeksforGeeks');  } } 

GeeksforGeeks 

Lidando com Conflitos de Nome

Quando dois pacotes contêm uma classe com o mesmo nome (por exemplo, java.util.Date e java.sql.Date), especifique o nome completo do pacote para evitar conflitos.

importar java.util.*;
importar java.sql.*;
//E então use a classe Date e obteremos um erro em tempo de compilação:
Data hoje; //ERRO-- java.util.Date ou java.sql.Date?

O compilador não será capaz de descobrir qual classe Date queremos. Este problema pode ser resolvido usando uma instrução de importação específica:

importar java.util.Date;
importar java.sql.*;

Se precisarmos de ambas as classes Date, precisaremos usar um nome completo de pacote sempre que declararmos um novo objeto dessa classe. Por exemplo:

java.util.Date deadLine = new java.util.Date();
java.sql.Date hoje = novo java.sql.Date();

bota de mola

Estrutura de diretório e CLASSPATH

Os nomes dos pacotes correspondem a uma estrutura de diretórios. Por exemplo, uma classe Circle no pacote com.zzz.project1.subproject2 é armazenada como:

$BASE_DIR/com/zzz/project1/subproject2/Circle.class

• Aqui $BASE_DIR representa o diretório base do pacote.
• O 'ponto' no nome do pacote corresponde a um subdiretório do sistema de arquivos.
• O diretório base ( $BASE_DIR ) pode estar localizado em qualquer lugar no sistema de arquivos.
• Portanto o compilador Java e o tempo de execução devem ser informados sobre a localização do $BASE_DIR para localizar as classes.
• Isso é realizado por uma variável de ambiente chamada CLASSPATH .
• CLASSPATH é semelhante a outra variável de ambiente PATH que é usada pelo shell de comando para procurar programas executáveis.

Configurando CLASSPATH

CLASSPATH pode ser definido de qualquer uma das seguintes maneiras:

• CLASSPATH pode ser definido permanentemente no ambiente, as etapas no Windows são

Vá para Painel de Controle -> Sistema -> Avançado -> Variáveis ​​de Ambiente.

• Selecione 'Variáveis ​​do Sistema' para aplicar o CLASSPATH para todos os usuários do sistema.
• Selecione 'Variáveis ​​de usuário' para aplicá-lo apenas ao usuário conectado no momento.
• Editar ou criar CLASSPATH: Se CLASSPATH já existir selecione-o e clique em 'Editar' ou se não existir clique em 'Novo'
• Insira os detalhes do CLASSPATH: No campo 'Nome da variável' insira: 'CLASSPATH' No campo 'Valor da variável' insira os diretórios e arquivos JAR separados por ponto e vírgula.
• No campo 'Valor da variável' insira os diretórios e arquivos JAR separados por ponto e vírgula. Exemplo:

.c:javaprojectclasses;d:tomcatlibservlet-api.jar

• O ponto (.) representa o diretório de trabalho atual.
• Para verificar a configuração atual do CLASSPATH, emita o seguinte comando:

> DEFINIR CLASSPATH

CLASSPATH pode ser definido temporariamente para aquela sessão de shell CMD específica emitindo o seguinte comando:

> SET CLASSPATH=.;c:javaprojectclasses;d:tomcatlibservlet-api.jar

Em vez de usar a variável de ambiente CLASSPATH você também pode usar a opção de linha de comando -classpath ou -cp dos comandos javac e java, por exemplo

> java –classpath c:javaprojectclasses com.abc.project1.subproject2.MyClass3

Ilustração de pacotes definidos pelo usuário:  Criando nosso primeiro pacote: Nome do arquivo – ClassOne.java

package package_name; public class ClassOne {  public void methodClassOne()  {  System.out.println('Hello there its ClassOne');  } } 

Criando nosso segundo pacote: Nome do arquivo – ClassTwo.java

package package_one; public class ClassTwo {  public void methodClassTwo()  {  System.out.println('Hello there i am ClassTwo');  } } 

Fazendo uso de ambos os pacotes criados: Nome do arquivo – Testing.java

import package_name.ClassOne; import package_one.ClassTwo; public class Testing {  public static void main(String[] args)  {  ClassTwo a = new ClassTwo();  ClassOne b = new ClassOne();  a.methodClassTwo();  b.methodClassOne();  } } 

Agora, dando uma olhada na estrutura de diretórios dos pacotes e do arquivo de classe de teste:

Modificadores de acesso no contexto de pacotes

• Público: Membros com opublicmodificador são acessíveis de qualquer lugar, independentemente de a classe de acesso estar no mesmo pacote ou não .
• Protegido: Membros com o modificador protegido são acessíveis dentro do mesmo pacote Nas subclasses
• Padrão: Membros sem modificador são acessíveis apenas dentro do mesmo pacote
• Privado: Membros com oprivatemodificador são acessíveis apenas dentro da mesma classe. Eles não podem ser acessados ​​por classes nas mesmas subclasses de pacotes ou em pacotes diferentes.