Metodi negli operatori logici

[Gas75]

Salve, mi sono imbattuto in questo codice che mi ha fatto sorgere qualche dubbio...

public class TestClass {
	public static void main(String args[ ]) {
		int i = 0;
		boolean bool1 = true;
		boolean bool2 = false;
		boolean bool  = false;
		bool = (bool2 &  method1("1")); //1
		bool = (bool2 && method1("2")); //2
		bool = (bool1 |  method1("3")); //3
		bool = (bool1 || method1("4")); //4
	}
	public static boolean method1(String str) {
		System.out.println(str);
		return true;
	}
}

Eseguendolo stampa 1 e 3...
method1() restituisce sempre true, mentre bool vale, in sequenza, false false true true: non c'è quindi corrispondenza tra l'esito del confronto logico e l'esecuzione di method1().

Come mai l'operatore bitwise (& e |) fa stampare sempre e quello logico (&& e ||) mai?

[LeleFT]

Perchè gli operatori logici usano la cosiddetta short-circuit logic mentre gli operatori bitwise no.
L'espressione viene sempre valutata da sinistra verso destra. Se si usano gli operatori logici, la valutazione si ferma non appena il risultato può già essere calcolato. In una AND, ad esempio, se il primo operando è FALSO non ha nessun senso andare a valutare gli altri operandi, in quanto il risultato è già noto a priori: sarà FALSO.
In una OR, se il primo operando è TRUE, non ha nessun senso andare a valutare gli altri, perchè il risultato è sicuramente TRUE.
Se, al contrario, i primi operandi non sono sufficienti già a determinare il risultato finale, i rimanenti operandi verranno valutati man mano (procedendo sempre da sinistra verso destra) fino a quando il risultato non sarà certo o fino alla fine degli operandi.

Esempio per capire meglio:

if (metodo1() && metodo2() && metodo3()) {
   ...
}

Se metodo1() restituisce FALSE, l'esecuzione termina perchè il risultato dell'intera espressione può già essere calcolato: sarà FALSE. metodo2() e metodo3() non verranno eseguiti.
Se metodo1() restituisce TRUE, non è possibile a priori sapere il risultato dell'espressione... quindi si procederà e verrà eseguito metodo2(). Se metodo2() restituisce FALSE il risultato è già determinato e metodo3() non verrà eseguito. Altrimenti verrà eseguito anche metodo3() e il risultato dipenderà solo da lui.

Questa è la short-circuit logic.

Questa logica non viene applicata con gli operatori bitwise per i quali tutti gli operandi vengono sempre valutati.

Di conseguenza, alla riga

bool = (bool2 && method1("2")); //2

Il risultato dell'espressione in AND può già essere valutato considerando il primo operando "bool2" che vale false... method1() non verrà eseguito.


Ciao.

[andbin]

Come mai l'operatore bitwise (& e |) fa stampare sempre e quello logico (&& e ||) mai?

Gli operatori && e || hanno un comportamento che viene detto di "short-circuit". Ovvero il secondo operando NON lo valutano nemmeno (se fosse la invocazione di un metodo non avviene) SE già dal primo operando è possibile dedurre il risultato finale.

Se in una "or" il primo operando è true, allora NON c'è bisogno di valutare il secondo operando, in quanto il risultato è sicuramente true.
Se in una "and" il primo operando è false, allora NON c'è bisogno di valutare il secondo operando, in quanto il risultato è sicuramente false.

Gli operatori & e | invece NON hanno il comportamento short-circuit e quindi valutano SEMPRE entrambi gli operandi prima di poter dare il risultato.

[Gas75]

Grazie per la rapida risposta.
Ok sulla logica short-circuit, ma siccome bool1 è true, perché non stampa anche il 4 e non si ferma a bool1 nella riga // 3?

[andbin]

ma siccome bool1 è true, perché non stampa anche il 4?

boolean bool1 = true;
bool = (bool1 || method1("4")); //4

Perché appunto c'è || ovvero il primo operando è true, quindi il secondo non viene valutato.

[Gas75]

Perché appunto c'è || ovvero il primo operando è true, quindi il secondo non viene valutato.

Ok!!!