Anleitung zu Java-Paketen

1. Einleitung

In diesem kurzen Tutorial werden die Grundlagen von Paketen in Java behandelt. Wir werden sehen, wie man Pakete erstellt und auf die Typen zugreift, die wir darin platzieren.

Wir werden auch Namenskonventionen diskutieren und wie sich dies auf die zugrunde liegende Verzeichnisstruktur auswirkt.

Schließlich werden wir unsere gepackten Java-Klassen kompilieren und ausführen.

2. Übersicht über Java-Pakete

In Java verwenden wir Pakete, um verwandte Klassen, Schnittstellen und Unterpakete zu gruppieren .

Die Hauptvorteile davon sind:

  • Erleichterte Suche nach verwandten Typen - Pakete enthalten normalerweise Typen, die logisch verwandt sind
  • Vermeiden von Namenskonflikten - Ein Paket hilft uns, eine Klasse eindeutig zu identifizieren. Zum Beispiel könnten wir eine com.baeldung.Application- sowie eine com.example.Application- Klasse haben
  • Kontrollieren des Zugriffs - Wir können die Sichtbarkeit und den Zugriff auf Typen steuern, indem wir Pakete und Zugriffsmodifikatoren kombinieren

Als nächstes wollen wir sehen, wie wir Java-Pakete erstellen und verwenden können.

3. Erstellen eines Pakets

Um ein Paket zu erstellen, müssen wir die Paketanweisung verwenden , indem wir sie als allererste Codezeile in eine Datei einfügen .

Platzieren wir einen Typ in einem Paket mit dem Namen com.baeldung.packages :

package com.baeldung.packages;

Es wird dringend empfohlen, jeden neuen Typ in ein Paket aufzunehmen. Wenn wir Typen definieren und sie nicht in ein Paket einfügen, werden sie in das Standardpaket oder das unbenannte Paket aufgenommen. Die Verwendung von Standardpaketen hat einige Nachteile:

  • Wir verlieren die Vorteile einer Paketstruktur und können keine Unterpakete haben
  • Wir können die Typen im Standardpaket nicht aus anderen Paketen importieren
  • Die geschützten und paketprivaten Zugriffsbereiche wären bedeutungslos

Wie in der Java-Sprachspezifikation angegeben, werden unbenannte Pakete von der Java SE-Plattform hauptsächlich zur Vereinfachung bei der Entwicklung kleiner oder temporärer Anwendungen oder zu Beginn der Entwicklung bereitgestellt.

Daher sollten wir vermeiden, unbenannte oder Standardpakete in realen Anwendungen zu verwenden .

3.1. Regeln der Namensgebung

Um gleichnamige Pakete zu vermeiden, befolgen wir einige Namenskonventionen:

  • Wir definieren unsere Paketnamen in Kleinbuchstaben
  • Paketnamen sind durch Punkte getrennt
  • Namen werden auch von der Firma oder Organisation bestimmt, die sie erstellt

Um den Paketnamen basierend auf einer Organisation zu ermitteln, kehren wir normalerweise die Unternehmens-URL um. Danach wird die Namenskonvention von der Firma definiert und kann Abteilungsnamen und Projektnamen enthalten.

Um beispielsweise aus www.baeldung.com ein Paket zu erstellen , kehren wir es um:

com.baeldung

Wir können dann weitere Unterpakete wie com.baeldung.packages oder com.baeldung.packages.domain definieren.

3.2. Verzeichnisaufbau

Pakete in Java entsprechen einer Verzeichnisstruktur.

Jedes Paket und Unterpaket hat ein eigenes Verzeichnis. Für das Paket com.baeldung.packages sollten wir also eine Verzeichnisstruktur von com -> baeldung -> packages haben .

Die meisten IDEs helfen beim Erstellen dieser Verzeichnisstruktur basierend auf unseren Paketnamen, sodass wir diese nicht manuell erstellen müssen.

4. Verwenden von Paketmitgliedern

Beginnen wir mit der Definition einer Klasse TodoItem in einem Unterpaket mit dem Namen domain :

package com.baeldung.packages.domain; public class TodoItem { private Long id; private String description; // standard getters and setters }

4.1. Importe

Um unsere TodoItem- Klasse aus einer Klasse in einem anderen Paket zu verwenden, müssen wir sie importieren. Sobald es importiert ist, können wir über den Namen darauf zugreifen.

Wir können einen einzelnen Typ aus einem Paket importieren oder ein Sternchen verwenden, um alle Typen in einem Paket zu importieren.

Importieren wir das gesamte Domain- Unterpaket:

import com.baeldung.packages.domain.*;

Importieren wir jetzt nur die TodoItem- Klasse:

import com.baeldung.packages.domain.TodoItem;

Das JDK und andere Java-Bibliotheken werden ebenfalls mit eigenen Paketen geliefert. Wir können bereits vorhandene Klassen, die wir in unserem Projekt verwenden möchten, auf dieselbe Weise importieren.

Importieren wir beispielsweise die Java Core List- Schnittstelle und die ArrayList- Klasse:

import java.util.ArrayList;import java.util.List;

Wir können diese Typen dann in unserer Anwendung verwenden, indem wir einfach ihren Namen verwenden:

public class TodoList { private List todoItems; public void addTodoItem(TodoItem todoItem) { if (todoItems == null) { todoItems = new ArrayList(); } todoItems.add(todoItem); } }

Here, we've used our new classes along with Java core classes, to create a List of ToDoItems.

4.2. Fully Qualified Name

Sometimes, we may be using two classes with the same name from different packages. For example, we might be using both java.sql.Date and java.util.Date. When we run into naming conflicts, we need to use a fully qualified class name for at least one of the classes.

Let's use TodoItem with a fully qualified name:

public class TodoList { private List todoItems; public void addTodoItem(com.baeldung.packages.domain.TodoItem todoItem) { if (todoItems == null) { todoItems = new ArrayList(); }todoItems.add(todoItem); } // standard getters and setters }

5. Compiling with javac

When it's time to compile our packaged classes, we need to remember our directory structure. Starting in the source folder, we need to tell javac where to find our files.

We need to compile our TodoItem class first because our TodoList class depends on it.

Let's start by opening a command line or terminal and navigating to our source directory.

Now, let's compile our com.baeldung.packages.domain.TodoItem class:

> javac com/baeldung/packages/domain/TodoItem.java

If our class compiles cleanly, we'll see no error messages and a file TodoItem.class should appear in our com/baeldung/packages/domain directory.

For types that reference types in other packages, we should use the -classpath flag to tell the javac command where to find the other compiled classes.

Now that our TodoItem class is compiled, we can compile our TodoList and TodoApp classes:

>javac -classpath . com/baeldung/packages/*.java

Again, we should see no error messages and we should find two class files in our com/baeldung/packages directory.

Let's run our application using the fully qualified name of our TodoApp class:

>java com.baeldung.packages.TodoApp

Our output should look like this:

6. Conclusion

In this short article, we learned what a package is and why we should use them.

We discussed naming conventions and how packages relate to the directory structure. We also saw how to create and use packages.

Finally, we went over how to compile and run an application with packages using the javac and java commands.

Der vollständige Beispielcode ist auf GitHub verfügbar.