Unsere Datenschutzrichtlinie wird in Kürze aktualisiert. Bitte sehen Sie sich die Vorschau an.

Java 7 Grundkurs

Pakete (packages)

Testen Sie unsere 2021 Kurse

10 Tage kostenlos!

Jetzt testen Alle Abonnements anzeigen
Je umfangreicher eine Anwendung durch Objekte und Klassen wird, desto unübersichtlicher wird sie logischerweise. Um dem entgegenzuwirken, haben Sie die Möglichkeit, in Java7 mit Paketen zu arbeiten. Wie das geht, erfahren Sie hier.
13:03

Transkript

In diesem Video zeige ich Ihnen, was Pakete sind und wie Sie Ihre Klassen in Pakete einsortieren können, um mehr Übersicht in Ihre Projekte zu bringen. Unser Beispielprojekt hier ist ja noch recht übersichtlich. Es besteht aus ganzen zwei Klassen. Eine Klasse "Auto", die ein Auto repräsentiert, die also auf einfache Weise beschreibt, wie ein Auto in unserer Anwendung aussehen soll. Es kann bremsen, es kann beschleunigen, es hat einen Namen, den wir uns holen können, und das war es auch schon. Außerdem haben wir eine zweite Klasse, "Auto-Demo", das ist die Klasse mit der Main-Methode, die dient also dazu, dass wir unsere Anwendung starten können. In dieser Anwendung werden zwei Auto-Objekte gebaut, eins hier oben und eins hier unten, dann wird hier ein bisschen beschleunigt und gebremst. Die gegenwärtige Situation lässt sich also ungefähr so darstellen: Eine Klasse "Auto", eine Klasse "Auto-Demo". In der Praxis sind Anwendungen allerdings in der Regel etwas größer. Sie bestehen zur Laufzeit aus sehr vielen Objekten, und sie bestehen aus sehr vielen verschiedenen Objekten. Verschiedene Objekte werden durch verschiedene Baupläne beschrieben, d. h. also verschiedene Klassen. Und da jede Klasse ja in ihrer eigenen Datei beschrieben wird, steigt die Anzahl der Dateien rapide an. Selbst für unsere Mini-Anwendung sind bereits Erweiterungen denkbar. Es könnte z. B. sein,dass wir nicht mehr mit Autos fahren möchten, sondern z. B. mit Fahrrädern. Wir brauchen also eine zweite Klasse "Fahrrad". Weiterhin möchten wir vielleicht auch den Fahrer eines solchen Fahrzeugs in unsere Anwendung mit aufnehmen. Und wenn wir schon dabei sind, vielleicht auch gleich noch den Mechaniker. Da haben wir schon fünf Klassen. Jetzt kommen die Pakete ins Spiel: Pakete bieten uns die Möglichkeit, Klassen in Gruppen zusammenzufassen. Also bspw. die Klassen "Auto" und "Fahrrad" in die Gruppe "fahrzeuge" und die Klassen "Fahrer" und "Mechaniker" in die Klasse "nutzer". Diese Gruppierung ist auch mehrstufig möglich. Wir können also mehrere Pakete wiederum gemeinsam in ein neues Paket hineinpacken. Da unsere Anwendung "Autos" heißt, habe ich dieses Paket einfach "autos" genannt. Wir sehen, auch die "AutoDemo" Klasse befindet sich in diesem Paket "autos". Die hierarchische Strukturierung sorgt zuerst einmal für mehr Übersicht, außerdem dürfen jetzt, wenn es nötig ist, mehrere Klassen denselben Namen tragen, so lange sie sich in verschiedenen Paketen befinden. Das ist dann wie mehrere Dateien im Dateisystem, die sich in verschiedenen Verzeichnissen befinden. Jetzt schauen wir uns einmal an, wie wir das in unserem Java Quellentext umsetzen, Beginnen wir erst einmal damit, unsere Klasse "Auto" in das Paket "fahrzeuge" hineinzupacken. Dazu benötigen wir ein neues Schlüsselwort, nämlich "Package". Gehen wir in die Klasse "Auto". Das "Package Statement" muss immer ganz zu Beginn der Klassendeklaration stehen, also vor dem eigentlichen "Class"-Text. Hier ganz oben schreiben wir rein Package: "fahrzeuge", ";". Nun bekommen wir hier allerdings einen Compilerfehler angezeigt und zwar "Incorrect Package", wieso denn das? Der Grund ist folgender: Wenn eine Java-Klasse sich in einem "Package" befindet, dann muss sich die Datei, in der wir die Klasse deklarieren, auch in einem entsprechenden Verzeichnis dieses Namens befinden, d. h. "Packages" werden direkt auf Verzeichnisse abgebildet. Wenn wir mit einem Dateimanager in unser Projektverzeichnis "autos" hineinschauen, das sich standardmäßig im Verzeichnis "NetBeans Projects" befindet, dann sehen wir hier, dass wir einen Ordner "Source" haben und darin befinden sich direkt unsere Dateien "auto.java" und "autodemo.java". Ist die Klasse "Auto" aber deklariert als im Package "fahrzeuge" befindlich, dann müsste hier jetzt ein Verzeichnis "fahrzeuge" existieren, und erst darin dürfte die Datei "auto.java" liegen. Nun müssen wir aber jetzt nicht umständlich Verzeichnisse erzeugen und Dateien verschieben. Wozu haben wir denn eine IDE? Wir sehen hier links, dass ganz klein ein rotes Ausrufezeichen dasteht. D. h., es gibt ein Problem, und etwas größer sehen wir eine gelbe Lampe. Die sagt uns: "Ich hätte da aber einen Vorschlag." Wenn wir auf die gelbe Lampe drauf klicken, einmal, dann bekommen wir die zwei Vorschläge: Entweder die Klasse in den richtigen Ordner zu packen, das ist das, was wir gleich tun werden. Oder die Paketdeklaration zu entfernen, das wäre in unserem Fall natürlich Quatsch, weil wir sie gerade erst reingeschrieben haben. Klicke ich also einmal auf den ersten Punkt, dann können wir sehen, wie hier jetzt ein Paket "fahrzeuge" erzeugt wurde und die Klasse "Auto" befindet sich in diesem Paket "fahrzeuge". So, jetzt speichern wir das mal, und dann sehen wir, dass es hier in der Klasse "AutoDemo" ein Problem gibt. Das Problem heißt "Kann Symbol nicht finden: 'Auto'". Wenn aus einer Klasse heraus eine andere Klasse benutzt werden soll, dann funktioniert das wunderbar, so lange sich beide Klassen im selben Paket befinden. Bisher befanden sich beide Klassen im selben Paket, nämlich im sog. "default package". Das ist das Paket, in dem sich Klassen befinden, wenn wir keine Paketdeklaration angeben. Nun haben wir aber die Klasse "Auto" in ein anderes Paket verschoben und sie kann deshalb nicht mehr gefunden werden. Um dieses Problem zu lösen, müssen wir dem Compiler jetzt mitteilen: Wenn du hier "Auto" siehst, dann meinen wir damit das "Auto" aus dem Paket "fahrzeuge". Das machen wir mit einem sogenannten "Import Statement". Auch ein solches muss vor der eigentlichen Klassendeklaration stehen. Das Schlüsselwort heißt "import", und jetzt geben wir den vollständigen Namen der Klasse an, die wir gern importieren möchten. In unserem Fall also, "fahrzeuge.auto", und ein Semikolon. Jetzt ist der Fehler verschwunden, und alles ist wieder gut. Falls hier auf der linken Seite der Fehler noch stehen sollte bei Ihnen, so wie bei mir auch, dann speichern Sie einfach mal aus, und dann verschwindet das. Wenn Sie neue Klassen anlegen, dann ist das alles etwas einfacher, dann können Sie nämlich das Paket gleich zu Beginn mit angeben. Wenn wir jetzt beispielsweise unsere Klasse "Fahrrad" hinzufügen möchten, dann soll die ja auch in das Paket "fahrzeuge". Wir klicken also auf dieses Paket, mit der rechten Maustaste, sagen hier "New Java Class", und dann wird hier bei "Package" gleich dieses Paket "fahrzeuge" mit vorgeschlagen. Da können Sie natürlich jetzt immer noch Änderungen daran vornehmen, wenn die Klasse eigentlich doch in ein anderes Paket soll. Klassennamen angeben, "Fahrrad", fertig. Und wir sehen, die Klasse befindet sich im Paket "fahrzeuge" und in der Klassendeklaration steht oben Package "fahrzeuge". Wenn ich nun aus meiner Hauptklasse "AutoDemo" auch diese Klasse "Fahrrad" benutzen wollen würde, dann müsste ich hier oben ja ein zweites "Import Statement" reinschreiben. Also etwa so: "Import", "fahrzeuge.fahrrad". Wenn Sie mehrere Klassen aus einem Paket importieren möchten, dann gibt es eine Abkürzung, und zwar können Sie stattdessen einfach schreiben import "fahrzeuge.*". Damit importieren Sie einfach alle Klassen aus dem Paket. Eine solche Importdeklaration ist lediglich ein Tipp für den Compiler, wo er die Klassen finden könnte, die wir hier weiter unten benutzen. Es wird also nichts in diese Datei hineinkopiert oder so, d. h. unser Byte-Code später wird also nicht größer, nur weil wir jetzt hier vielleicht 250 Klassen importieren. In unserer grafischen Darstellung haben wir ja die beiden Pakete "fahrzeuge" und "nutzer" wieder in ein weiteres Paket gepackt, das hier "autos" heißt. In diesem Paket befindet sich dann auch die Klasse "AutoDemo". Auch das möchten wir jetzt im Quelltext noch umsetzen. Eine Möglichkeit wäre jetzt, in allen drei Klassen, oben die "Import Statements" anzupassen, aber es geht auch einfacher. Dazu legen wir zuerst direkt in "Source Packages" unser Paket "autos" an. Rechte Maustaste auf "Source Packages", "New", der zweite Punkt heißt "Java Package". Schreiben wir hier rein: "autos". Fertig, jetzt haben wir ein leeres Package "autos". Dort hinein können wir jetzt per Drag-and-drop unsere anderen Dinge reinziehen. D. h., ich nehme hier die Klasse "AutoDemo" und ziehe sie dort rein. Jetzt muss ich hier auf "Refactor" drücken. "Refactoring" bedeutet, dass ich die Struktur der Anwendung ändere, ohne ihre Funktionalität zu verändern, und genau das ist es, was wir hier machen. Ich drücke also auf "Refactor", und dann befindet sich im Paket "autos" jetzt die Klasse "AutoDemo". Innerhalb von "autos" lege ich jetzt ein Unterpaket "fahrzeuge" an, und in das hinein ziehe ich jetzt meine beiden Klassen. "Refactor", fertig. Schließlich müssen wir nur noch das leere Paket "fahrzeuge" löschen, rechte Maustaste "delete" erledigt das. Sie sehen, wenn sich ein Paket innerhalb eines anderen Paketes befindet, dann werden beide durch einen Punkt getrennt. NetBeans verwendet hier standardmäßig die Listendarstellung, d. h. wir haben hier oben das Paket "autos" und darunter, scheinbar als separates Paket, haben wir das Paket "autos.fahrzeuge". Möchten Sie lieber die Baumdarstellung, dann klicken Sie einfach in den leeren Bereich mit der rechten Maustaste hinein und wählen ganz unten den Punkt "View Java Packages as Tree". Dann haben Sie die hierarchische Darstellung. Zurückschalten geht genauso: Rechte Maustaste, "View Java Packages as List" und jetzt sieht es wieder aus wie vorher. Vorhin hatte ich gesagt, dass einer der Vorteile von Paketen darin besteht, dass Sie jetzt denselben Klassennamen mehrfach verwenden können, so lange sich die Klassen in verschiedenen Paketen befinden. Das kann z. B. vorteilhaft sein, wenn Sie in Ihrem Projekt externe Bibliothenken verwenden, und in diesen Bibliotheken sind zufällig Klassen drin, die genauso heißen wie Ihre Klassen auch. So lange sich die Klassen in verschiedenen Paketen befinden, ist alles in Ordnung. Was nun aber, wenn auch die Paketnamen dieselben sind? Um das zu verhindern, hat man sich eine lustige Namenskonvention ausgedacht. Die Idee basiert auf dem Umstand, dass es im Internet jeden Domain-Namen nur einmal gibt. Wenn wir nun all unseren Paketnamen unseren Domain-Namen voranstellen, dann sind Kollisionen ausgeschlossen. Vorausgesetzt natürlich, es halten sich alle an diese Regel. Man beginnt dazu mit der "Toplevel-Domain", also "com" oder "de" oder "org", usw. und danach folgt der eigentliche Domain-Name, danach dann der Name des Projektes, usw. In unserem Fall könnte das also z. B. so aussehen: Ganz vorne das erste Paket heißt "com", dann kommt das Paket "video2brain", jetzt haben wir das Paket "java7" und darin das Paket "autos". Das wird zwar jetzt etwas länger, aber auf diese Weise sind Ihre Klassennamen jetzt global eindeutig, und Kollisionen sind so gut wie ausgeschlossen. Bringen wir die Änderung noch in unseren Quelltext ein. Dazu gehe ich auf das Paket "autos", rechte Maustaste, "refactor", "rename". Jetzt kann ich das Ding umbenennen in "com.video2brain.java7.autos", "refactor". Das gleiche muss ich jetzt natürlich mit dem anderem Paket auch machen. Ich kann es direkt hier reintippen: "com.video2brain". Sie können es natürlich auch einfach kopieren und einfügen an der Stelle, also den Text ".java7.autos", "refactor", und der Fehler verschwindet noch nicht. Dadurch, dass wir jetzt manuell hier ein bisschen dazwischengepfuscht haben, jetzt hier ein Import zuviel. Diese Zeile können wir also entfernen. Alles andere ist ja vollkommen korrekt geändert worden. Die Klasse "AutoDemo" befindet sich jetzt im Package "com.video2brain.java7.autos" und wir importieren die Klasse "com.video2brain.java7.autos. fahrzeuge.auto". So, noch speichern, dann verschwindet das rote Ausrufezeichen. Eine wichtige Anmerkung noch dazu: Solche Imports sind nicht rekursiv, d. h., ich kann jetzt zwar sagen: "import hmhmhm.*", dann importiere ich alles aus dem Paket "fahrzeuge". Ich kann aber nicht z. B. sagen, ich importiere einfach "autos.*". Dann würde ich nur alles aus dem Paket "autos" importieren, nicht aber etwas, was sich evtl. noch in Unterpaketen befindet. Dann hätten wir wieder einen Compilerfehler, wir sehen es hier oben an dem roten Ausrufezeichen, da funktioniert wieder irgendwas nicht. Machen wir das also wieder rückgängig. So, "fahrzeuge.*", "speichern" und zum Abschluss noch mal testen, ob die Anwendung auch tatsächlich funktioniert. Ja, Läuft alles hervorragend. Für die Paketnamen können Sie prinzipiell beliebige Bezeichner wählen, es müssen natürlich gültige Java-Bezeichner sein, und Sie haben das vielleicht gesehen, die Konvention sieht vor, dass die Bezeichner grundsätzlich aus Kleinbuchstaben bestehen. Damit haben Sie nun gesehen, wie Sie mit Paketen Ihre Anwendungen besser strukturieren können und auf diese Weise, insbesondere bei größeren Projekten immer die Übersicht behalten.

Java 7 Grundkurs

Machen Sie sich mit den Grundlagen der Java-Programmierung vertraut und lernen Sie die Syntax der Sprache sowie das Konzept der objektorientierten Softwareentwicklung kennen.

8 Std. 32 min (66 Videos)
Derzeit sind keine Feedbacks vorhanden...
 

Dieser Online-Kurs ist als Download und als Streaming-Video verfügbar. Die gute Nachricht: Sie müssen sich nicht entscheiden - sobald Sie das Training erwerben, erhalten Sie Zugang zu beiden Optionen!

Der Download ermöglicht Ihnen die Offline-Nutzung des Trainings und bietet die Vorteile einer benutzerfreundlichen Abspielumgebung. Wenn Sie an verschiedenen Computern arbeiten, oder nicht den ganzen Kurs auf einmal herunterladen möchten, loggen Sie sich auf dieser Seite ein, um alle Videos des Trainings als Streaming-Video anzusehen.

Wir hoffen, dass Sie viel Freude und Erfolg mit diesem Video-Training haben werden. Falls Sie irgendwelche Fragen haben, zögern Sie nicht uns zu kontaktieren!