# Logische Operatoren && und &



## esqueeze (3. Jan 2011)

Hi!

Irgendwie verstehe ich den Unterschied zwischen & und && bzw. |  und || nicht.
Mir ist klar, das dies jeweils der strikte bzw. nicht strikte Operator ist, und das beispielsweise
& beide Seiten auswertet, während && die zweite schon garnicht mehr auswertet, wenn die erste
falsch ist.

Nur wo liegt der Sinn? Irgendwie kommt doch unterm Strich genau das Gleiche bei heraus?!

Beispiel:

        System.out.println(1==1 & 2==3);
        System.out.println(1==1 && 2==3);

=> Beides false.


----------



## eRaaaa (3. Jan 2011)

es geht darum, dass du unter Umständen dort aber etwas prüfen musst, was nicht gerade eine so simple Prüfung wie 2==3 ist, sondern etwas komplizierter und rechenintensiver.

```
public static boolean foo(...){
		//lange pruefung
		return ...
	}

// und
if(foo(..) && foo(..)){
```

da macht`s dann evtl. Sinn den zweiten Methodenaufruf von foo() nicht auch noch aufzurufen, wenn der erste eh schon false ist.


----------



## F.S.WhiTeY (3. Jan 2011)

Der unterschied ist die Rechenleistung. Er muss bei && nicht beides auswerten, das spart rechenleistung.


----------



## AlexSpritze (3. Jan 2011)

F.S.WhiTeY hat gesagt.:


> Der unterschied ist die Rechenleistung. Er muss bei && nicht beides auswerten, das spart rechenleistung.



bei 
	
	
	
	





```
Bedingung1 && Bedingung2
```
 muss "er" auch die zweite Bedinung auswerten, wenn die erste true ist; nur wenn die erste false ist, "weiß" "er" das Ergebnis der logischen Verknüpfung ohne die zweite auszuwerten ...


----------



## darekkay (3. Jan 2011)

Ein einfaches & sollte auch eher für bitweise Operationen verwendet werden, z.B.: 0110 & 1010


----------



## esqueeze (3. Jan 2011)

Okay, das es Rechenleistung spart, hatte ich mir auch überlegt. Gibt es sonst noch einen Grund bzw. habt ihr vllt. noch ein weiteres Beispiel? danke!!


----------



## Schandro (3. Jan 2011)

Es ist nicht nur für die Performance wichtig. Beispiel:

```
if(connection == null || !connection.isValid()){
```
Wenn das connection-Object noch garnicht initialisiert wurde oder mittlerweile invalide ist, soll es neu zugewiesen werden...
Diese Überprüfung MUSS mit || statt | geschrieben werden, da ansonsten immer eine NullPointerException fliege würde wenn connection null ist. Wenn man dagegen || benutzt und connection null ist, wird der Teil 
	
	
	
	





```
!connection.isValid()
```
 garnicht mehr ausgeführt, dementsprechend fliegt auch keine NullPointerException.


----------



## F.S.WhiTeY (3. Jan 2011)

AlexSpritze hat gesagt.:


> bei
> 
> 
> 
> ...



Ja so meinte ich das ^^ hab mich da eher unglücklich ausgedrückt. Sry


----------



## esqueeze (3. Jan 2011)

Schandro hat gesagt.:


> Es ist nicht nur für die Performance wichtig. Beispiel:
> 
> ```
> if(connection == null || !connection.isValid()){
> ...



Danke dafür  Das hat mir die Sache schon sehr verdeutlicht!


----------



## eeeaaaeeeaaa (3. Jan 2011)

semantische unterschied ergeben sich, wenn die nachfolgenden bedingungen nur dann geprüft werden sollen, wenn die vorherigen true ergeben (&&) - oder wenn nachfolgende nicht mehr ausgewertet werden sollen (||). diese schreibweisen ersparen if-verschachtelungen oder wiederholung gleicher sachen.


```
if a
 b

if c
 b
```

if a || c then b[/code]


```
if a
 if b
  c

if a && b then c
```


----------



## Marco13 (3. Jan 2011)

Von sowas wie

```
if (x==y & ++z==w) ... 
vs
if (x==y && ++z==w) ...
```
mal abgesehen :autsch:


----------



## Andi_CH (4. Jan 2011)

```
if (function1() & function2()) ...
```
function2() wir in jedem Fall ausgeführt - es könnte ja sein, dass sie sideffects hat die gewollt sind.


```
if (reference != null && reference.function3()) ...
```
In diesem Fall macht & defitniv KEINEN Sind ;-)


----------



## Marco13 (4. Jan 2011)

Andi_CH hat gesagt.:


> ```
> if (function1() & function2()) ...
> ```
> function2() wir in jedem Fall ausgeführt - es könnte ja sein, dass sie sideffects hat die gewollt sind.



Wenn function2 ausgeführt werden MUSS, ist das an sich IMHO schon fragwürdig, aber wenn, dann sollte man es definitiv nicht so schreiben, sondern eher als

```
boolean b1 = function1();
boolean b2 = function2();
if (b1 && b2) { ... }
```


----------



## Andi_CH (4. Jan 2011)

Natürlich ist es zu hinterfragen wenn funktionen sideffects haben aber es gibt leider einen Unterschied zwischen Wunschdenken und der realen Welt.
(Ich gönne dir gerne mal einen Blick in die Sourcen hier - da werden alle Berechnungsresultate in lokalen Variablen gespeichert und von späteren Berechnungsschritten verwendet - nein, ich habe nicht behauptet, dass das ideal ist)

Warum das so geschrieben werden soll wie du es machst ist allerdings auch erwas fraglich und macht überhaupt keinen Unterschied.


----------



## Marco13 (4. Jan 2011)

Zumindest sind wir uns einig, dass die (sich nirgendwo manifestierende) Anforderung "diese Methode muss aufgerufen werden" kritisch ist. Es könnte aber auch sein, dass der Rückgabewert der "Seiteneffekt" ist  Man könnte sich einen... vergleichsweise realitätsnahen und an sich nicht wirklich "schlechten" Anwendungsfall vorstellen:
[c]if (set.add(object0) & set.add(object1)) { ... }[/c]
bzw.
[c]if (set.add(object0) && set.add(object1)) { ... }[/c]
Das einzig "schlechte" daran ist die Schreibweise. Der wichtige Unterschied dieses Codes zur Alternative

```
boolean setHasChanged0 = set.add(object0);
if (!setHasChanged0)
{
    boolean setHasChanged1 = set.add(object1);
    if (setHasChanged1) { ... }
}
```
bzw.

```
boolean setHasChanged0 = set.add(object0);
boolean setHasChanged1 = set.add(object1);
if (setHasChanged0 && setHasChanged1) { ... }
```
ist: Das zweite ist übersichtlicher - es steht deutlicher und leichter erfassbar da, was gemacht wird. Es werden die Elemente zum Set hinzugefügt (und zwar explizit, in einzlenen Zeilen, bei denen Klar ist, wann sie ausgeführt werden), es wird sich in sprechenden Variablen gemerkt, ob die Menge sich durch das Hinzufügen geändert hat, und diese booleans dann unmißverständlich abgefragt.


----------

