Perché le espressioni stampano il valore della variabile usando System.out.print?

Il parametro di un metodo può essere un'espressione.

System.out.println(x - y)

Funziona perché x - y è un'espressione.

Nella maggior parte delle lingue simili a C, l'operatore di assegnazione fa anche parte di un'espressione. Ad esempio in C # Perché le istruzioni di assegnazione restituiscono un valore? Eric Lippert indica la differenza tra una istruzione an an espressione . Un'espressione restituisce qualcosa. + , - , ! e così via - quegli operatori restituiscono le cose. L'operatore = non è diverso sotto questo aspetto, restituisce qualcosa anche.

Che un operatore di assegnazione restituisca un valore è idiomatico in C come le lingue. E mentre i pensieri originali sul perché questo è il caso in C sono persi, x = y è tanto un'espressione quanto x - y è.

Si scopre che x = 42 restituisce anche il valore di 42 . Questo è utile per effetti collaterali come x = y = z = 42 che in realtà è x = (y = (z = 42))) . E qui, z = 42 restituisce 42 , che viene quindi utilizzato in y = 42 e così via.

Vedrai anche il valore di ritorno usato in cose come:

while ((line = in.readLine()) != null) {
    processLine(++lineNo, line);
}

in cui l'assegnazione alla linea viene eseguita e controllati per vedere se non è nulla.

Questo è un codice perfettamente idiomatico per la maggior parte delle lingue che rintracciano una linage in C.

Ulteriori letture: Specifiche della lingua Java, sezione 15.26: Assegnazione Gli operatori

Java è abbastanza liberale su dove è possibile fare un incarico. Sta stampando il valore della variabile dopo l'assegnazione. Quello che stai veramente scrivendo è un codice come:

int x;
x = 5; 
System.out.println(x);

o

int x = 5; 
System.out.println(x);

La maggior parte degli standard di codifica preferirà il codice scritto come mostrato sopra.

Quando si effettua un incarico, il valore assegnato è considerato il "risultato" o il "valore di ritorno" dell'espressione. È sottile e forse non chiaro perché il tuo esempio è qualcosa che raramente viene eseguito.

Ad esempio:

int i = 5;
int j = (i = 6);

A questo punto del codice, sia i che j sono uguali a 6. We assegnato i al valore 6 e quindi catturato il valore di ritorno dell'espressione, che è il valore che è stato trasferito, che è 6.

Personalmente, eviterei questo perché può essere molto confuso e facile da introdurre bug. Soprattutto in un System.out.println o qualsiasi altra chiamata che non dovrebbe cambiare lo stato. Viola il principio del minimo stupore.

Ti sei mai chiesto perché le classi di programmazione ti insegnano a usare sempre un doppio equo ( == ) in un'istruzione if? Hai mai notato che con un singolo segno di uguale, può ancora funzionare? Ecco perché. Il processo di valutazione di una condizione sta cambiando la condizione, creando un truismo o un falso. Il numero di difetti del software causati da if (x = y) .....

Molti programmatori (non ho ancora preso l'abitudine, ma probabilmente dovrebbero) preferiscono scrivere se le dichiarazioni con la costante sul lato sinistro come if (5 == x) invece di if (x == 5) in modo che se usano accidentalmente un singolo uguale firmare, il compilatore non lo permetterà.

Per portare questo al tuo esempio di codice, hai ragione, l'espressione sta "restituendo" un valore.

String fruit;
System.out.println(fruit="Orange"); //prints orange

Quando JVM esegue questo codice, un'istruzione alla volta, vede 3 istruzioni in questo ordine:

String fruit;
String someInternalStackVariableYouDontSee = (fruit = "Orange");
System.out.println(someInternalStackVariableYouDontSee );