# if (obj == null || obj.isEmpty())



## Rock Lobster (10. Sep 2007)

Servus,

gibt es eigentlich eine *Garantie*, daß ein Konstrukt wie dieses...

```
if (obj == null || obj.isEmpty())
```
...immer von links nach rechts ausgewertet wird, sodaß ich unbesorgt nach dem || eine Methode des Objekts aufrufen kann, weil dieser Aufruf ja, sofern es null ist, sowieso nicht getätigt wird, da die If-Abfrage bereits nach dem "== null"-Vergleich rausspringt?

Oder könnten das andere Compiler auch genau andersrum machen, wodurch es dann unter Umständen zu einer NullPointerException kommen kann?


----------



## The_S (10. Sep 2007)

Verwende den Compiler von Sun und auch dieselbe VM und du solltest das Problem nicht haben (zumal ich aber auch bezweifle, dass ein anderer Compiler die Argumente umdreht ...).


----------



## SlaterB (10. Sep 2007)

jeder Compiler kann es machen wie es will, aber wenn er sowas macht, dann kann er auch gleich die Festplatte formatieren,
ein anständiger Compiler ist verpflichtet, von links nach rechts auszuwerten,

das gilt schon für |, aber gerade || hat ja die besondere Bedeutung, dass rechts nicht ausgewertet wird wenn links true ergibt,
darauf verlassen sich alle Programmierer


----------



## P3AC3MAK3R (10. Sep 2007)

Du solltest Dich darauf verlassen können, daß die beiden Bedingungen von links nach rechts ausgewertet werden:



> Die bedingten Operatoren &&, || und ?: werten ihre Operanden auch von links nach rechts aus, überspringen aber die Auswertung weiterer Operanden, wenn das nicht mehr nötig ist.



Quelle: http://www.num.math.uni-goettingen..../vorlinfo/1998/www/skript/texte/priority.html


----------



## Rock Lobster (10. Sep 2007)

Okay das wollte ich hören. Natürlich kann ein Compiler Mist bauen, aber ich meinte das jetzt mehr von der Richtung "ist das so in den Java-Standards / Java-Richtlinien definiert".

Wenn Du sagst, daß || die von Dir angesprochene "besondere Bedeutung" hat, dann wird das wohl so sein 

Ich nehme an, unter C/C++ gelten dann die gleichen Regeln?


----------



## Rock Lobster (10. Sep 2007)

Ah okay, da heißt er ja auch "Conditional Or", das sollte alles sagen. Vielen Dank!


----------



## function (10. Sep 2007)

Es gibt leider keine wirklichen Java-standarts. Es ist grundsätzlich jedem Compilerentwickler freigestellt, wie er die sprach elemente umsetzt. Allerdings ist mir keine programmiersprache bekannt bei der if abfragen nicht von links nach rechts gelesen werden. Vorallem bei || und &&, ansonsten wären diese beiden elemente sinnlos.


----------



## Murray (10. Sep 2007)

Java-Language-Specification hat gesagt.:
			
		

> 15.24 Conditional-Or Operator ||
> The || operator is like | (§15.22.2), but evaluates its right-hand operand only if the value of its left-hand operand is false.


Also: eine VM, die sich hier anders verhält, wäre nicht spezifikationskonform; insofern kann man sich darauf verlassen, dass solche Konstrukte funktionieren.


----------



## Rock Lobster (10. Sep 2007)

> Es gibt leider keine wirklichen Java-standarts. Es ist grundsätzlich jedem Compilerentwickler freigestellt, wie er die sprach elemente umsetzt.



Naja klar, aber ein paar Regelungen gibt es ja schon, z.B. kann ja ein Compilerentwickler nicht einfach die Bedeutung von "private" und "public" vertauschen. Okay, er könnte es, aber der Compiler würde dann nicht als "gültiger Java-Compiler" bezeichnet werden können. So meinte ich das mit den "Standards"  und Sun-Richtlinien gibt's ja schon immer wieder zu lesen.


----------



## Murray (10. Sep 2007)

function hat gesagt.:
			
		

> Es gibt leider keine wirklichen Java-standarts. Es ist grundsätzlich jedem Compilerentwickler freigestellt, wie er die sprach elemente umsetzt.


Das stimmt m.E. nicht; ein Compiler muss zumindest die JLS einhalten, um sich wirklich "Java"-Compiler nennen zu können.


----------



## tfa (10. Sep 2007)

function hat gesagt.:
			
		

> Es gibt leider keine wirklichen Java-standarts. Es ist grundsätzlich jedem Compilerentwickler freigestellt, wie er die sprach elemente umsetzt. Allerdings ist mir keine programmiersprache bekannt bei der if abfragen nicht von links nach rechts gelesen werden. Vorallem bei || und &&, ansonsten wären diese beiden elemente sinnlos.



"Java-Standarts" gibt es wirklich nicht. Der Standard für Java nennt sich JLS und legt das Verhalten des ||-Operators genau fest:
java.sun.com/docs/books/jls/third_edition/html/expressions.html#15.24

tfa


----------



## Kim Stebel (10. Sep 2007)

Sun setzt seine Markenrechte an "Java" so ein, dass sich kein Java-Compiler so nennen darf, wenn er die Standards, namentlich die Java Language Specification nicht einhält.


----------



## me1357 (10. Sep 2007)

Rock Lobster hat gesagt.:
			
		

> Ich nehme an, unter C/C++ gelten dann die gleichen Regeln?


In C++ kannst du Operatoren überladen. Und wenn man den ||-Operator überlädt, dann werden afaik immer beide Seiten ausgewertet, man kann sich also in C++ nicht generell darauf verlassen.


----------



## Jango (10. Sep 2007)

me1357 hat gesagt.:
			
		

> In C++ kannst du Operatoren überladen. Und wenn man den ||-Operator überlädt, dann werden afaik immer beide Seiten ausgewertet, man kann sich also in C++ nicht generell darauf verlassen.


Zeig mir mal bitte, wie man in C++ logische Operatoren überlädt.


----------



## me1357 (10. Sep 2007)

Jango hat gesagt.:
			
		

> Zeig mir mal bitte, wie man in C++ logische Operatoren überlädt.


Nicht anders, als man dass bei allen anderen Operatoren auch macht.

```
#include <iostream>
using namespace std;

class foo {
	public:
		void operator||(bool)
		{
			cout << "Hello, world!" << endl;
		}
};

int main ()
{
	foo a;
	a || true;
}
```


----------



## Saxony (12. Sep 2007)

Hiho,

man kann sich das natürlich auch ganz sicher hinschreiben:


```
int i = 0;

if (obj == null) {

    i = 1;
} else if (obj.isEmpty()) {

    i = 1;
}

if (i & 1) {

    // jetzt mache das was bei "obj == null || obj.isEmpty()" gemacht werden soll
}
```

Sieht aber etwas gestelzt und unschön aus. 
Zudem hat man nun ein und draus gemacht. 

bye Saxony


----------



## Murray (12. Sep 2007)

Saxony hat gesagt.:
			
		

> Sieht aber etwas gestelzt und unschön aus.
> Zudem hat man nun ein und draus gemacht.


Außerdem hat man 
 - eine überflüssige Variable i
 - ein bis zwei überflüssige Zuweisungen( i=0, i=1)
 - eine Bedingung, deren Semantik nicht aus der Anweisung allein erschließt ( if ( i & 1))

Letzeren Nachteil kann man mit einer sinnvoll benamten Bool'schen Hilfvariablen vermeiden:

```
boolean empty = false;
if (obj == null) {
    empty = true;
} else if (obj.isEmpty()) {
    empty = true;
}

if ( empty) {
    // jetzt mache das was bei "obj == null || obj.isEmpty()" gemacht werden soll
}
```

Sinvoll ist das alles aber eigentlich nicht: wie oben schon mehrfach erwähnt wurde, ist das in Rede stehende Konstrukt (verflucht, hier schleicht sich gerade Versicherungssprech ein) hinreichend sicher.


----------



## Kim Stebel (12. Sep 2007)

das ist nicht nur hinreichend sicher, dass ist genau so ein Bestandteil der Sprache Java wie "If-else-Blöcke. Wenn ihr dem Compiler bei ersterem nicht trauen wollt, wieso dann bei letzterem?


----------



## Jango (12. Sep 2007)

@: me1357 - danke - wollte ich mal wissen. Ich dachte sowas geht nicht.


----------



## jPat (13. Sep 2007)

x

[edit] xx [/edit]

Bei eurem problem spielt doch die linksassoziativität des Operators || eine Entscheisdene Rolle.
Da kann man sich IMMER drauf verlassen.


----------



## The_S (14. Sep 2007)

jPat hat gesagt.:
			
		

> x




aaaaaaahhhhhhhhhhhh, x ... genau das wars! Danke, jetzt sind alle Fragen geklärt! 

Da hat aber jemand sein geballtes Wissen in einem einzigen Post entladen ...


----------



## Jango (14. Sep 2007)

Hobbit_Im_Blutrausch hat gesagt.:
			
		

> Da hat aber jemand sein geballtes Wissen in einem einzigen Post entladen ...


...und trotz der immensen Fülle an Infos, immer noch sehr übersichtlich gehalten. So, dass man es sofort versteht...  :lol:


----------

