Pacchetto (package) Java

为了更好地组织类，Java 提供了包机制，用于区分类名的命名空间。

包的作用

• 1、将功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。

• 2、与文件夹类似，包也采用了树形目录的存储方式。同一个包中的类名是不同的，不同包中的类名可以相同，当同时调用两个不同包中相同类名的类时，应该加上包名以区分。因此，包可以避免名称冲突。

• 3. Il pacchetto limita anche i permessi di accesso, solo le classi che hanno il permesso di accesso al pacchetto possono accedere alle classi nel pacchetto.

Java utilizza il meccanismo del pacchetto (package) per prevenire conflitti di nomi, controllare l'accesso, fornire ricerca e localizzazione delle classi (classi), interfacce, enum (enumerazioni) e annotazioni (annotazioni).

La sintassi della dichiarazione del pacchetto è:

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

Ad esempio, il contenuto di un file Something.java

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

Pertanto, il percorso dovrebbe essere net/java/util/Something.java In questo modo si salva. Il ruolo del package (pacchetto) è quello di classificare e salvare diversi programmi java, rendendoli più facili da chiamare da altri programmi java.

Un pacchetto (package) può essere definito come un gruppo di tipi (classi, interfacce, enum e commenti) che forniscono funzionalità di protezione dell'accesso e gestione dello spazio dei nomi.

Ecco alcuni pacchetti in Java:

• java.lang-Pacchetti di base

• java.io-Funzioni che includono funzionalità di input/output

I sviluppatori possono themselves raccogliere un gruppo di classi e interfacce e definire il loro pacchetto. E nel processo di sviluppo, è utile farlo, quando si completa l'implementazione delle classi, raggruppare le classi correlate può rendere più facile per altri programmatori determinare quali classi, interfacce, enum e commenti sono correlati.

Poiché il pacchetto crea un nuovo spazio dei nomi (namespace), non c'è conflitto di nomi con altri pacchetti. Utilizzando questo meccanismo del pacchetto, è più facile implementare il controllo dell'accesso e rendere più semplice la localizzazione delle classi correlate.

Creare un pacchetto

Quando si crea un pacchetto, devi dare un nome appropriato a questo pacchetto. Dopo di che, se un altro file di origine contiene classi, interfacce, enum o tipi di commenti forniti da questo pacchetto, devono essere messi nella testa di questo file di origine.

La dichiarazione del pacchetto dovrebbe essere nella prima riga del file di origine, ogni file può avere solo una dichiarazione di pacchetto e ogni tipo nel file si applica a essa.

Se un file di origine non contiene una dichiarazione di pacchetto, le classi, le funzioni, gli enum, i commenti e altri elementi vengono messi in un pacchetto senza nome (unnamed package).

Esempio

Vediamo un esempio, questo esempio crea un pacchetto chiamato animals. Di solito si utilizzano lettere minuscole per il nome per evitare conflitti con i nomi delle classi e delle interfacce.

Aggiungi un'interfaccia (interface) al pacchetto animals:

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

Aggiungi ora l'implementazione dell'interfaccia nello stesso pacchetto:

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

Poi, compila questi due file e mettili in una sottodirectory chiamata animals. Esegui i seguenti comandi per farlo:

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

Parola chiave import

Per utilizzare i membri di un pacchetto specifico, dobbiamo importare chiaramente questo pacchetto nel programma Java. L'istruzione 'import' può completare questa funzione.

Nella声明 del file sorgente java, l'istruzione import dovrebbe essere collocata dopo la dichiarazione del package e prima di tutte le definizioni delle classi, può essere omessa o possono esserci più di una, la sua forma grammaticale è la seguente:

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

Se un'intera classe in un pacchetto desidera utilizzare un'altra classe dello stesso pacchetto, il nome del pacchetto può essere omesso.

Esempio

Il pacchetto payroll già contiene la classe Employee, quindi aggiungiamo una classe Boss al pacchetto payroll. Quando la classe Boss fa riferimento alla classe Employee, non è necessario utilizzare il prefisso payroll, ecco un esempio della classe Boss.

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

Cosa succede se la classe Boss non si trova nel pacchetto payroll? La classe Boss deve utilizzare uno dei seguenti metodi per fare riferimento a classi di altri pacchetti.

Usa il nome completo della classe, ad esempio:

payroll.Employee

con import La parola chiave introduce, utilizza l'asterisco "*"

import　payroll.*;

usare import La parola chiave introduce la classe Employee:

import　payroll.Employee;

Attenzione:

I file delle classi possono contenere una qualsiasi quantità di dichiarazioni import. Le dichiarazioni import devono essere dopo la dichiarazione del pacchetto e prima della dichiarazione della classe.

Struttura della directory del pacchetto

Collocare la classe nel pacchetto ha due principali risultati principali:

• Il nome del pacchetto diventa parte del nome della classe, come abbiamo discusso in precedenza.

• Il nome del pacchetto deve corrispondere alla struttura della directory in cui si trovano i bytecode corrispondenti.

Ecco un modo semplice per gestire i file java personalizzati:

Metti il codice della classe, dell'interfaccia e altri tipi in un file di testo, il nome del file è il nome di questo tipo, più l'estensione .java. Ad esempio:

//　Nome del file　:　　Car.java
　
package　vehicle;
　
public　class　Car　{
　　　//　Implementazione della classe　　
}

Quindi, metti il file sorgente in una directory, che deve corrispondere al nome del pacchetto in cui si trova la classe.

....\vehicle\Car.java

Ora, il nome corretto della classe e del percorso saranno come segue:

• Nome della classe -> 　vehicle.Car

• Nome del percorso -> 　 vehicle\Car.java (sul sistema Windows)

Di solito, una società utilizza la forma inversa del suo dominio internet come nome del pacchetto. Ad esempio: il dominio internet è oldtoolbag.com, tutti i nomi dei pacchetti iniziano con com.w3codebox. Ogni parte del nome del pacchetto corrisponde a una sottodirectory.

Ad esempio: c'è un com.w3codebox.test del pacchetto, che contiene un file sorgente chiamato w3codebox.java, allora, in corrispondenza, ci dovrebbe essere una serie di sottodirectory come segue:

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

Durante la compilazione, il compilatore crea un file di output diverso per ogni classe, interfaccia e altro tipo definito nel pacchetto, il nome del file di output è il nome di questo tipo, più l'estensione .class. Ad esempio:

// Nome del file: w3codebox.java
　
package com.w3codebox.test;
public class w3codebox {
　　　　　　
}
class Google {
　　　　　　
}

Ora, usiamo l'opzione -d per compilare questo file, come segue:

$javac -d . w3codebox.java

I file compilati saranno posizionati come segue

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

Puoi importare tutto come segue \com\w3codebox\test\ Definiti nella classe, l'interfaccia, ecc.

import com.w3codebox.test.*;

I file .class compilati devono essere posizionati come i file .java di origine, le directory in cui si trovano devono corrispondere al nome del package. Tuttavia, non è richiesto che il percorso del file .class sia lo stesso del percorso del file .java. Puoi organizzare separatamente le directory del codice sorgente e delle classi.

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

In questo modo, puoi condividere la tua directory delle classi con altri programmatori senza rivelare il tuo codice sorgente. Gestire il codice sorgente e i file delle classi in questo modo permette al compilatore e al motore virtuale java (JVM) di trovare tutti i tipi utilizzati nel tuo programma.

Il percorso assoluto della directory delle classi è chiamato class path. È impostato nel variabile di sistema CLASSPATH Compilatore e il motore virtuale java costruiscono il percorso del file .class aggiungendo il nome del package al class path.

<path- two>\classes è il class path, il nome del package è com.w3codebox.test e il compilatore e il JVM cercano i file .class in <path-two>\classes\com\w3codebox\test.

Un class path potrebbe includere più percorsi, i percorsi multipli devono essere separati da un separatore. Di default, il compilatore e il JVM cercano la directory corrente. I file JAR contengono classi relative alla piattaforma Java, quindi le loro directory sono collocate di default nel class path.

Imposta la variabile di sistema CLASSPATH

Usa il comando seguente per visualizzare la variabile CLASSPATH corrente:

• Piattaforma Windows (sotto riga di comando DOS): C:\> set CLASSPATH

• Piattaforma UNIX (sotto Bourne shell): # echo $CLASSPATH

Elimina il contenuto della variabile CLASSPATH corrente:

• Piattaforma Windows (sotto riga di comando DOS): C:\> set CLASSPATH=

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

Impostazione variabile CLASSPATH:

• Piattaforma Windows (sotto riga di comando DOS): C:\> set CLASSPATH=C:\users\jack\java\classes

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