Java Packages: Namespaces, Zugriffskontrolle & Code-Organisation verwalten

Was sind Packages?

Packages werden in Java verwendet, um Namenskonflikte zu vermeiden, den Zugriff zu kontrollieren und das Suchen/Lokalisieren sowie die Verwendung von Klassen, Interfaces, Enumerationen und Annotationen zu erleichtern.

Ein Package kann als Gruppierung verwandter Typen (Klassen, Interfaces, Enumerationen und Annotationen) definiert werden, die Zugriffsschutz und Namespace-Verwaltung bieten.

Einige der vorhandenen Pakete in Java sind:

• java.lang – bündelt die fundamentalen Klassen
• java.io – Klassen für Eingabe- und Ausgabefunktionen sind in diesem Paket gebündelt

Programmierer können ihre eigenen Pakete definieren, um Gruppen von Klassen/Interfaces usw. zu bündeln. Es ist eine gute Praxis, verwandte Klassen, die Sie implementieren, zu gruppieren, damit ein Programmierer leicht feststellen kann, dass die Klassen, Interfaces, Enumerationen und Annotationen verwandt sind.

Da das Package einen neuen Namespace erstellt, gibt es keine Namenskonflikte mit Namen in anderen Paketen. Durch die Verwendung von Paketen ist es einfacher, Zugriffskontrolle bereitzustellen, und es ist auch einfacher, verwandte Klassen zu lokalisieren.

Ein Package erstellen

Beim Erstellen eines Packages sollten Sie einen Namen für das Package wählen und eine package-Anweisung zusammen mit diesem Namen an den Anfang jeder Quelldatei setzen, die die Klassen, Interfaces, Enumerationen und Annotationstypen enthält, die Sie in das Package aufnehmen möchten.

Die package-Anweisung sollte die erste Zeile in der Quelldatei sein. In jeder Quelldatei kann es nur eine package-Anweisung geben, und sie gilt für alle Typen in der Datei.

Wenn keine package-Anweisung verwendet wird, werden die Klasse, Interfaces, Enumerationen und Annotationstypen im aktuellen Standard-Package platziert.

Um Java-Programme mit package-Anweisungen zu kompilieren, müssen Sie die -d-Option wie folgt verwenden:

javac -d Destination_folder file_name.java

Dann wird ein Ordner mit dem angegebenen Paketnamen im angegebenen Ziel erstellt, und die kompilierten Klassendateien werden in diesen Ordner gelegt.

Beispiel: Package "animals" erstellen

Sehen wir uns ein Beispiel an, das ein Package namens animals erstellt. Es ist eine gute Praxis, Paketnamen mit Kleinbuchstaben zu verwenden, um Konflikte mit Klassennamen und Interface-Namen zu vermeiden.

Das folgende Package-Beispiel enthält ein Interface namens animals:

/* Dateiname: Animal.java */
package animals;

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

Nun implementieren wir das obige Interface im selben Package animals:

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();
    }
}

Kompilieren Sie die Java-Dateien wie folgt:

$ javac -d . Animal.java
$ javac -d . MammalInt.java

Nun wird ein Package/Ordner mit dem Namen animals im aktuellen Verzeichnis erstellt, und diese Klassendateien werden darin platziert.

Das import-Schlüsselwort

Wenn eine Klasse eine andere Klasse im selben Package verwenden möchte, muss der Paketname nicht verwendet werden. Klassen im selben Package finden sich gegenseitig ohne spezielle Syntax.

Beispiel

Hier wird eine Klasse namens Boss zum payroll-Package hinzugefügt, das bereits Employee enthält. Die Boss-Klasse kann sich dann auf die Employee-Klasse beziehen, ohne das payroll-Präfix zu verwenden, wie die folgende Boss-Klasse demonstriert:

package payroll;

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

Was passiert, wenn die Employee-Klasse nicht im payroll-Package ist? Die Boss-Klasse muss dann eine der folgenden Techniken verwenden, um auf eine Klasse in einem anderen Package zu verweisen:

• Der vollqualifizierte Name der Klasse kann verwendet werden. Zum Beispiel:

payroll.Employee

• Das Package kann mit dem import-Schlüsselwort und dem Wildcard-Zeichen (*) importiert werden. Zum Beispiel:

import payroll.*;

• Die Klasse selbst kann mit dem import-Schlüsselwort importiert werden. Zum Beispiel:

import payroll.Employee;

Hinweis – Eine Klassendatei kann beliebig viele import-Anweisungen enthalten. Die import-Anweisungen müssen nach der package-Anweisung und vor der Klassendeklaration erscheinen.

Verzeichnisstruktur von Packages

Zwei wichtige Ergebnisse treten auf, wenn eine Klasse in ein Package gestellt wird:

• Der Name des Packages wird Teil des Namens der Klasse, wie wir gerade im vorherigen Abschnitt besprochen haben.
• Der Name des Packages muss der Verzeichnisstruktur entsprechen, in der der entsprechende Bytecode residiert.

Hier ist eine einfache Möglichkeit, Ihre Dateien in Java zu verwalten:

Legen Sie den Quellcode für eine Klasse, ein Interface, eine Enumeration oder einen Annotationstyp in eine Textdatei, deren Name der einfache Name des Typs ist und deren Erweiterung .java ist.

Zum Beispiel:

// Dateiname: Car.java
package vehicle;
public class Car {
    // Klassenimplementierung
}

Legen Sie die Quelldatei nun in ein Verzeichnis, dessen Name den Namen des Packages widerspiegelt, zu dem die Klasse gehört:

....\vehicle\Car.java

Der qualifizierte Klassenname und Pfadname wären dann wie folgt:

• Klassenname → vehicle.Car
• Pfadname → vehicle\Car.java (in Windows)

Im Allgemeinen verwendet ein Unternehmen seinen umgekehrten Internet-Domainnamen für seine Paketnamen.

Beispiel – Der Internet-Domainname eines Unternehmens ist apple.com, dann würden alle seine Paketnamen mit com.apple beginnen. Jede Komponente des Paketnamens entspricht einem Unterverzeichnis.

Beispiel – Das Unternehmen hatte ein com.apple.computers-Package, das eine Dell.java-Quelldatei enthielt, wäre es in einer Reihe von Unterverzeichnissen wie folgt enthalten:

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

Zur Kompilierzeit erstellt der Compiler für jede in der Datei definierte Klasse, jedes Interface und jede Enumeration eine andere Ausgabedatei. Der Basisname der Ausgabedatei ist der Name des Typs, und seine Erweiterung ist .class.

Zum Beispiel:

// Dateiname: Dell.java
package com.apple.computers;
public class Dell { }
class Ups { }

Kompilieren Sie diese Datei nun wie folgt mit der -d-Option:

$ javac -d . Dell.java

Die Dateien werden wie folgt kompiliert:

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

Sie können alle Klassen oder Interfaces importieren, die in \com\apple\computers\ definiert sind, wie folgt:

import com.apple.computers.*;

Wie die .java-Quelldateien sollten die kompilierten .class-Dateien in einer Reihe von Verzeichnissen liegen, die den Paketnamen widerspiegeln. Der Pfad zu den .class-Dateien muss jedoch nicht derselbe sein wie der Pfad zu den .java-Quelldateien. Sie können Ihre Quell- und Klassenverzeichnisse separat anordnen, wie folgt:

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

Dadurch ist es möglich, anderen Programmierern Zugriff auf das Klassenverzeichnis zu geben, ohne Ihre Quellen preiszugeben. Sie müssen Quell- und Klassendateien auch in dieser Weise verwalten, damit der Compiler und die Java Virtual Machine (JVM) alle Typen finden können, die Ihr Programm verwendet.

Der vollständige Pfad zum Klassenverzeichnis, <path-two>\classes, wird als class path bezeichnet und wird mit der CLASSPATH-Systemvariable gesetzt. Sowohl der Compiler als auch die JVM konstruieren den Pfad zu Ihren .class-Dateien, indem sie den Paketnamen zum Class Path hinzufügen.

Angenommen, <path-two>\classes ist der Class Path und der Paketname ist com.apple.computers, dann suchen der Compiler und die JVM nach .class-Dateien in <path-two>\classes\com\apple\computers.

Ein Class Path kann mehrere Pfade enthalten. Mehrere Pfade sollten durch ein Semikolon (Windows) oder einen Doppelpunkt (Unix) getrennt werden. Standardmäßig durchsuchen der Compiler und die JVM das aktuelle Verzeichnis und die JAR-Datei, die die Java-Plattform-Klassen enthält, sodass diese Verzeichnisse automatisch im Class Path sind.

CLASSPATH-Systemvariable setzen

Um die aktuelle CLASSPATH-Variable anzuzeigen, verwenden Sie die folgenden Befehle in Windows und UNIX (Bourne Shell):

• In Windows → C:\> set CLASSPATH
• In UNIX → % echo $CLASSPATH

Um den aktuellen Inhalt der CLASSPATH-Variable zu löschen, verwenden Sie:

• In Windows → C:\> set CLASSPATH =
• In UNIX → % unset CLASSPATH; export CLASSPATH

Um die CLASSPATH-Variable zu setzen:

• In Windows → set CLASSPATH = C:\users\jack\java\classes
• In UNIX → % CLASSPATH = /home/jack/java/classes; export CLASSPATH