Java Paket (package)

Um Klassen besser zu organisieren, bietet Java das Paketmechanismus an, um Namensräume von Klassennamen zu unterscheiden.

Die Funktion des Pakets

• 1, organisieren Sie Klassen oder Interfaces mit ähnlichen oder verwandten Funktionen in einem Paket, um die Suche und Verwendung der Klassen zu erleichtern.

• 2, wie Ordner, verwendet das Paket auch eine baumstrukturierte Speicherart. Die Namen der Klassen in einem Paket sind unterschiedlich, die Namen der Klassen in verschiedenen Paketen können gleich sein. Wenn gleichzeitig auf Klassen mit gleichem Namen aus zwei verschiedenen Paketen zugegriffen wird, sollte der Pakznamen hinzugefügt werden, um sie zu unterscheiden. Daher können Pakete Namenskonflikte vermeiden.

• 3, das Paket begrenzt auch den Zugriffsbereich, nur Klassen mit Paketzugriffsrechten können auf Klassen in einem bestimmten Paket zugreifen.

Java verwendet das Mechanismus des Pakets (package), um Namenskonflikte zu vermeiden, Zugriffssteuerung zu bieten und die Suche und Lokalisierung von Klassen (class), Interfaces, Enumerations (enumerations) und Kommentaren (annotations) zu ermöglichen.

Die Syntax des Paketstatements lautet:

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

Zum Beispiel, der Inhalt eines Something.java-Datei

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

Dann sollte sein Pfad sein net/java/util/Something.java So wird gespeichert. Die Funktion des Pakets (Paket) ist es, verschiedene java-Programme zu klassifizieren und zu speichern, um sie anderen java-Programmen einfacher zugänglich zu machen.

Ein Paket (package) kann definiert werden als eine Gruppe von miteinander verbundenen Typen (Klassen, Interfaces, Enumerations und Kommentare), die diese Typen Zugangsschutz und Namensraumverwaltung bieten.

Hier sind einige Pakete in Java:

• java.lang-Grundlegende Klassen verpacken

• java.io-Funktionen mit Ein- und Ausgabefunktionen

Entwickler können eine Gruppe von Klassen und Interfaces verpacken und ihr eigenes Paket definieren. Und dies wird in der Praxis empfohlen, wenn die Implementierung der Klassen abgeschlossen ist, können verwandte Klassen gruppiert werden, um anderen Programmierern zu erleichtern, zu bestimmen, welche Klassen, Interfaces, Enumerations und Kommentare usw. relevant sind.

Da das Paket einen neuen Namensraum (namespace) erstellt, gibt es keine Namenskonflikte mit anderen Paketen. Mit diesem Mechanismus des Pakets ist es einfacher, Zugriffssteuerung zu realisieren und die Lokalisierung relevanter Klassen zu vereinfachen.

Paket erstellen

Bei der Erstellung eines Pakets müssen Sie einem Paket einen geeigneten Namen geben. Nachdem eine andere Quelldatei die Klassen, Interfaces, Enumerations oder Kommentartypen bereitstellt, die dieses Paket bereitstellt, muss die Deklaration dieses Pakets am Anfang dieser Quelldatei stehen.

Die Paketdeklaration sollte in der ersten Zeile der Quelldatei stehen, jede Quelldatei kann nur eine Paketdeklaration haben, und jeder Typ in dieser Datei wird darauf angewendet.

Wenn in einer Quelldatei keine Paketdeklaration verwendet wird, werden die darin enthaltenen Klassen, Funktionen, Enumerations, Kommentare usw. in einem namenlosen Paket (unnamed package) platziert.

实例

Lassen Sie uns einen Beispielfall betrachten, bei dem ein Paket namens "animals" erstellt wird. Es wird empfohlen, Kleinbuchstaben zu verwenden, um Konflikte mit Klassennamen und Schnittstellen zu vermeiden.

Fügen Sie in das Paket "animals" eine Schnittstelle (interface) hinzu:

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

Fügen Sie nun die Implementierung dieses Interfaces in denselben Paket hinzu:

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

Dann kompilieren Sie diese beiden Dateien und legen Sie sie in einem Verzeichnis namens "animals" ab. Um dies auszuführen, verwenden Sie den folgenden Befehl:

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

Schlüsselwort "import"

Um die Mitglieder eines bestimmten Pakets verwenden zu können, müssen wir dieses Paket in unserem Java-Programm explizit importieren. Dies kann durch das "import"-Statement erfolgen.

In Java-Quelldateien sollten die import-Anweisungen nach dem package-Anweisung und vor allen Klassendefinitionen stehen, sind optional und können mehrfach vorkommen. Die Syntax ist wie folgt:

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

Wenn eine Klasse in einem Paket eine andere Klasse desselben Pakets verwendet, kann der Paketname weggelassen werden.

实例

下面的 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 声明必须在包声明之后，类声明之前。

package 的目录结构

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

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

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

下面是管理你自己 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 的包，这个包包含一个叫做 w3codebox.java Quelldatei, dann sollten entsprechend eine Reihe von Unterverzeichnissen wie unten sein:

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

Beim Kompilieren erstellt der Compiler für jeden in der Paket definierten Typ (Klasse, Schnittstelle usw.) eine separate Ausgabedatei, und der Name der Ausgabedatei ist der Name des Typs, gefolgt von .class als Dateierweiterung. Beispiel:

//　Dateiname:　w3codebox.java
　
package　com.w3codebox.test;
public　class　w3codebox　{
　　　　　　
}
class　Google　{
　　　　　　
}

Nun verwenden wir-d-Option, um diese Datei zu kompilieren, wie folgt:

$javac　-d　.　w3codebox.java

So werden die kompilierten Dateien wie unten gezeigt platziert:

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

Sie können alle, wie unten gezeigt, importieren \com\w3codebox\test\ In der definierten Klasse, Schnittstelle usw.:

import　com.w3codebox.test.*;

Die nach dem Kompilieren generierten .class-Dateien sollten wie die .java-Quelldateien sein, und ihre Verzeichnisse sollten auf den Namen des Pakets zutreffen. Es wird jedoch nicht verlangt, dass der Pfad der .class-Datei dem Pfad der entsprechenden .java-Datei entspricht. Sie können die Verzeichnisse für Quellcode und Klassen getrennt anordnen.

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

Auf diese Weise können Sie Ihr Klassendirektorium anderen Programmierern zur Verfügung stellen, ohne Ihre Quelldateien preiszugeben. Mit diesem Verfahren können Compiler und Java-Virtual-Maschine (JVM) alle in Ihrem Programm verwendeten Typen finden.

Der absolute Pfad zum Klassendirektorium heißt class path. Einstellen in Systemvariablen CLASSPATH Innerhalb. Compiler und Java-Virtual-Maschine konstruieren die .class-Dateipfade, indem sie den Paketnamen zur Classpath hinzufügen.

<path- two>\classes ist die Classpath, der Paketname ist com.w3codebox.test, und Compiler und JVM suchen im 　<path-two>\classes\com\w3Suchen Sie im Verzeichnis codebox\test nach .class-Dateien.

Eine Classpath kann mehrere Pfade enthalten, und die Pfade sollten durch Trennzeichen getrennt werden. Standardmäßig suchen Compiler und JVM nach dem aktuellen Verzeichnis. JAR-Dateien enthalten Java-Plattform-bezogene Klassen, daher werden ihre Verzeichnisse standardmäßig in die Classpath eingefügt.

Setzen Sie die CLASSPATH Systemvariable

Verwenden Sie den folgenden Befehl, um die aktuelle CLASSPATH Variable anzuzeigen:

• Windows Plattform (unter DOS Befehlszeile): C:\> set CLASSPATH

• UNIX Plattform (unter Bourne shell): # echo $CLASSPATH

Löschen Sie den Inhalt der aktuellen CLASSPATH Variable:

• Windows Plattform (unter DOS Befehlszeile): C:\> set CLASSPATH=

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

Setzen Sie die CLASSPATH Variable:

• Windows Plattform (unter DOS Befehlszeile): C:\> set CLASSPATH=C:\users\jack\java\classes

• UNIX Plattform (unter Bourne shell): # CLASSPATH=/home/jack/java/Klassen; export CLASSPATH