Aufrufe statischer Methoden in Java

Diese Lektion soll an Hand der schon bekannten Aufrufe statischer Methoden einige Begriffe einführen, die wir etwas später bei der Behandlung neuer Themen einsetzen werden.

Verben

Der eigentliche Name einer Methode wird hier auch als Verb jener Methoden bezeichnet.

Beispielsweise ist das Verb der Methode »java.lang.Math.random()« der Bezeichner »random«.

Verbaufrufe

Wir erinnern hier an die Produktionsregel eines Aufrufs.

Aufruf (Syntaxdiagramm)

Aufruf
    .-------.     .-.     .---------------.     .-.    
--->| Name  |--->( ( )--->| Ausdruckliste |--->( ) )--->
    '-------'     '-'     '---------------'     '-'
Ausdruckliste
   .---------------------------.            
   |        .----------.       v
---'---.--->| Ausdruck |---.---'--->
       ^    '----------'   |
       |        .-.        |
       '-------( , )<------'
                '-'

Zusätzliche Anforderungen: Der »Name« muß der Name einer Methode sein.

Ein Verbaufruf ist ein Aufruf, welcher mit einem Verb beginnt, also der folgenden Produktionsregel genügt.

Verbaufruf (Syntaxdiagramm)

Verbaufruf
    .------------.     .-.     .---------------.     .-.    
--->| Bezeichner |--->( ( )--->| Ausdruckliste |--->( ) )--->
    '------------'     '-'     '---------------'     '-'

Dabei ist es entscheidend, daß bei einem Verbaufruf vor der Klammer auf »(« nur ein Bezeichner, aber kein Name, steht. Ein Bezeicher darf – im Gegensatz zu einem Namen – keine Punkte enthalten.

Beispiel für einen Verbaufruf

random()

Beispiel für einen Aufruf, der aber kein Verbaufruf ist

java.lang.Math.random()

Jeder Aufruf endet mit einem Verbaufruf.

Aufrufe mit Typnamen

Ein Verbaufruf alleine ist in manchen Fällen noch zu unbestimmt für eine Auswertung.

Er benötigt dann unter Umständen noch einen mit einem Punkte abgetrennten Typnamen vor dem Verbaufruf. Der Aufruf »java.lang.Thread.dumpStack()« enthält beispielsweise den Typnamen »java.lang.Thread« und den Verbaufruf »dumpStack()«.

Aufruf einer statischen Methode mit Typnamen (Syntaxdiagramm) ::=

    .---------.     .---.     .------------.
--->| Typname |--->(  .  )--->| Verbaufruf |--->
    '---------'     '---'     '------------'

Beispiel eines Aufrufs mit Typnamen

java.lang.Thread . dumpStack()

Kontexte

Eine mit einem Punkt abgetrennte Angabe in einem Aufruf, die vor einem Verbaufruf steht, wird vom Java -Compiler auch Kontext genannt. (Nach dem Kontext im Sinne eines „umgebenden“ Textes, der die Bedeutung eines Textes eingrenzen kann.)

Einen Aufruf, der einen mit einem Punkt ».« abgetrennten Typnamen vor dem Verb (dem einfachen Namen der Methode) enthält, nennen wir auch einen Aufruf mit Kontext. Ein Aufruf mit Kontext enthält also Punkte in dem Namen vor der Klammer, wie etwa bei dem Aufruf »java.lang.Thread.dumpStack()«. Ein komplexer Aufruf ist ein Teil des Quelltexts.

Aufruf einer statischen Methode (Syntaxdiagramm) ::=

    .---------.     .---.     .------------.
--->| Kontext |--->(  .  )--->| Verbaufruf |--->
    '---------'     '---'     '------------'

Beispiel eines Aufrufs mit Kontext

java.lang.Thread . dumpStack()

Der Aufruf »java.lang.Thread.dumpStack()« enthält beispielsweise den Kontext »java.lang.Thread« und den Verbaufruf »dumpStack()«.

Den Punkt zwischen Kontext und Verbaufruf, nennen wir hier auch Kontextpunkt. Es handelt sich beim Kontextpunkt stets um den letzten Punkt vor der Klammer eines Aufrufs mit Kontext.

Man sagt auch, daß der Verbaufruf mit dem angegebenen Kontext oder in dem angegebenen Kontext erfolge. Beispielsweise wird in dem obigen Beispiel »dumpStack()« im Kontext »java.lang.Thread« aufgerufen.

Man sagt auch, daß mit dem obigen Aufruf die Methode »dumpStack()« aus dem Typ »java.lang.Thread« aufgerufen werde. Ein Kontext ist ein Teil des Quelltexts.

Enthaltensein

Wenn ein Verbaufruf in einem bestimmten Kontext möglich ist (also ohne Fehlermeldung kompiliert und ausgeführt wird), dann sagen wir, daß dieser Kontext eine zum Aufruf passende Methode enthalte.

? Der Kontext enthält eine zum Aufruf passende Methode

java.lang.Thread . dumpStack()

? Der Kontext enthält keine zum Aufruf passende Methode

java.lang.Math . dumpStack()

Eine Typ als Kontext enthält eine zu einem Verbaufruf passende Methode dann, wenn es eine statische Methode in diesem Typ gibt, die zu dem Aufruf paßt.

In der Dokumentation des Typs »java.lang.Thread« findet man beispielsweise eine zum Verbaufruf »dumpStack()« passende Methode.

Dokumentation von »java.lang.Math.random()« (gekürzt, vereinfacht und übersetzt)

Modul java.base

Packet java.lang

Klasse Thread

Methodenzusammenfassung

static void dumpStack()

Druckt einen Stapelbericht für das laufende Programm.

In der Dokumentation des Typs »java.lang.Math« findet man aber keine zum Verbaufruf »dumpStack()« passende Methode. Daher enthält der Kontext »java.lang.Math« keine zum Verbaufruf »dumpStack()« passende Methode.

Beispiele für Aufrufe statischer Methoden

Die folgende Tabelle zeigt einige Beispiele für Aufrufe statischer Methoden.

Tabelle

Kontext            Kontextpunkt   Verbaufruf
java.lang.Thread   .              dumpStack()
java.lang.Math     .              random()

Die Frage, ob ein Kontext eine Methode enthält, die einen bestimmten Verbaufruf ermöglicht, kann durch Lesen der Dokumentation und des Quelltexts beantwortet werden.

Zusammenfassung

Ein Aufruf mit Kontext, der eine statischen Methode aufruft, wie »java.lang.Math.pow( 2.0, 3.0 )« besteht aus einem Kontexttyp, wie »java.lang.Math«, und einem Verbaufruf, wie »pow( 2.0, 3.0 )«, zu dem es im Kontexttyp eine passende Methode gibt.

Übungsfragen

? Bestandteile von Aufrufen

Was ist der Verbaufruf im Aufruf »java.lang.Math.random()«?

Was ist der Kontext im Aufruf »java.lang.Math.random()«?

? Enthaltensein von Methoden

Zu welchen der folgenden Verbaufrufe gibt es im Kontext »java.lang.Math« passende Methoden?

»rand()«
»random()«
»random( 6 )«

Übungsaufgaben

/ Aufrufe mit Kontext

Schreiben Sie einen Aufruf mit dem Kontext »java.lang.Math« und dem Verbaufruf »rint( 2 )«. (Der Aufruf sollte höchstens 24 Zeichen benötigen.)

Anmerkungen und Zitate *

Syntax eines Aufrufs einer statischen Methode *

Zitate aus der JLS, leicht umgestellt und vereinfacht:
Aufruf einer statischen Methode ::=
〈MethodInvocation 〉 ::=: 〈TypeName 〉 "." 〈Identifier 〉 "(" [〈ArgumentList 〉] ")".

Herkunft des Begriffes „Kontext“ *

Der Begriff „Kontext“ wird 2012 vom Standard-Java -Compiler aus dem JDK selber verwendet:

Main.java

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

Konsole

javac Main.java

Main.java:3: error: non-static method println() cannot be referenced from a static context
  { java.io.PrintStream.println(); }}
                       ^
1 error

(Main.java:3: Fehler: nicht-statische Methode println() kann nicht von statischem Kontext aus referenziert werden.)

Compiler-Fehlermeldung, 2012