Ergänzungen zu Argumenten in Java 

Aussprache eines Aufrufausdrucks

Die runde Klammer auf »(« wird im Deutschen (in der Mathematik) bei Verwendung der Funktionsschreibweise meist als „von“ gesprochen. So ist »java.lang.Math.negateExact( 3 )« „Negate  von  Drei“ oder „das Negative von  Drei“ (Man kann den langen Namen »java.lang.Math.negateExact« beim Aussprechen ruhig mit “negate ” oder etwas Ähnlichem abkürzen, solange dadurch keine Mißverständnisse zu befürchten sind). Den Ausdruck »java.lang.Math.cos( 0 )« kann man beispielsweise als „Kosinus von Null“ aussprechen.

Ausführlicher nennt man »java.lang.Math.cos( 0 )« „der Aufruf der Methode »cos« mit dem Argument(wert) »0«“.

In manchen Fällen kann man »cos( 0 )« auch einfach „Kosinus Null“ sprechen, etwa wenn der Ausdruck als untergeordnet markiert werden soll: »log( cos( 0 )+ sin( 0 ))« „Logarithmus von  Kosinus Null plus Sinus Null“.

Man kann sich den Aufruf »java.lang.Math.negateExact( 3 )« auch als Frage veranschaulichen: „Was ist das Negative von »3«?“ – er antwortet dann mit »-3«.

Wenn eine Methode mit einem Argument zusammen aufgerufen wird, dann sagt man auch, daß die Methode auf dieses Argument angewendet werde. Man nennt »java.lang.Math.negateExact( 3 )« also beispielsweise „die Anwendung  der Methode »java.lang.Math.negateExact« auf den Wert »3«“. Damit kann sowohl der Ausdruck »java.lang.Math.negateExact( 3 )« als auch dessen Auswertung gemeint sein.

Java 

java.lang.Math.cos( 0 )

auf deutsch:

● „der Wert des Aufrufs der Methode »java.lang.Math.cos« mit dem Argumentausdruck Null“

● „»java.lang.Math.cos« von Null“

● „der Kosinus von Null“

● „der Wert, den die Methode »java.lang.Math.cos« für den Wert Null ergibt“

● „der Wert der Methode »java.lang.Math.cos« an der Stelle Null“

● „der Wert, der sich ergibt, wenn die Methode »java.lang.Math.cos« mit Null aufgerufen wird“

Zur Schreibweise von „Kosinus“

● Der Duden von 1954 kennt nur „cos“ (als „Zeichen“ des Kosinus) und „Kosinus“, aber nicht „Cosinus“.

● Ein sechsbändiger Duden von 1977 hat nur einen Eintrag für „Kosinus“, der „cos“, aber nicht „Cosinus“, erwähnt.

● Eine aktuelle Duden-Ausgabe (2018) hat nur einen Eintrag für „Kosinus“, in dem aber „Cosinus“ erwähnt wird.

● Das „Taschenbuch der Mathematik“ (Bronstein, Semendjajew, Musiol, Mühlig) von 2005 schreibt immer „Kosinus“.

Daher kann man „Kosinus“ wohl als die traditionelle Schreibweise und als die Standardschreibweise dieses Begriffs ansehen.

Die Schreibweise „Cosinus“ wird im aktuellen Duden (2018) als „fachsprachlich“ bezeichnet. Tatsächlich findet sich die Schreibweise „Cosinus“ auch in einigen mathematischen Texten, aber auch in der zeitgenössischen mathematischen Fachliteratur wird oft (vermutlich: meistens) „Kosinus“ geschrieben.

Bedeutung eines Argumentwertes

Die Bedeutung  eines bestimmten Argumentwertes für die Auswertung des Aufrufausdrucks wird durch die aufgerufene Methode beziehungsweise ihre Dokumentation jeweils individuell festgelegt.

Erklärung zur Bedeutung von Ausdrücken *

Wir hatten Ausdrücke bereits als Quelltexte kennengelernt, welche man in den Ausdruckrahmen  einsetzen kann. Danach konnten wir Ausdrücke auch als das charakterisieren, was man als Operand  eines Operators schreiben kann. Nun können wir Ausdrücke auch noch dadurch charakterisieren, daß sie als Argumente  in Aufrufausdrücken verwendet werden können. Wenn man Argumente aber auch als eine Art von Operanden ansieht, dann ist es nicht nötig, sie ausdrücklich zu erwähnen, und wir können dann weiterhin einfach sagen: „Ein Ausdruck  ist etwas, das in den Ausdruckrahmen eingesetzt werden oder als Operand verwendet werden kann.“

Deterministische Methoden *

Eine Methode, welche man mit einem Argument aufrufen kann, und welche einen Wert als Ergebnis liefert, der durch diese Methode und einen eventuellen Argumentwert bestimmt ist, nennt man auch eine deterministische Methode.

»java.lang.Math.negateExact« ist ein Beispiel für eine deterministische Methode, weil sich bei gleichem Aufruf auch der gleicher Wert ergibt, während die Methoden »java.lang.Math.random« nicht  deterministisch ist, da sie auch bei gleicher Schreibweise des Aufrufs unterschiedliche Werte liefern kann.

Deterministische Methoden, die mit einem Argument aufgerufen werden, ähneln den Funktionen (Abbildungen) der Mathematik, während nicht-deterministische Methode in der Schulmathematik keine Entsprechung haben.

Übergabe des Argumentwerts **

Man kann sich den Sinn  eines Arguments auch so erklären: Die Methode »java.lang.Math.negateExact« benötigt noch Informationen, um ihre Arbeit tun zu können, und diese Informationen werden durch den Wert des Arguments geliefert. Das Argument enthält die Information, welche die Methode verarbeiten soll.

Da beim Aufruf einer Methode der Wert des Argumentausdrucks zur Laufzeit zusammen mit der Kontrolle (über den Computer) an die aufgerufene Methode übergeben wird, spricht man auch von der Übergabe  des Argumentwertes oder sagt, der Argumentwert werde an die aufgerufene Methode übergeben.

Hauptprogramm und »negateExact«

Hauptprogramm
      |
      |
      |        Übergabe der Kontrolle       
      |           und des Wertes 3          
      '------------------.
                         | 
                         V 
                 .---------------.
                 | negateExact   |
                 '---------------'
                         |
                         |
      .<-----------------'
      |        Rueckgabe der Kontrolle      
      |          und des Wertes -3          
      |
      v
Hauptprogramm

Das folgende Diagramm stellt dieselbe Situation mit etwas allgemeineren Begriffen vor.

Übergabe und Rückgabe der Kontrolle zur Laufzeit

Hauptprogramm
      |
      |
      |   Übergabe der Kontrolle   Vergleich: Der Kapitän übergibt Steuer
      |   und des Argumentwertes   und Zielinformation an den ersten Offizier.
      '-------------.
                    | 
                    V 
            .---------------.
            | Unterprogramm |
            '---------------'
                    |
                    |
      .<------------'
      |   Rueckgabe der Kontrolle   Vergleich: Der erste Offizier gibt das 
      |   und des Ergebniswertes    Steuer zurück und eine Bericht zurueck.
      |
      v
Hauptprogramm

Ein- und Ausgang bei Methoden **

Man kann eine Methode wie »java.lang.Math.negateExact« auch mit einer Backmaschine vergleichen, bei der man – vereinfacht gesagt – Mehl hinein gibt und Brot heraus bekommt: bei »java.lang.Math.negateExact« gibt man eine Zahl hinein und bekommt die negative Zahl heraus.

Insofern kann man eine Methode wie ein Maschine sehen, in die eine Information eingegeben werden kann, und die dann eine andere Information dazu ausgibt. Wenn beispielsweise die Zahl »3« in die Methode »java.lang.Math.negateExact« hineingeht, so kommt beim Ausgang die Zahl »-3« heraus.

»java.lang.Math.negateExact« als Maschine mit einem Eingang und einem Ausgang

   "Eingang"                                 "Ausgang"
             .----------------------------.
      3 ---> | java.lang.Math.negateExact |---> -3
             '----------------------------'
   Übergabe                                   Rückgabe

Operanden und Argumente ***

Man kann den Argumentausdruck auch als den Operanden  des Aufrufs ansehen und den Rest (also den Methodennamen und die runden Klammern) als einen unären Zirkumfixoperator. Diese Sichtweise ist aber unüblich, zumal der Operator dann auch oft aus relative vielen einzelnen lexikalischen Einheiten bestünde. Trotzdem gilt alles, was wir hier über Operanden  sagen im Regelfall auch für Argumente. Daher ist es im allgemeinen eine Vereinfachung, wenn man ein Argument als eine Art von Operand ansieht, damit man nicht immer von „Operanden und Argumenten “ sprechen muß.

Ein Aufrufausdruck zerlegt in Operator und Operanden

                         Operand
                            |
                            v
java.lang.Math.negateExact( 3 )
---------------------------   -
            ^                 ^
            '-----------------'
                     |
                  Operator