Els paquets en Java són un mecanisme que encapsula un grup de subpaquets i interfícies de classes. Els paquets s'utilitzen per a:

• Eviteu els conflictes de noms permetent que les classes amb el mateix nom existeixin en diferents paquets, com ara college.staff.cse.Employee i college.staff.ee.Employee.
• Faciliteu l'organització de la localització i l'ús de les interfícies de classes i altres components.
• Proporcioneu accés controlat als membres protegits als quals es pot accedir dins del mateix paquet i per subclasses. Els membres per defecte (sense especificador d'accés) només són accessibles dins del mateix paquet.

En agrupar classes relacionades en paquets, Java promou l'encapsulació de dades fent que el codi sigui reutilitzable i més fàcil de gestionar. Simplement importeu la classe desitjada d'un paquet per utilitzar-la al vostre programa.

Creació de paquets personalitzats

Pas 1: Creeu un directori en el qual creem els nostres paquets i fitxers Java.

PROGRAMACIÓ mkdir

llegiu el fitxer csv en java

Pas 2: Ara canvieu el directori i creeu una altra carpeta dins de la carpeta principal

PROGRAMACIÓ de cd
mkdir Programació Java
cd JavaProgramming
matrius mkdir

Pas 3: Ara creeu un fitxer de text buit i escriviu el codi Java següent i no us oblideu de desar-lo amb el mateix nom que la classe amb extensió .java (TwoPointers.java)

Classe TwoPointers.

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

Nota: No oblideu afegir el nom del paquet dins del fitxer del programa.

Pas 4: Ara executeu el programa amb la ruta de la carpeta definida

javac srcJavaProgrammingarraysTwoPointers.java

java srcJavaProgrammingarraysTwoPointers.java

Sortida:

Estructura de carpetes:

Aquesta és la representació visual d'un paquet personalitzat en Java a la imatge següent. Primer creem una carpeta anomenada Progamming i dins d'ella creem un paquet Javaprogramming i després creem un altre subpaquet que es diu matrius . A continuació, creem un fitxer de classe Java dins d'ell que es mostra a la imatge següent:

Funcionament de paquets Java

Estructura del directori: Els noms dels paquets i les estructures de directoris estan estretament relacionats. Per exemple, si el nom del paquet és college.staff.cse, llavors tres directoris són personal universitari i cse on cse és dins del personal i el personal és dins de la universitat.

Convencions de denominació : els noms dels paquets s'escriuen en ordre invers als noms de domini, p. org.geeksforgeeks.practice. En una universitat, la convenció podria ser:

• college.tech.cse
• college.tech.ee
• universitat.història.de.art

Exemple:

tipus de bucle for

importar java.util.*;

Aquí util és un subpaquet creat dins del paquet java.  

Accés a classes dins d'un paquet

A Java podem importar classes d'un paquet utilitzant qualsevol dels mètodes següents:

1. Importa una classe específica :

importar java.util.Vector;

Això només importa la classe Vector del paquet java.util.

2. Importa totes les classes d'un paquet :

importar java.util.*;

Això importa totes les classes i interfícies del paquet java.util però no inclou subpaquets.

Exemple: Importa la 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] 

Nota:

• Utilitzant el paquet d'importació.*; importa totes les classes d'un paquet però no les classes dels seus subpaquets.
• Quan dos paquets tenen classes amb el mateix nom (per exemple, java.util.Date i my.package.Date), utilitzeu el nom complet per evitar conflictes:

importar java.util.Date;

import my.package.Date;

Tipus de paquets Java

• Paquets integrats
• Paquets definits per l'usuari

1. Paquets integrats

Aquests paquets consisteixen en un gran nombre de classes que formen part de Java API .Alguns dels paquets integrats que s'utilitzen habitualment són:

• java.lang : Conté classes de suport d'idiomes (p. ex. classes que defineixen tipus de dades primitives operacions matemàtiques). Aquest paquet s'importa automàticament.
• java.io: Conté classes per donar suport a les operacions d'entrada/sortida.
• java.util : Conté classes d'utilitat que implementen estructures de dades com el diccionari de llista enllaçada i el suport; per a operacions de data/hora.
• java.applet: Conté classes per crear applets.
• java.aut: Conté classes per implementar els components per a interfícies gràfiques d'usuari (com el botó ;menús, etc.). 6)
• java.net: Conté classes per donar suport a les operacions de xarxa.

2. Paquets definits per l'usuari

Aquests són els paquets que defineix l'usuari.

1. Creeu el paquet:

Primer creem un directori myPackage (el nom hauria de ser el mateix que el nom del paquet). A continuació, creeu la MyClass dins del directori amb la primera instrucció els noms dels paquets.

Exemple:

quantes tecles tenen els teclats

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

2. Utilitzeu la classe al programa:

Ara farem servir el La meva classe classe al nostre 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);  } } 

Nota: MyClass.java s'ha de desar dins del directori myPackage ja que forma part del paquet.  

Importació estàtica a Java

La importació estàtica a Java tracta de simplificar l'accés als membres estàtics i el separa de la discussió més àmplia dels paquets definits per l'usuari.

Importació estàtica és una característica introduïda en el llenguatge de programació Java (versions 5 i superiors) que permet que els membres (camps i mètodes) es defineixin en una classe com a públics. estàtica s'utilitzarà en codi Java sense especificar la classe en què es defineix el camp.

Exemple:

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 

Gestió de conflictes de noms

Quan dos paquets contenen una classe amb el mateix nom (per exemple, java.util.Date i java.sql.Date), especifiqueu el nom complet del paquet per evitar conflictes.

importar java.util.*;
importar java.sql.*;
//A continuació, utilitzeu la classe Date i obtindrem un error en temps de compilació:
Data avui; //ERROR: java.util.Date o java.sql.Date?

El compilador no podrà esbrinar quina classe de Date volem. Aquest problema es pot resoldre mitjançant una declaració d'importació específica:

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

Si necessitem ambdues classes de date, hem d'utilitzar un nom de paquet complet cada vegada que declarem un objecte nou d'aquesta classe. Per exemple:

java.util.Date deadLine = nou java.util.Date();
java.sql.Date today = nou java.sql.Date();

img css align

Estructura de directoris i CLASSPATH

Els noms dels paquets corresponen a una estructura de directoris. Per exemple, una classe Circle al paquet com.zzz.project1.subproject2 s'emmagatzema com:

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

• Aquí $BASE_DIR representa el directori base del paquet.
• El "punt" del nom del paquet correspon a un subdirectori del sistema de fitxers.
• El directori base ( $BASE_DIR ) es pot localitzar en qualsevol lloc del sistema de fitxers.
• Per tant, el compilador Java i el temps d'execució s'han d'informar sobre la ubicació del $BASE_DIR per tal de localitzar les classes.
• S'aconsegueix mitjançant una variable d'entorn anomenada CLASSPATH .
• CLASSPATH és similar a una altra variable d'entorn PATH que utilitza l'intèrpret d'ordres per cercar els programes executables.

Configuració de CLASSPATH

CLASSPATH es pot configurar de qualsevol de les maneres següents:

• CLASSPATH es pot configurar de manera permanent a l'entorn dels passos a Windows

Aneu a Tauler de control -> Sistema -> Avançat -> Variables d'entorn.

• Seleccioneu "Variables del sistema" per aplicar el CLASSPATH a tots els usuaris del sistema.
• Seleccioneu "Variables d'usuari" per aplicar-lo només a l'usuari que ha iniciat sessió actualment.
• Edita o crea CLASSPATH: si ja existeix CLASSPATH, seleccioneu-lo i feu clic a "Edita" o, si no existeix, feu clic a "Nou".
• Introduïu els detalls de CLASSPATH: al camp "Nom de la variable" introduïu: "CLASSPATH" Al camp "Valor de la variable" introduïu els directoris i els fitxers JAR separats per punt i coma.
• Al camp "Valor variable" introduïu els directoris i els fitxers JAR separats per punt i coma. Exemple:

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

• El punt (.) representa el directori de treball actual.
• Per comprovar la configuració actual del CLASSPATH, emet l'ordre següent:

> DEFINIR CLASSPATH

CLASSPATH es pot configurar temporalment per a aquella sessió d'intèrpret d'ordres CMD en particular emetent l'ordre següent:

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

En lloc d'utilitzar la variable d'entorn CLASSPATH, també podeu utilitzar l'opció de línia d'ordres -classpath o -cp de les ordres javac i java, per exemple

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

Il·lustració de paquets definits per l'usuari:  Creant el nostre primer paquet: Nom del fitxer: ClassOne.java

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

Creant el nostre segon paquet: Nom del fitxer: ClassTwo.java

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

Fent ús dels dos paquets creats: Nom del fitxer – 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();  } } 

Ara feu una ullada a l'estructura de directoris tant dels paquets com del fitxer de classe de prova:

Modificadors d'accés en el context de paquets

• Públic: Membres amb elpublicels modificadors són accessibles des de qualsevol lloc, independentment de si la classe d'accés es troba al mateix paquet o no .
• Protegit: Els membres amb el modificador protegit són accessibles dins del mateix paquet a les subclasses
• Per defecte: Els membres sense modificador només són accessibles dins del mateix paquet
• Privat: Membres amb elprivatemodificador només són accessibles dins de la mateixa classe. No poden accedir-hi classes de les mateixes subclasses de paquets o paquets diferents.