Die Bedeutung qualifizierter Namen in Java

Qualifizieren

„Qualifizieren“ bedeutet soviel wie: „näher bestimmen“.

Im qualifizierten Namen »java.lang.Integer.MAX_VALUE« wird der am Ende stehende einfache Name »MAX_VALUE« durch den vorangestellten Text »java.lang.Integer.« näher bestimmt („qualifiziert“). So kann er von anderen Namen, wie beispielsweise »java.lang.Long.MAX_VALUE«, die auch mit »MAX_VALUE« enden, unterschieden werden. Solche langen Namen sind hilfreich, wenn in großen Programmen mehrere ähnliche Namen unterschieden werden sollen, ähnlich wie man in großen Gruppen von Personen zur Unterscheidung der Personen bei Gleichheit zweier Nachnamen noch die Vornamen zur Unterscheidung heranziehen kann.

Vergleich von Java -Namen und Personenbezeichnungen

java. lang. Integer. MAX_VALUE

Prof. Dr. Fritz Müller

Die Bedeutung des Punktes »`.`«

Der Punkt ».« drückt in qualifizierten Namen in der Regel aus, daß das Rechtsstehende als in dem Linksstehenden „enthalten“ angesehen wird.

Daher nennen wir etwas, das links von einem Punkt steht oder stehen kann, auch ein Verzeichnis (man denke an ein Verzeichnis eines Datenträgers), und etwas, das rechts von einem Punkt stehen kann, einen Eintrag.

Das Verzeichnis »java.lang.Integer« enthält also den Eintrag »MAX_VALUE«. (»java.lang.Integer« enthält auch noch andere Einträge, wie beispielsweise »MIN_VALUE«.)

Das Verzeichnis »java.lang« enthält den Eintrag »Integer«.

Der einfache Name »java« wird allerdings normalerweise nicht als ein Verzeichnis angesehen, vielmehr zerlegte man in Java den Namen »java.lang« normalerweise nicht weiter in seine beiden einfachen Namen.

Man kann sich vorstellen, daß es in Java so viele Namen gibt, daß Referenztypen herangezogen werden, um sie übersichtlich abzulegen, so wie man Gegenstände in verschiedenen Schubladen ablegt.

Das Ineinanderenthaltensein bei »java.lang.Integer.MAX_VALUE«

.----------------------------------------------------------.
| java.lang                                                |
| .------------------------------------------------------. |
| | Integer                                              | |
| | .--------------------------------------------------. | |
| | | MAX_VALUE                                        | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
'----------------------------------------------------------'

»`java.lang.Long.MAX_VALUE`«

Der Name »java.lang.Long.MAX_VALUE« steht für die größte Zahl des Datentyps »long«.

Das Ineinanderenthaltensein bei »java.lang.Integer.MAX_VALUE«

.----------------------------------------------------------.
| java.lang                                                |
| .------------------------------------------------------. |
| | Long                                                 | |
| | .--------------------------------------------------. | |
| | | MAX_VALUE                                        | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
'----------------------------------------------------------'

Berichtstypen für elementare Typen

Da elementare Typen keine Namen enthalten können, verwendet für jeden elementaren Typ einen Referenztyp, der Informationen über den elementaren Typ enthalten kann.

Elementare Typen und ihre Berichtstypen

elementarer Typ Berichtstyp

int java.lang.Integer
long java.lang.Long

Das Ineinanderenthaltensein der bisher vorgestellten Namen

Wir zeigen nun die bisher vorgestellten Namen alle zusammen in einem Schaubild.

Das Ineinanderenthaltensein der bisher vorgestellten Namen

.----------------------------------------------------------.
| java.lang                                                |
| .------------------------------------------------------. |
| | Integer                                              | |
| | .--------------------------------------------------. | |
| | | MAX_VALUE                                        | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
| .------------------------------------------------------. |
| | Long                                                 | |
| | .--------------------------------------------------. | |
| | | MAX_VALUE                                        | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
| .------------------------------------------------------. |
| | Math                                                 | |
| | .--------------------------------------------------. | |
| | | PI                                               | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
'----------------------------------------------------------'

»`java.lang.Math.E`«

Der Name »java.lang.Math.E« steht für die Eulersche Zahl (eine bestimmte Zahl, zirka ‹ 2,718 ›).

Das Ineinanderenthaltensein bei »java.lang.Math.E«

.----------------------------------------------------------.
| java.lang                                                |
| .------------------------------------------------------. |
| | Math                                                 | |
| | .--------------------------------------------------. | |
| | | E                                                | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
'----------------------------------------------------------'

Das Ineinanderenthaltensein der bisher vorgestellten Namen

.----------------------------------------------------------.
| java.lang                                                |
| .------------------------------------------------------. |
| | Integer                                              | |
| | .--------------------------------------------------. | |
| | | MAX_VALUE                                        | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
| .------------------------------------------------------. |
| | Long                                                 | |
| | .--------------------------------------------------. | |
| | | MAX_VALUE                                        | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
| .------------------------------------------------------. |
| | Math                                                 | |
| | .--------------------------------------------------. | |
| | | PI                                               | | |
| | | E                                                | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
'----------------------------------------------------------'

Eigentliche Namen

Der einfache Name am Ende eines qualifizierten Namens bestimmt die Bedeutung des ganzen Namens. Beispielsweise ist »java.lang.Math.PI« die Kreiszahl ‹ π › („Pi“) und »java.lang.Math.E« die Eulersche Zahl ‹ e ›. Das davorstehende Verzeichnis gibt nur einen Zusammenhang (Kontext) an, um Mißverständnisse zu vermeiden, entscheidend ist aber der einfache Name am Ende. So ist es in manchen Fällen auch möglich, ein Verzeichnis wegzulassen, aber der einfache Name am Ende muß immer genannt werden, um sich auf einen bestimmten Wert zu beziehen.

Der einfache Name am Ende eines qualifizierten Namens bestimmt, wofür der ganze Name steht. Daher nennen wir den einfachen Namen am Ende eines qualifizierten Namens auch den eigentlichen Namen.

Der eigentliche Name in »java.lang.Integer.MAX_VALUE« ist also beispielsweise »MAX_VALUE«.

Einen Teil, der in einem Namen eventuell vor einem Punkt ».« und dem eigentlichen Namen steht, nennen wir die Qualifikation des Namens.

Der Qualifikation des Namens »java.lang.Integer.MAX_VALUE« ist also beispielsweise »java.lang.Integer«.

Beim mündlichen Bezug auf einen Namen reicht es oft, nur den eigentlichen Namen oder eine Teil vom Ende des Namens auszusprechen, wenn das Davorstehende sich aus dem Zusammenhang ergibt. So kann der Name »java.lang.Integer.MAX_VALUE« also oft einfach als “max value ” oder “integer max value ” ausgesprochen werden.

Das Ineinanderenthaltensein der bisher vorgestellten Namen

.----------------------------------------------------------.
| java.lang                                                |
| .------------------------------------------------------. |
| | Integer                                              | |
| | .--------------------------------------------------. | |
| | | MAX_VALUE                                        | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
| .------------------------------------------------------. |
| | Long                                                 | |
| | .--------------------------------------------------. | |
| | | MAX_VALUE                                        | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
| .------------------------------------------------------. |
| | Math                                                 | |
| | .--------------------------------------------------. | |
| | | PI                                               | | |
| | | E                                                | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
'----------------------------------------------------------'

Wenn jemand „Prof. Dr. Fritz Müller“ genannt wird, so könnte man entsprechend auch sagen, daß der „eigentliche Name“ dieser Person „Fritz Müller“ ist, denn die anderen Qualifikationen sind nicht wirklich Teil des Namens.

Referenztypen

Verzeichnisse, die Namen direkt enthalten (wie »java.lang.Integer«), werden in Java auch noch einmal durch eine besondere Bezeichnung gewürdigt: sie werden als Referenztypen bezeichnet.

Man kann sich einen Referenztyp also als ein Verzeichnis für Namen vorstellen.

Wir kennen allerdings auch schon den Referenztyp »java.lang.String«, den wir als Typ von Zeichenfolgenausdrücken, wie »"abc"« kennengelernt haben. Referenztypen haben eben eine Doppelnatur: sie können einerseits Typ von Ausdrücken sein (wie »java.lang.String«) und andererseits Verzeichnisse für Namen (wie »java.lang.Integer«), ein einzelner Referenztyp kann manchmal auch beides gleichzeitig sein – Beispiele dafür werden aber erst wesentlich später im Kurs behandelt werden.

Der Referenztyp »java.lang.Integer« enthält einige Informationen, die eigentlich zum elementaren Typ »int« gehören. Da ein elementarer Typ kein Verzeichnis ist, kann »int« diese Informationen nicht selber aufnehmen. Man kann die Schreibweise »int.MAX_VALUE« nicht verwenden, denn hinter »int« ist ein Punkt ».« nicht erlaubt.

Referenztypen, wie »java.lang.Integer«, und elementare Typen, wie »int«, sind Typen, aber nur Referenztypen können als Verzeichnisse genutzt werden. Elementare Typen, wie »int«, haben keine Einträge. Daß der Typ »int« keine eigenen Einträge enthalten kann, die ihn beschreiben, ist der Grund dafür, daß sich einige Informationen über den Typ »int« im Typ »java.lang.Integer« befinden.

Das Ineinanderenthaltensein der bisher vorgestellten Namen

.----------------------------------------------------------.
| java.lang                                                |
| .------------------------------------------------------. |
| | Referenztyp "Integer"                                | |
| | .--------------------------------------------------. | |
| | | MAX_VALUE                                        | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
| .------------------------------------------------------. |
| | Referenztyp "Long"                                   | |
| | .--------------------------------------------------. | |
| | | MAX_VALUE                                        | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
| .------------------------------------------------------. |
| | Referenztyp "Math"                                   | |
| | .--------------------------------------------------. | |
| | | PI                                               | | |
| | | E                                                | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
'----------------------------------------------------------'

Das Typsystem von Java

Typen

|
.------------'------------.
| |

Referenztypen elementare Typen

java.lang.String double
java.lang.Integer int
java.lang.Math long
java.lang.Long

Daß ›int‹ und ›Integer‹ zwei verschiedene Typen sind, ist ein weiterer Grund dafür, »int« nicht wie “integer ” auszusprechen.

Elementare Typen wie ›int‹ können keine Namen wie »MAX_VALUE« enthalten. Deswegen enthält der Referenztyp ›Integer‹ ersatzweise Informationen über den elementaren Typ ›int‹.

Klassen

Die bisher vorgestellten Referenztypen sind alle Klassen.

Da wir die Unterschiede zwischen dem Begriff „Klasse“ und dem Begriff „Referenztyp“ vorerst nicht benötigen werden, kann man die Begriffe „Referenztyp“ und „Klasse“ vorerst als gleichbedeutend ansehen. Wir verwenden im folgenden für Klassen manchmal die Bezeichnung „Klasse“, wenn vermittelt werden soll, daß ein Referenztyp eine Klasse ist, oder „Referenztyp“, wenn eine Aussage, die für alle Referenztypen gilt, nicht unnötig auf Klassen eingeschränkt werden soll.

Das Ineinanderenthaltensein der bisher vorgestellten Namen

.----------------------------------------------------------.
| java.lang                                                |
| .------------------------------------------------------. |
| | Klasse "Integer"                                     | |
| | .--------------------------------------------------. | |
| | | MAX_VALUE                                        | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
| .------------------------------------------------------. |
| | Klasse "Long"                                        | |
| | .--------------------------------------------------. | |
| | | MAX_VALUE                                        | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
| .------------------------------------------------------. |
| | Klasse "Math"                                        | |
| | .--------------------------------------------------. | |
| | | PI                                               | | |
| | | E                                                | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
'----------------------------------------------------------'

Das Typsystem von Java

Typen

|
.------------'------------.
| |

Referenztypen elementare Typen

| double
.------------'------------. int
| | long

Klassen andere
Arten von
java.lang.String Referenztypen
java.lang.Integer
java.lang.Math
java.lang.Long

Java

java.lang.Math.PI

auf deutsch

„der Name »PI« aus der Klasse »java.lang.Math«“

Bezeichnungen für Namen, die als Ausdrücke verwendet werden können

Für Namen, die als Ausdrücke verwendet werden können, wie »java.lang.Math.PI«, sind verschiedene Bezeichnungen gebräuchlich oder passend, von denen einige im folgenden vorgestellt werden.

Wertnamen

Der Name »java.lang.Math.PI« steht, ähnlich wie ein Literal, für einen bestimmten Wert. Daher nennen wir ihn auch einen Wertnamen.

Konstanten

Wertnamen werden auch als Konstanten bezeichnet, wenn der Name immer den gleichen Wert hat. (Die JLS enthält allerdings eine etwas engere Definition dieses Begriffs.)

Wir können »java.lang.Math.PI« also informell auch als eine Konstante bezeichnen, auch wenn dieser Gebrauch fachsprachlich nicht immer korrekt ist.

Variablen

Die Wertnamen eines Referenztyps werden auch manchmal als Variablen dieses Typs bezeichnet.

»java.lang.Math.PI« kann also auch als Variable bezeichnet werden. Dies scheint einen Widerspruch dazu darzustellen, daß der Wert eben nicht veränderbar (also variabel) ist, aber in Java gelten Konstanten als ein Spezialfall von Variablen, als konstante Variablen.

Felder

Der Wertname »MAX_VALUE« ist im Referenztyp »java.lang.Integer« enthalten. Ein solcher Wertname, der in einem Referenztyp enthalten ist, wird auch als statisches Feld eines Referenztyps (hier also beispielsweise als statisches Feld von »java.lang.Integer«) oder kurz als statisches Feld (englisch “static field ”) bezeichnet.

Man sieht in »java.lang.Math.PI« also beispielsweise das statische Feld »PI« der Klasse »java.lang.Math«.

Die Bezeichnung „Feld“ kommt von Datensätzen oder Formularen, die „Felder“ enthalten, beispielsweise Felder für Vornamen, Nachnamen und so weiter. (Die Bezeichnung kommt vermutlich von dem „Feld“ der Landschaft im Sinne eines abgegrenzten Bereiches.)

Ein Formular oder Datensatz mit zwei Feldern „Vorname“ und „Nachname“

Person

Vorname: Paul
Nachname: Fischer

Eine Referenztyp mit zwei Feldern »PI« und »E«

Math

PI: 3.141592653589793
E: 2.718281828459045

Ein statisches Feld eines Referenztyps ist also ein benannter Bestandteil jenes Referenztyps, der einen bestimmten Wert enthält.

Falls keine Mißverständnisse zu befürchten sind, kann man ein solches statisches Feld auch einfach nur kurz als Feld bezeichnen.

Das Ineinanderenthaltensein der bisher vorgestellten Namen

.----------------------------------------------------------.
| java.lang                                                |
| .------------------------------------------------------. |
| | Klasse "Integer"                                     | |
| | .--------------------------------------------------. | |
| | | Feld "MAX_VALUE"                                 | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
| .------------------------------------------------------. |
| | Klasse "Long"                                        | |
| | .--------------------------------------------------. | |
| | | Feld "MAX_VALUE"                                 | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
| .------------------------------------------------------. |
| | Klasse "Math"                                        | |
| | .--------------------------------------------------. | |
| | | Feld "PI"                                        | | |
| | | Feld "E"                                         | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
'----------------------------------------------------------'

Während die Begriffe „Variable“ und „Konstante“ Wertnamen eher isoliert bezeichnet, wird bei einer Verwendung des Begriffs „Feld“ mehr die Beziehung des Wertnamens zu dem ihn enthaltenden Referenztyp hervorgehoben.

Groß- und Kleinschreibung

Eigentliche Wertnamen (wie »MAX_VALUE«) werden manchmal vollständig in Majuskeln (großen Buchstaben) geschrieben, wenn betont werden soll, daß sie „konstant“, also in einem bestimmten Zusammenhang unveränderlich, sind. Zur Trennung englischer Wörter innerhalb des eigentlichen Namens dient dann ein Grundstrich »_«.

In manchen Fällen werden die eigentlich Namen von Werten aber auch mit einem kleinen Anfangsbuchstaben geschrieben, etwa bei »tableIndexStatistic«. Dann werden eventuelle weitere englische Wörter im selben Namen mit großem Anfangsbuchstaben hervorgehoben. Diese Schreibweise wird manchmal auch Camel Case genannt.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println
    ( java.sql.DatabaseMetaData.tableIndexStatistic ); }}

transcript

Aussprachehinweis

metadata ˈmɛt ə ˌdeɪ tə

»java.sql.DatabaseMetaData« ist auch ein Beispiel für einen Referenztyp, der keine Klasse ist.

Das Ineinanderenthaltensein der bisher vorgestellten Namen

.----------------------------------------------------------.
| java.lang                                                |
| .------------------------------------------------------. |
| | Klasse "Integer"                                     | |
| | .--------------------------------------------------. | |
| | | Feld "MAX_VALUE"                                 | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
| .------------------------------------------------------. |
| | Klasse "Long"                                        | |
| | .--------------------------------------------------. | |
| | | Feld "MAX_VALUE"                                 | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
| .------------------------------------------------------. |
| | Klasse "Math"                                        | |
| | .--------------------------------------------------. | |
| | | Feld "PI"                                        | | |
| | | Feld "E"                                         | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
'----------------------------------------------------------'
.----------------------------------------------------------.
| java.sql                                                 |
| .------------------------------------------------------. |
| | Referenztyp "DatabaseMetaData"                       | |
| | .--------------------------------------------------. | |
| | | Feld "tableIndexStatistic"                       | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
'----------------------------------------------------------'

Anders als »java.lang.« darf »java.sql.« nie weggelassen werden.

Eigentliche Namen von Referenztypen

Den eigentliche Name eines Referenztyps findet man im qualifizierten Namen des Referenztyps hinter dem letzten Punkt. So ist der eigentliche Name von »java.lang.Integer« der Name »Integer«.

Eigentliche Namen von Referenztypen, wie beispielsweise »Integer«, werden in Java mit großem Anfangsbuchstaben geschrieben. Sonst wird darin Kleinschreibung verwendet. Die Anfänge englischer Wörter innerhalb eines eigentlichen Namens werden jedoch immer groß geschrieben, wie beispielsweise in »DatabaseMetaData«. Diese Schreibweise wird manchmal auch Pascal Case genannt.

Regeln zur Schreibung von Namen beziehen sich stets auf den eigentlichen Namen.

Die Typen »int« und »double« werden im Unterschied zu den Referenztypen als elementare Typen (auch: „primitive Typen“) bezeichnet und mit einem kleinen Anfangsbuchstaben geschrieben.

Das Typsystem von Java

Typen

|
.----------------'----------------.
| |

Referenztypen elementare Typen

| double
.--------------'--------------. int
| | long

Klassen andere
Arten von
java.lang.String Referenztypen
java.lang.Integer
java.lang.Math java.sql.DatabaseMetaData
java.lang.Long

Referenztypen als Ordnungssystem

Um verschiedene Wertnamen auch bei Gleichheit ihres eigentlichen Namens noch unterscheiden und übersichtlich ordnen zu können, werden die Wertnamen in verschiedene Referenztypen eingeordnet. So ist es dann beispielsweise möglich, zwischen den Feldern »java.lang.Integer.MAX_VALUE« und »java.lang.Long.MAX_VALUE« zu unterscheiden.

Man kann die Referenztypen als Schubladen ansehen, in welche Konstanten zur besseren Übersicht hineingelegt werden. Dabei werden Konstanten, die inhaltlich zusammengehören möglichst auch in einen gemeinsamen Referenztyp eingeordnet, wie beispielsweise »java.lang.Math.PI« und »java.lang.Math.E« – die Kreiszahl ‹ π › und die Eulersche Zahl ‹ e › werden beide als „mathematische“ Konstanten empfunden.

Paketnamen

Um verschiedene Referenztypen auch bei Gleichheit ihres eigentlichen Namens noch unterscheiden und übersichtlich ordnen zu können, können auch Referenztypen wiederum in verschiedene Verzeichnisse eingeordnet werden, die in diesem Fall Pakete genannt werden.

Im Falle des Referenztypnamens »java.lang.Integer« ist »Integer« der eigentliche Referenztypname, und »java.lang« ist ein Paketname (kurz auch Paket genannt).

Der qualifizierte Name »java.lang.Integer.MAX_VALUE« enthält also einen Paketnamen »java.lang«, einen Referenztypnamen »java.lang.Integer« (beziehungsweise »Integer« als eigentlichen Referenztypnamen) und schließlich einen Wertnamen »java.lang.Integer.MAX_VALUE« (beziehungsweise »MAX_VALUE« als eigentlichen Wertnamen).

Das Ineinanderenthaltensein der bisher vorgestellten Namen

.----------------------------------------------------------.
| Paket "java.lang"                                        |
| .------------------------------------------------------. |
| | Klasse "Integer"                                     | |
| | .--------------------------------------------------. | |
| | | Feld "MAX_VALUE"                                 | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
| .------------------------------------------------------. |
| | Klasse "Long"                                        | |
| | .--------------------------------------------------. | |
| | | Feld "MAX_VALUE"                                 | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
| .------------------------------------------------------. |
| | Klasse "Math"                                        | |
| | .--------------------------------------------------. | |
| | | Feld "PI"                                        | | |
| | | Feld "E"                                         | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
'----------------------------------------------------------'
.----------------------------------------------------------.
| Paket "java.sql"                                         |
| .------------------------------------------------------. |
| | Referenztyp "DatabaseMetaData"                       | |
| | .--------------------------------------------------. | |
| | | Feld "tableIndexStatistic"                       | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
'----------------------------------------------------------'

Das Paket »java.lang« enthält viele Standardreferenztypen der Programmiersprache Java, also Referenztypen, die Bestandteil der normalen Ausgabe von Java sind.

Die Namen von Paketen (wie »java.lang«) können auch Punkte enthalten, sie werden mit kleinen Anfangsbuchstaben geschrieben und enthalten meist gar keine großen Buchstaben.

In dem hier behandelten Rahmen kann ein Paketname, wie »java.lang«, nicht weiter zerlegt werden, obwohl der enthaltene Punkt ».« eine weitere Unterteilung nahelegt. Dieser Punkt dient hier aber nur zur optischen Trennung zweier Wörter.

Es gibt in Java SE beispielsweise einen Referenztyp »java.awt.List« und einen Referenztyp »java.util.List«. Diese könnten ohne den davorstehenden Paketnamen nicht unterschieden werden.

Java

java.lang.Math

auf deutsch

„die Klasse »Math« aus dem Paket »java.lang«“

Vollständig qualifizierte Namen

Namen, die mit einem Paketnamen beginnen, wie »java.lang.Integer.MAX_VALUE« sind vollständig bestimmt : noch genauer können sie nicht geschrieben werden (man kann keinen weiteren einfachen Namen davor setzen).

Name, die mit einem Paketnamen beginnen, werden deswegen werden sie auch als vollständig qualifizierte Namen oder als maximal qualifizierte Namen bezeichnet. Ein vollständig qualifizierter Name ist ein Name, vor den keine weiteren Qualifikation mehr hinzugefügt werden können (um ihn noch näher zu bestimmen).

Namen, die nicht vollständig qualifiziert wird, können von dem Ort ihrer Verwendung abhängen und werden daher hier auch relative Namen genannt.

Einen Namen, der qualifiziert, aber nicht vollständig qualifiziert ist, nennen wir auch einen einfach qualifizierten Namen.

Namen

maximal qualifizierter Name    qualifizierter Name     Eigentlicher Name  Gattung  Ausdruck?
(vollst. qualifizierter Name)  einfach qualifizierter  (Bezeichner)            
(qualifizierter Name)            Name
 
java.lang.Integer.MAX_VALUE    Integer.MAX_VALUE       MAX_VALUE          Feld     Ausdruck
java.lang.Long.MAX_VALUE       Long.MAX_VALUE          MAX_VALUE          Feld     Ausdruck
java.lang.Math.PI              Math.PI                 PI                 Feld     Ausdruck
java.lang.Math.E               Math.E                  E                  Feld     Ausdruck
 
java.lang.Integer                                      Integer            Typ      kein Ausdruck
java.lang.Long                                         Long               Typ      kein Ausdruck
java.lang.Math                                         Math               Typ      kein Ausdruck
 
java.lang                                                                 Paket    kein Ausdruck

»java.lang.Integer« ist also der vollständig qualifizierte Name des Referenztyps »Integer« aus dem Paket »java.lang«.

»java.lang.Integer.MAX_VALUE« ist der vollständig qualifizierte Name des Feldes »MAX_VALUE« aus der Klasse »java.lang.Integer«.

In vielen Fällen kann in einem Java -Programm ein einfacher oder ein einfach qualifizierter Name an Stelle eines vollständig qualifizierten Namens geschrieben werden. Im Zweifelsfall ist ein vollständig qualifizierter Name aber nie verkehrt.

»String« statt »java.lang.String« geschrieben werden. Man kann dies mit einem Namen wie „Prof. Dr. Fritz Müller“ vergleichen – wenn keine Verwechslungen mit einem anderen „Fritz Müller“ zu befürchten sind, reicht es den eigentlichen Namen „Fritz Müller“ zu verwenden.

Vergleich mit Ortsangaben ⃗

Man kann einen vollständig qualifizierten Namen mit der Angabe eines Ortes vergleichen, bei der zuerst ein Land, dann eine Stadt und dann eine Sache aus der Stadt genannt wird.

Java

java.lang -> Math -> PI

Ortsangabe

Bundesrepublik Deutschland -> Berlin -> Hauptstraße

Man stellt sich vor, daß die Klasse »Math« im Paket »java.lang« enthalten ist, so wie die Stadt „Berlin“ im Land „Bundesrepublik Deutschland“ enthalten ist.

Die Angabe des Landes ist in der Regel nötig, da es in anderen Ländern ebenfalls Orte names „Berlin“ gibt. Genauso könnte es in anderen Paketen auch andere Referenztypen mit dem Namen »Math« geben.

Das Ineinanderenthaltensein von Gebieten in der Geographie

.----------------------------------------------------------.
| Land "Bundesrepublik Deutschland"                        |
| .------------------------------------------------------. |
| | Ort "Berlin"                                         | |
| | .--------------------------------------------------. | |
| | | Strasse "Hauptstrasse"                           | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
| .------------------------------------------------------. |
| | Ort "Gelsenkirchen"                                  | |
| | .--------------------------------------------------. | |
| | | Strasse "Hauptstrasse"                           | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
| .------------------------------------------------------. |
| | Ort "Heidelberg"                                     | |
| | .--------------------------------------------------. | |
| | | Strasse "Maulbeerweg"                            | | |
| | | Strasse "Tischbeinstraße"                        | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
'----------------------------------------------------------'
.----------------------------------------------------------.
| Land "Vereinigte Staaten von Amerika"                    |
| .------------------------------------------------------. |
| | Ort "Memphis"                                        | |
| | .--------------------------------------------------. | |
| | | Strasse "Beale Street"                           | | |
| | '--------------------------------------------------' | |
| '------------------------------------------------------' |
'----------------------------------------------------------'

Aussprachehinweis

Beale biːl

Eindeutigkeit ⃗

In einer einem Land könnte es verschiedene Städte mit dem gleichen Namen geben. In einer Stadt könnte es verschiedene Straßen mit dem gleichen Namen geben. Daher ist eine Angabe aus einem Land, einer Stadt und einer Straße nicht unbedingt immer eine eindeutige Angabe einer bestimmten Straße.

In Java darf es in einem Paket jedoch nicht mehrere verschiedene Typen mit dem gleichen Namen geben. Außerdem darf eine Typ auch nicht mehrere verschiedene Felder mit dem gleichen Namen enthalten. Daher ist eine maximal qualifizierte Angabe eines Pakets, Typs oder Feldes in Java immer eindeutig.

Ausdrücke ⃗

Typnamen sind keine Ausdrücke! Während also beispielsweise »java.lang.Integer.MAX_VALUE« ein Ausdruck ist, ist »java.lang.Integer« kein Ausdruck. Man kann »java.lang.Integer« lediglich als einen Namen oder als eine Angabe bezeichnen.

Das folgende Programm zeigt, daß Namen von Klassen nicht als Ausdruck gelten.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println
    ( java.lang.Math ); }}

transcript (übersetzt)

Main.java:4: Fehler: Symbol nicht gefunden
    ( java.lang.Math ); }}
          ^
  Symbol: Klasse lang
  Ort:    Paket java
1 Fehler

Paketnamen sind ebenfalls keine Ausdrücke! Während also beispielsweise »java.lang.Integer.MAX_VALUE« ein Ausdruck ist, ist »java.lang« kein Ausdruck. Man kann »java.lang« lediglich als einen Namen oder als eine Angabe bezeichnen.

Das folgende Programm zeigt, daß Namen von Klassen nicht als Ausdruck gelten.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println
    ( java.lang ); }}

transcript (übersetzt)

Main.java:4: Fehler: Symbol nicht gefunden
    ( java.lang ); }}
      ^
  Symbol: Variable java
  Ort:    Klasse Main
1 Fehler

Feldnamen sind hingegen auch Ausdrücke und können deshalb als Operatoren verwendet oder in den Ausdruckrahmen eingesetzt werden.

Es sind also nicht alle Namen auch Ausdrücke.

Symbole ⃗

Etwas, das einen bestimmmten Eintrag einer Klasse identifiziert, wie etwas „die Variable »Xi«“ wird in Fehlermeldungen (des JDK von 2017) auch als ein Symbol bezeichnet.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println
    ( java.lang.Math.Xi ); }}

Konsole (übersetzt)

Main.java:3: Fehler: Symbol kann nicht gefunden werden
  { java.lang.System.out.println
    ( java.lang.Math.Xi ); }}
                    ^
  Symbol: Variable Xi
  Ort:    Klasse Math
1 Fehler

Die Fehlermeldung besagt, daß die Implementation in der Klasse »Math« nach dem Symbol „Variable »Xi«“ gesucht hat, aber in dieser Klasse solch ein Symbol, also eine Variable namens »Xi«, nicht gefunden hat.

Gründe für die maximale Qualifikation ⃗

Ein Name wie »java.lang.Integer« kann oft ohne Qualifikation als »Integer« verwendet werden.

Es ist aber möglich, daß ein Programmteil in ein anderes Programm kopiert wird, in dem es dann nötig ist, eine Qualifikation voranzustellen. Dies kann sich auch ergeben, wenn ein Programm oder darin verwendete Bibliotheken im Laufe der Zeit verändert werden.

Ein relativer Name wie »Integer« bezieht sich also nicht immer auf die Klasse »java.lang.Integer«, seine Bedeutung hängt von der Umgebung ab, in der er sich befindet.

Insofern ist ein Programmfragment mit einem relativen Namen wie »Integer« nicht robust, denn »Integer« bedeutet „die nächste erreichbare Klasse namens »Integer«“, dies muß nicht unbedingt »java.lang.Integer« sein. So ein Programmfragment mag oft funktionieren, aber dies ist nicht garantiert, wenn es verpflanzt wird.

Wenn man immer maximal qualifizierte Namen verwendet, so kann man sie ohne weiteres immer in anderen Programme kopieren, ohne sich erst lange Gedanken machen zu müssen, ob die Qualifikation dort vielleicht hinzugefügt werden muß.

In größeren Programmen liest man machmal plötzlich einen Namen wie »multiplier« und weiß nicht, „woher“ er kommt. Die Qualifikation kann auch die Lesbarkeit von Programmteilen verbessern, denn man kann einem Namen so direkt ansehen aus welchem Referenztyp und aus welchem Paket er kommt.

Übungsfragen _

? Benanntes _

Wofür stehen die folgenden Namen jeweils? (Referenztyp, Wert oder Paket?)

»java.lang«
»java.lang.Integer«
»java.lang.Integer.MAX_VALUE«

? Enthaltensein _

Was kann man aus der Schreibweise »alpha.gamma« in Java normalerweise entnehmen?

»alpha« ist in »gamma« enthalten
»gamma« ist in »alpha« enthalten
keiner der obigen Antwortvorschläge trifft zu

? Ausdrücke _

Welcher der folgenden Texte ist ein Ausdruck?

o »java.lang.Integer«
o »java.lang.Integer.MAX_VALUE«

? Namen _

Welcher der folgenden Namen ist einfach (also ein Bezeichner), welcher qualifiziert und welcher vollständig qualifiziert?

»java.lang.Integer.MAX_VALUE«
»MAX_VALUE«
»Integer.MAX_VALUE«

? Eigentliche Namen _

Was ist der eigentliche Name des Referenztyps »java.lang.Integer«?

Was ist der eigentliche Name des Namens »java.lang.Integer.MAX_VALUE«?

Quellenangabe *

Das folgende Zitate gibt noch eine Quelle zum Thema der Schreibung von Bezeichnern mit Majuskeln (wie bei »MAX_VALUE«) für interessierte Leser an.

JLS7, 6 Names, 6.1 Declaration, Constant Names: The names of constants in interface types should be, and final variables of class types may conventionally be, a sequence of one or more words, acronyms, or abbreviations, all uppercase, with components separated by underscore "_" characters.
JLS7, 6 Namen, 6.1 Deklarationen, Konstantennamen (Übersetzung): Die Namen von Konstanten in Schnittstellentypen sollten eine Folge von einem Wort oder mehreren Wörtern, Akronymen oder Abkürzungen sein, vollständig mit Großbuchstaben geschrieben, wobei die Komponenten durch einen Grundstrich getrennt sind. Die Namen von final-Variablen in Klassen dürfen per Konvention so geschrieben werden.

Die Bedeutung qualifizierter Namen in Java

Qualifizieren

Die Bedeutung des Punktes ».«

»java.lang.Long.MAX_VALUE«

Berichtstypen für elementare Typen

Das Ineinanderenthaltensein der bisher vorgestellten Namen

»java.lang.Math.E«

Eigentliche Namen

Referenztypen

Klassen

Bezeichnungen für Namen, die als Ausdrücke verwendet werden können

Wertnamen

Konstanten

Variablen

Felder

Groß- und Kleinschreibung

Eigentliche Namen von Referenztypen

Referenztypen als Ordnungssystem

Paketnamen

Vollständig qualifizierte Namen

Vergleich mit Ortsangaben ⃗

Eindeutigkeit ⃗

Ausdrücke ⃗

Symbole ⃗

Gründe für die maximale Qualifikation ⃗

Übungsfragen _

? Benanntes _

? Enthaltensein _

? Ausdrücke _

? Namen _

? Eigentliche Namen _

Quellenangabe *

Die Bedeutung des Punktes »`.`«

»`java.lang.Long.MAX_VALUE`«

»`java.lang.Math.E`«