Pakete erstellen das nächste, die nächste Ebene der Gliederung,
da die Java bietet, als Module. Ja,
wiederum das Gleiche, wir möchten etwas kapseln,
wir möchten Ausbreitung von Änderungen begrenzen, also alles diese Dinge,
das ist das Nächste, das Paket ist das nächste Modulkonzept,
was wir hier haben.
Es hilft wiederum bei der Strukturierung und es kann einiges enthalten,
nämlich Klasseninterfaces und weitere Pakete. Das zeigt dieses Bild hier,
das Java, das UML-Symbol für ein Paket,
ist so ein Rechteck mit so einem Reiter obendran,
wo man den Namen hier reinschreibt,
man kann
den Namen aber noch hier unten reinschreiben
Ja, also dieses Paket enthält hier wieder
ein Paket und nebenbei enthält es Klassen und ein Interface.
Ja, und eine Klasse von außen benutzt jetzt hier eine Klasse aus diesem Paket.
Diese Klasse ist public. Damit kann sie benutzt werden.
Und wir haben die Möglichkeit, den Zugriff zu beschränken,
wenn wir hier drin private Klassen haben,
dann sind die nach außen nicht erreichbar.
Das werden wir gleich noch mal sagen. Und sie bilden,
was es noch für Möglichkeiten gibt, außer privat, meine ich.
Und sie bilden einen Namensraum. Und was vielleicht auch noch
ganz interessant ist, insbesondere bei großen Projekten,
sie sind eine Einheit der Übersetzung
Bei großen Projekten, wo ich das schon mal ein paar Minuten dauert,
bis ich was übersetze, freue ich mich,
dass ich nur ein Paket übersetzen muss,
weil sich nur das geändert hat und die anderen Sachen,
die ich schon übersetzt habe,
muss ich nicht noch mal separat machen.
Also für große Projekte, die sehr komplex sind,
Hilfen helfen uns die Klassen, Dinge zusammenzufassen, Klassen helfen uns die Dinge.
Nur in der Zugriff zu beschränken, ja,
und gleichzeitig Übersetzungszeit zu sparen, ja,
das ist gleichzeitig auch eine Möglichkeit, ja,
wie wir,
wie wir das steuern können und noch mal auf separate Namensraum,
was meinen wir damit
Also wenn wir einen Namen haben wie List oder Pfeil,
der relativ häufig vorkommt, können wir sagen,
in dem Paket ist List genau das.
In dem Paket ist List genau das. Wir können Namen mehrfach verwenden,
weil dadurch, weil durch die Angabe des Pakets eindeutig ist,
wo es da herkommt. Und wenn wir das nicht eindeutig machen wollen,
können wir das auch manchmal weglassen, ja, implizit,
also ohne, dass es explizit gesagt wird,
ist der Paketnamen immer.
Als Prefix, aber besser ist es natürlich den Volk qualifizierten Namen,
als den vollen Namen zu nehmen.
Also wir haben hier von der Klasse Punkt,
geben wir noch an,
dass es
dem Graphics-Paket stammt
Ja, und das Ganze fordert nach Eindeutigkeit. Jede Klasse
kann nur zu einem Paket gehören. Public als Möglichkeit,
etwas nach außen sichtbar zu machen, hätte ich schon gesagt.
Wenn wir keinen durch ein Multifyer haben, also weder Public noch Private noch irgendwas,
dann ist es das im Paket sichtbar. Wir sagen,
was zu einem Paket gehört, in dem wir eine Übersetzungseinheit,
das heißt eine Datei meistens,
dass wir die mit dem Bezeichner Package, mit dem Schlüsselwort Package deklarieren,
zum Beispiel im Package Graphics Und da ist das alles,
was da drin steht, gehört dazu, wenn man das weglässt,
gibt es ein Default-Package, wo alles drin ist.
Man darf es also auch weglassen. Ja,
diese Möglichkeit, die zu Schachteln,
hilft uns sozusagen größere und kleinere Einheiten voneinander zu trennen,
wäre es nur das Gesamt braucht,
nimmt das Größere und wer innen drin was macht,
nimmt das Kleinere und damit können wir namens Konflikte
auch auf dieser Ebene vermeiden
Es gibt eine Namenskonvention, die empfohlen wird. Konventionen ist ja immer etwas,
wo man sich freiwillig dran hält, was Disziplin erfordert.
Also nicht das Laufzeitsystem meckert, wenn man da was falsch macht,
sondern da muss man sich selber dran halten.
Die Konvention ist, dass man die Internetdomänen,
zu der man gehört, als Basis für den Paketname nimmt.
Häufig macht man das bei größeren Einheiten.
Das Beispiel ist also Uni Hamburg, wir sind die,
ich gehöre zu der Arbeits- zum Arbeitsbereich SWK,
also die Professur sozusagen.
Ja, wir gehören zum Fachbereich Informatik und wir gehören zur
Uni Hamburg und das Ganze ist in Deutschland
Ja, und unser Paket Grafik hat noch ein Unterpaket Box.
Und dann haben wir das in dieser umgezerrten Bezeichnung hier.
Also das ist damit hier die Konvention, die Reihenfolge ist umgedreht.
Und wir haben Kleinbuchstaben. So, und gleichzeitig gibt es noch
die Konvention, dass man das im Dateisystem entsprechend ablegt.
Ja, also die Paketstruktur. Und dann ist aber umgekehrt,
unihamburg.de ist dann zum Beispiel die Domäne oder der Server,
wo wir das Ganze zu holen ist.
Dann gibt es einen Ordner mit SWK,
einen Ordner Grafiks, einen Ordnerbox oder die Klasse Box.
Das ist hier
nicht ganz deutlich
Ja, also damit können wir das so entsprechend, ja,
in der Richtung Schachteln und gleichzeitig ordnen. Nachdem wir nun wissen,
wie wir etwas nach außen sichtbar machen können, nun darum,
soll es nur darum gehen, wie können wir darauf zugreifen.
Das können wir jeweils mit Importbeziehungen machen, die Importanweisung erlaubt es uns,
woanders, von woanders her etwas zugreifbar zu machen.
Und da gibt es zwei Möglichkeiten. Einerseits können wir
eine Klasse importieren, wie hier die Klasse R,
die von Klasse H und G importiert wird.
Oder wir können
ein ganzes Paket importieren
Ja, dass sie dann so aus, ja,
also hier die Klasse R und hier dieses Paket,
ja, die Klasse R, indem wir die importieren wollen.
Ach so, hier steht es,
indem wir die Klasse R von dem Paket Dev importieren,
nehmen wir die Anweisung, Importdev.r.
Also hier ist das Paket Dev und die Klasse R.
Und Import LMK.stern bedeutet, wir importieren alles von dem Paket LMK.
Ja, also so sieht es dann mit dem Java-Schlüsselwort aus
Wir können durch diese, wir können eine verkürzte Schreibweise wählen,
wenn wir etwas importiert haben, indem wir zum Beispiel,
wenn wir vorher sagen, wir importieren die Klasse, Punkt,
aus dem Paket Graphics, dann reicht es uns in Zukunft,
wenn wir hier etwas erzeugen, zum Beispiel eine Instanz von Punkt,
können wir einfach nur, müssen wir nicht schreiben,
Graphics, Punkt, Punkt, Punkt, sondern das,
aber wenn wir die Importanweisungen nicht haben,
können wir trotzdem darauf zugreifen,
aber da müssten wir explizit hier
Graphics Punkt angeben
Ja, also hier erleichtern wir uns das, indem wir diese Anweisung benutzen.
Also wir können, hier steht das Können. Ja,
wir können uns das damit ein bisschen einfacher machen.
Die Export-Schnittstelle, das ist ein wichtiger Punkt.
Ja, wie machen wir es nach außen sichtbar?
Verhindert man schon generell, dass es durch Public läuft und
genau das ist auch die Antwort auf die Frage.
Wir springen gleich zurück zu den Fragen.
Alles, was Public ist, ist nach außen sichtbar.
Ja, sie bildet also alles, was Public ist,
bildet die Exportschnittstelle eines Pakets
Wir können dann auf Klassen zugreifen, erstmal das,
was Public ist, ja, und das wirklich von allen anderen Paketen.
Von überall her, wenn es denn Public ist,
wenn es wir es dort in irgendeiner Form importieren.
Und wenn wir kein Multifyer haben, also weder Public noch Prei wird noch protected,
noch irgendwas, dann können wir es innerhalb dieses Pakets zugreifen.
Wir können das nicht einschränken, das,
was ich eben schon sagte, es gibt keine Schutzmechanismen,
wir werden gleich noch was in dem nächsten Abschnitt zu den Moduls noch sagen,
aber wir können es überall zugreifen, aber wir können es strukturieren.
Ja, aber diese Strukturierung hilft nicht wirklich um den Zugriff zu verhindern. Ja,
also wir können hier mit Import zwar sagen, wir parketieren,
wir haben das in Unterpaket und so weiter, wir greifen hier darauf zu,
aber wir können es nicht einschränken, wir können nicht sagen,
ich kann nur auf mein Paket zugreifen und hier drin nicht,
wenn das public ist.
So, nochmal hier vollständig,
wir hatten bis jetzt nur Private und ohne Private,
ist schon klar, es kann nicht zugegriffen werden, von welchen,
die weiter oben liegen und das Ganze hängt nicht davon ab,
wie es Vererbung ist oder wie Vererbungsbeziehung ist oder wie es zum Paket gehört.
Es kann nicht zugegriffen werden. Anders sieht es aus,
wenn wir keinen durch den Modifier haben, ja,
dann kann es im selben Paket zugegriffen werden.
Manche sagen dazu Package Private, aber das ist eine Slang-Bezeichnung.
Eigentlich heißt das, ist da Standardzugriff, Default Modifier. So,
dann gibt es noch Protected, das ist ein bisschen eingeschränkt,
ja, es ist zugreifbar für Klassen im selben Paket und für Subklassen.
Ja, wenn wir in anderen Paketen davon erben, So,
und dieses Public, das hatten wir schon gesagt, das ist dann von überall her zugreifbar. Hier haben wir das nochmals in der Übersicht,
wir haben ja gleich noch nicht das kleines Quiz,
dass sie ihn schon mal sehen, ja,
also wenn wir hier Private haben,
dann sind wir nur in dem Paket A, B,
C zugreifbar, nicht von DEF irgendwo, wenn wir diesen Default-Motifyer haben,
dann ist es von überall her in ABC zugreifbar,
jedes war nicht in anderen Klassen zugreifbar, also ja auch aus anderen Klassen,
wenn es protected ist, ja, dann kann es,
wenn hier die Klasse von der Klasse vererbt wird, dann ist keines hier drin zugegriffen werden, auch in anderen Paketen.
Das ist das, was ich eins vorspringe,
nochmal eine Folie zurück, ja, hier in Subklassen in anderen Paketen.
Ja, also hier haben wir eine Subklasse von Klasse A
und dann darf dieses Protected hier zugegriffen werden und Public bedeutet,
es kann überall herzugegriffen, nicht nur von dieser Subklasse, sondern von überall her soweit.
Ja, dabei soweit, dass die Zusammenfassung nochmal,
nein, lass uns uns erst zu den Fragen springen,
die Steuerungsmöglichkeiten für Ich meine, Frage 4, wann ist etwas sichtbar?
Das war das mit dem Public. Ja,
die Steuerungsmöglichkeiten von Java-Modulen werden wir gleich im nächsten Abschnitt besprechen.
Und Zugriffsschutz haben wir durch Private, durch Protected und durch den Default Modifier.
Ja, soweit, soweit dazu und nun zu den,
zu der Zusammenfassung. Wir haben Blava und Packages bilden Module
im Sinne von Paketen als Konzept der Einheiten von Softwarearchitektur. Wir nutzen es zur Bildung,
zur Strukturierung, vor allen Dingen der große Systeme haben,
wo wir den Zugriffsschutz beschränken müssen,
damit sich nicht Änderungen zu sehr ausbreiten, Namensräume erleichtern,
das eindeutige Bezeichner zu vergeben und erleichtern die Entkopplung,
Import und Export, Schnittstellen, geben uns die Möglichkeit,
das in Java auch noch in der Sprache mit Sprachmitteln zu deklarieren.
Und gegenüber dem Typ ist auch noch was mehr,
dass wir eine Typhierarchie haben, Exemplare erzeugen können.
Soweit. Dazu erst mal, es kommt gleich im nächsten
Einheit zu den Java-Modulen