Ergänzungen zur Zuweisung in Java  ⃗

Zuweisungen in inneren Blöcken ⃗

Wirkungen werden nicht  auf Blöcke eingeschränkt. Die Wirkung einer Zuweisung in einem Block besteht also auch über das Ende des Blockes hinaus fort.

Main.java

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

transcript

7

Die Assoziativität der Zuweisung ⃗

Die Zuweisung ist rechtsassoziativ. Der Ausdruck »a = b = c« bedeutet also »a =( b = c )«.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { int a = 2; 
    int b = 3; 
    int c = 7; 
    java.lang.System.out.println( a = b = c );
    java.lang.System.out.println( a );
    java.lang.System.out.println( b );
    java.lang.System.out.println( c ); }}

transcript

7
7
7
7

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { int a = 2; 
    int b = 3; 
    int c = 7; 
    java.lang.System.out.println( a =( b = c )); 
    java.lang.System.out.println( a );
    java.lang.System.out.println( b );
    java.lang.System.out.println( c ); }}

transcript

7
7
7
7

Alle anderen bisher vorgestellten binären Operatoren sind linksassoziativ. Der Ausdruck »a + b + c« bedeutet beispielsweise »( a + b )+ c«.

Priorität und Assoziativität der bisher behandelten Operatoren

   ()                   Eingeklammerter Ausdruck
   +  -                 Unaere vorangestellte Operatoren
L  *  /                 Multiplikation, Division
L  +  -                 Addition, Subtraktion
R  =                    Zuweisung

Anwendungsbeispiel ⃗

Warum hat eine Zuweisung auch einen Wert?

Eine der häufigsten Anwendungen des Wertes einer Zuweisung sind Anweisungen wie »a = b = 0;«, mit denen mehrere Variablen mit einer einzigen Anweisung auf »0« gesetzt werden.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { int a = 7; int b = 2;
    java.lang.System.out.println( a ); 
    java.lang.System.out.println( b );
    a = b = 0;
    java.lang.System.out.println( a );
    java.lang.System.out.println( b ); }}

Protokoll

7
2
0
0

Wir wissen jetzt, daß »a = b = 0;« als »a =( b = 0 );« zu lesen ist, und daß der Wert von »( b = 0 )« gleich »0« ist. Die Auswertung von »a = b = 0« setzt also zuerst »b« und dann »a« auf »0«.

Die Syntax der Zuweisung ⃗

Der Zuweisungsoperator »=« ist ein binärer Infixoperator.

Die Zuweisung hat den folgenden Aufbau.

Syntax

Zuweisung
    .------.     .-.    .----------.
--->| Name |--->( = )-->| Ausdruck |--->
    '------'     '-'    '----------'

Zuweisungsausdruck (Beispiel)

a = 7

Neue, erweiterte Syntax (vereinfacht)

Ausdruck
                 .----------.
---.------------>| Literal  |-----------------------------.---->
   |             '----------'                             |
   |             .----------.                             |
   '------------>| Name     |-----------------------------'
   |             '----------'                             |
   |     .-.     .----------.                             |
   '--->( - )--->| Ausdruck |-----------------------------'
   |     '-'     '----------'                             |
   |     .-.     .----------.                             |
   '--->( + )--->| Ausdruck |-----------------------------'
   |     '-'     '----------'                             |
   |     .-.     .----------.     .-.                     |
   '--->( ( )--->| Ausdruck |--->( ) )--------------------'
   |     '-'     '----------'     '-'                     |
   |             .----------.     .-.     .----------.    |
   '------------>| Ausdruck |--->( / )--->| Ausdruck |----'
   |             '----------'     '-'     '----------'    |
   |             .----------.     .-.     .----------.    |
   '------------>| Ausdruck |--->( + )--->| Ausdruck |----'
   |             '----------'     '-'     '----------'    |
   |             .----------.     .-.     .----------.    |
   '------------>| Ausdruck |--->( - )--->| Ausdruck |----'
   |             '----------'     '-'     '----------'    |
   |             .----------.     .-.     .----------.    |
   '------------>| Ausdruck |--->( * )--->| Ausdruck |----'
   |             '----------'     '-'     '----------'    |
   |             .----------.     .-.     .----------.    |
   '------------>| Name     |--->( = )--->| Ausdruck |----'
   |             '----------'     '-'     '----------'    |
   |             .----------.                             |
   '------------>| Aufruf   |-----------------------------'
                 '----------'
Name
   .-----------------------.
   |    .------.    .-.    v    .------------. 
---'--->| Name |-->( . )---'--->| Bezeichner |--->
        '------'    '-'         '------------'
Aufruf
    .-------.     .-.     .---------------.     .-.    
--->| Name  |--->( ( )--->| Ausdruckliste |--->( ) )--->
    '-------'     '-'     '---------------'     '-'
Ausdruckliste
   .---------------------------.            
   |        .----------.       v
---'---.--->| Ausdruck |---.---'--->
       ^    '----------'   |
       |        .-.        |
       '-------( , )<------'
                '-'

Die Quelltextsemantik der Zuweisung ⃗

Der Typ einer Zuweisung ist der Typ ihrer linken Seite (vor dem Gleichheitszeichen »=«).

Die Laufzeitsemantik der Zuweisung ⃗

Eine Blockvariable wird als Speicher für einen Wert ihres Typs angesehen, das heißt, daß sie zu jedem Zeitpunkt genau einen Wert ihres Datentyps haben kann. Man kann sagen, daß eine Zuweisungsoperation einen neuen Wert in eine Blockvariable schreibt  oder kopiert.

Bei der Zuweisung wird der Ausdruck auf der rechten Seite  des Gleichheitszeichens »=« ausgewertet. Der erhaltene Wert wird in den Typ der Variablen auf der linken Seite gewandelt  und dann in diese Variable geschrieben. Der Wert der gesamten Zuweisung  ist der Wert der Variablen nach dieser Schreiboperation.

Eine Information über den vorherigen Wert einer Variable kann dieser nach einer Schreiboperation nicht  mehr entnommen werden, der vorherige Wert ist also unwiderruflich verlorengegangen, er wurde also durch den neuen Wert überschrieben (gelöscht).

Steht der Name einer Variablen auf der linken Seite einer Zuweisung, so wird also in die Variable geschrieben. Wenn eine Variable ansonsten in einem Ausdruck verwendet wird, dann wird sie ausgelesen, um den Wert ihres Namens zu erhalten.

Ein Name steht auf der rechten Seite  einer Zuweisung (und in fast allen anderen Fällen) also für seinen Wert, auf der linken  Seite aber für seine Variable  (den Speicherplatz).

Der Anfangswert einer Variablen kann zunächst in der Deklaration der Blockvariablen festgelegt werden (wie bei einer final-Blockvariablen).

Mit einer Zuweisung kann der Wert einer Variablen während des Ablaufs eines Programms beliebig oft verändert werden.

Die Operationen einer Variablen ⃗

Wir haben bisher schon Operatoroperationen und Methodenoperation kennengelernt.

Mit der Einführung von Variablen kommen nun noch zwei Variablenoperationen hinzu: Das Lesen aus einer Variablen und das Schreiben in eine Variable.

Betrachten wir etwa die Zuweisung »v = java.lang.Math.round( v / 2 )« für eine double-Variable »v« mit dem Wert »7«, so erkennen wird vier zeitlich aufeinanderfolgende Operationen

Operationen

Vorzustand: »v« hat den Wert »7«

v = java.lang.Math.round( v / 2 )

1. Operation: Auslesen des Wertes aus »v«

v = java.lang.Math.round( 7 / 2 )

2. Operation: Division »7 / 2«

v = java.lang.Math.round( 3.5 )

3. Operation: »java.lang.Math.round( 3.5 )«

v = 4.0

4. Operation: Schreiben des Wertes »4.0« nach »v«

Nachzustand: »v« hat den Wert »4.0«.

Abgrenzung zur Initialisierung *

Die Festlegung des ersten Wertes einer Blockvariablen innerhalb ihrer Deklaration wird oft Initialisierung  dieser Blockvariablen genannt. Entsprechend nennt man den Ausdruck rechts vom Gleichheitszeichen auch den Initialisierungsausdruck  und seinen Wert den Initialisierungswert.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { int v = 2;
    final int k = 7;
    java.lang.System.out.println( v );
    java.lang.System.out.println( k );  }}

transcript

2
7

Laut der JLS  erfolgt dabei ebenfalls eine Zuweisung, es handelt sich aber bei einer Schreibweise mit einem Gleichheitszeichen innnerhalb einer Deklaration nicht  um eine Anwendung des Zuweisungsoperators, denn hier gilt nicht die Syntaxregel für diesen Operator, sondern die Syntaxregel für Variablendeklarationen. In der Deklaration »int v = 2;« ist »v = 2« daher kein Ausdruck, bewirkt aber auch eine Zuweisung.

Übungsfragen ⃗

?   Zuweisung ⃗

Was gibt das folgende Programm aus?

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { double v = 2.0;
    int w = 4;
    java.lang.System.out.println( 1/( v = w = 2 )); }}

Zitate zur Zuweisung *

“At run-time, the result of the assignment expression is the value of the variable after the assignment has occurred. The result of an assignment expression is not itself a variable.” – JLS7, 15.26 Assignment Operators

“A variable that is declared final cannot be assigned to (unless it is definitely unassigned (§16)), because when an access of such a final variable is used as an expression, the result is a value, not a variable, and so it cannot be used as the first operand of an assignment operator.” – JLS7, 15.26 Assignment Operators