pacchetto Java (pacchetto)

Al fine di meglio organizzare la classe, Java fornisce un meccanismo pacchetto per la differenza tra il nome classe del namespace.

Il ruolo del pacchetto

• Una funzione simile organizzazione o correlata della classe o interfaccia nella stessa confezione, per trovare e facile da usare di classe.
• 2 come nella stessa cartella, il pacchetto utilizzato anche l'albero delle directory di archiviazione. Le classi nello stesso nome del pacchetto è diverso, un diverso nome del pacchetto della classe è la stessa, mentre chiamando contemporaneamente due diversi tipi di pacchetti nello stesso nome della classe, il nome del pacchetto deve essere distinzione aggiunto. Così, il nome del pacchetto per evitare conflitti.
• Pacchetto 3 definisce anche i diritti di accesso, le classi hanno accesso al pacchetto di accedere a un pacchetto di classi.

Java utilizza il pacchetto (package) Questo meccanismo è stato progettato per prevenire i conflitti di denominazione, il controllo di accesso, fornendo di ricerca e individuare la classe (classe), le interfacce, enumerazioni (enumerazioni) e commenti (annotazione) e simili.

sintassi dell'istruzione pacchetto è:

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

Ad esempio, un file la sua Something.java contenuti

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

Allora dovrebbe essere il percorso net / java / util / Something.java così salvato. Pacchetto (pacchetto) ruolo è quello di classificare diverso programma Java memorizzato più facilmente essere chiamato da un altro programma Java.

Un pacchetto (package) può essere definita come un insieme di tipi (classi, interfacce, enumerazioni, e annotazione) interconnessi per fornire protezione di accesso e funzioni di gestione namespace per questi tipi.

Ecco alcuni dei Java nel pacchetto:

• java.lang- classe base confezionato
• Funzione Java.io- contiene funzioni di input e output

Gli sviluppatori possono mettere il proprio set di classi e interfacce, confezionati, e definire il proprio pacchetto. E nello sviluppo reale è quello di essere incoraggiati a farlo, quando si completa la classe di implementazione, il raggruppamento classi correlate, in modo che gli altri programmatori possono più facilmente determinare quali classi, interfacce, enumerazioni, e commenti sono correlati .

Dal momento che il pacchetto crea un nuovo spazio dei nomi (namespace), quindi senza conflitti di denominazione con qualsiasi altro nome del pacchetto. Utilizzare questo meccanismo pacchetto, facile da implementare il controllo degli accessi, e lasciare che individuare la relativa classe più facile.

Crea pacchetto

Creare un pacchetto, è necessario prendere un nome appropriato per questo pacchetto. Quindi, se un file di origine che contiene le altre classi offerto questo tipo di pacchetto, interfaccia, annotazione o enum, il pacchetto di tale dichiarazione deve essere posizionato all'inizio di questo file sorgente.

Pacchetto deve essere dichiarato nella prima riga del file di origine per ogni file sorgente può avere una sola istruzione pacchetto, il file per ogni tipo vengono applicate ad esso.

Se non si utilizza una dichiarazione pacchetto nel file di origine, quindi una delle classi, funzioni, l'enumerazione, commenti, ecc saranno collocati in un pacchetto senza nome (pacchetto senza nome) in.

esempio

Diamo un'occhiata a un esempio che crea un pacchetto chiamato gli animali. Generalmente usare lettere minuscole per evitare classi di denominazione, le interfacce, e il nome del conflitto.

Partecipa a un animale di interfaccia pacchetto (interfaccia):

/* 文件名: Animal.java */
package animals;

interface Animal {
   public void eat();
   public void travel();
}

Successivamente, aggiungere nello stesso package che implementa l'interfaccia:

package animals;

/* 文件名 : 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, compilare questi due file e metterli in una sottodirectory denominata animali. Utilizzare il seguente comando per eseguire:

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

le parole chiave di importazione

Per poter utilizzare un membro di un pacchetto, occorre importare esplicitamente il pacchetto nel programma Java. Utilizzando l'istruzione "import" per svolgere questa funzione.

In Java istruzioni import di file sorgente deve essere situata dopo l'istruzione package, tutte le classi definite in precedenza, non è possibile, si può anche avere più, la sua sintassi è:

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

Se un pacchetto, una classe che si desidera utilizzare questo pacchetto in un'altra classe, quindi il nome del pacchetto può essere omesso.

esempio

Il seguente pacchetto libro paga contiene già la classe Employee, quindi aggiungere una classe al pacchetto libro paga Boss. Quando la classe di riferimento della classe Boss dei dipendenti non è possibile utilizzare le istanze di prefisso libro paga classe Boss segue.

package payroll;

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

E se la classe non è pacchetto paghe boss? classe sporgenza deve utilizzare uno dei seguenti metodi per fare riferimento altre classi del pacchetto

Utilizzare il nome completo della descrizione della classe, come ad esempio:

payroll.Employee

Con l'introduzione di parole chiave di importazione, utilizzare il carattere jolly "*"

import payroll.*;

Utilizzando importazione parola chiave introduce classe Employee

import payroll.Employee;

Nota:

file di classe può contenere qualsiasi numero di dichiarazione di importazione. dichiarazione di importazione deve essere dopo l'istruzione package, prima della dichiarazione di classe.

pacchetto struttura di directory

Class sulla confezione hanno due risultati principali:

• Nome del pacchetto diventa parte del nome della classe, come abbiamo discusso in precedenza.
• Nome del pacchetto deve corrispondere al codice di byte corrispondente nella stessa partita struttura di directory.

Ecco un modo semplice per gestire i file in java:

Le classi, interfacce, e altri tipi di codice sorgente in un testo, il nome di questo file è il nome del tipo, e .java estensione. Ad esempio:

// 文件名 :  Car.java

package vehicle;

public class Car {
   // 类实现  
}

Successivamente, i file di origine in una directory, il nome della directory alla classe corrispondente del proprio pacchetto.

....\vehicle\Car.java

Ora, il nome della classe corretta e il percorso sarà simile alla seguente:

• Nome classe -> vehicle.Car

• Pathname -> veicolo \ Car.java (in Windows)

In genere, una società utilizza la sua forma invertita di nomi di dominio Internet, come il nome del pacchetto, ad esempio: il dominio Internet è apple.com, tutti i nomi dei pacchetti sono in principio com.apple. Ogni nome del pacchetto corrispondente ad una parte di una sottodirectory.

Per esempio: L'azienda ha una com.apple.computers il pacchetto, che contiene un file sorgente Dell.java noto, il corrispondente dovrebbe essere come la seguente serie di sottodirectory:

....\com\apple\computers\Dell.java

fase di compilazione, il compilatore crea un file di output diverso, il nome del file di output è il nome di questo tipo è definita nel tipo di pacchetto di ogni classe, interfaccia, e ha aggiunto come suffisso un'estensione .class. Ad esempio:

// 文件名: Dell.java

package com.apple.computers;
public class Dell{
      
}
class Ups{
      
}

Ora, si usa l'opzione -d per compilare il file, come segue:

$javac -d . Dell.java

Ciò posto come questo per compilare il file:

.\com\apple\computers\Dell.class.\com\apple\computers\Ups.class

È possibile come questo per importare tutti \ com \ mela \ computer \ classe definita nell'interfaccia:

import com.apple.computers.*;

.class file compilati assistenza e avere java file di origine, sono collocati nella directory deve corrispondere al nome del pacchetto. Tuttavia, il percorso non richiede file .class con il percorso corrispondente .java stesso. È possibile organizzare le directory di origine e di classe separata.

<path-one>\sources\com\apple\computers\Dell.java
<path-two>\classes\com\apple\computers\Dell.class

In questo modo, è possibile condividere la directory classi per altri programmatori, piuttosto che rivelare la loro fonte. In questo modo gestire sorgente e file di classe in grado di lasciare che il compilatore e Java Virtual Machine (JVM) si possono trovare tutti i tipi utilizzati nel programma.

Absolute percorsi di directory classe chiamata percorso di classe. Situato nel sistema CLASSPATH variabile. Compilatore e la Java Virtual Machine per il nome del pacchetto per il percorso di classe dopo la costruzione percorso .class file.

<Path- due> \ Classes è il percorso della classe, il nome del pacchetto è com.apple.computers, e il compilatore e JVM sarà in <path-due> \ Classes \ com \ mela \ compters trovare i file .class.

Un percorso di classe potrebbe contenere diversi percorsi. Multi-percorso dovrebbe essere separato da un delimitatore. Per impostazione predefinita, il compilatore e JVM trovano nella directory corrente. file JAR contenente la piattaforma Java, in base alla relativa classe, in modo che di default su una directory nel percorso di classe.

Impostazione variabile di sistema CLASSPATH

Utilizzare il seguente comando per visualizzare la variabile CLASSPATH corrente:

• piattaforme Windows (riga di comando DOS) -> C: \> set CLASSPATH
• piattaforme UNIX (Bourne shell sotto) ->% echo $ CLASSPATH

• piattaforme Windows (riga di comando DOS) -> C: \> set CLASSPATH =
• piattaforme UNIX (Bourne shell sotto) ->% CLASSPATH impostata; export CLASSPATH

Impostazione variabile CLASSPATH:

• piattaforme Windows (riga di comando DOS) -> set CLASSPATH = C: \ Users \ jack \ java \ classes
• piattaforme UNIX (Bourne shell sotto) ->% CLASSPATH = classi / home / jack / java /; export CLASSPATH