kurzes if-then-else statement

[Roar]

gudn morgen,
ich hab mich bisher noch nie mit diesem statement beschäftigt, aber jetzt muss ichs so machen, weil das einfach kürzer ist. also es geht um diese kurzform dieses if-then-else statements.
im internet konnte ich die richtige syntax nicht finden, und bei mir lässt sich das foglende zwar kompileiren, funktioneirt aber nicht.

String importantBg = colorToString(pmWnd.importantbg).equals("0,255,0") ? "Rot" : "nicht rot";

irgendwie ist das also falsch. kriegen will ich das ergebnis von

if ( colorToString(pmWnd.importantbg).equals("0,255,0") ) {
importantBg = "Rot";
} else {
importantBg = "nicht rot";
}

wie ist denn jetzt die richtige syntax für das statement?

 

[Roar]

GAA bin ich doof :?
die syntax war schon richtig, nur hab ich leider vergessen dass rot "255,0,0" ist und nicht 0,255,0 :? ich wurst.
die bestätigung hab ich hier bekommen:
http://java.sun.com/docs/books/tutorial/java/nutsandbolts/if.html

so is richtig:

String importantBg = colorToString(pmWnd.importantbg).equals("255,0,0") ? "Rot" : "kein rot";

 

[sigma]

gewöhn dir diesen stil nicht an. es ist nich wirklich sinnvoll. denn wenn du im if eine etwas hinzufügen musst dann musst du alles umbauen und zudem ist es sehr mühsam zum lesen vorallem wenn ein souce in paar hundert seiten lang ist.

gruss sigma

 

[Roar]

wenn man aber schnell was überprüfen muss und das evtl. oft hintereinander ist es einfach kürzer.
aber ich werde's trotzdem nicht oft machen :?

 

[sigma]

ich programmier seit 3 jahren und am anfang habe ich dies auch si gemacht, doch als meine programme immer grösser wurden gab ich es mit der zeit langsam auf.

evtl. oft hintereinander

wenn du dinge oft hintereinander prüfen musst, dann könnte man dies auch in eine methode packen.

hab mal von einem kollegen gehört wenn methoden zu lange werden, dann sind sie nicht schön OO-programmiert.

gruss sigma

 

[Roar]

nee ich mein wenn man einige überprüfungen benötigt, dann geht das so einfach schneller zu schreiben, und ist auch einfacher zu lesen, als wenn man ewig große lange if-blöcke schreibt. so:

importantBg = colors.contains(pmWnd.importantbg) ? (String) 

colorNames.elementAt(colors.indexOf(pmWnd.importantbg)) : colorToString(pmWnd.importantbg);
importantFg = colors.contains(pmWnd.importantfg) ? (String) 

colorNames.elementAt(colors.indexOf(pmWnd.importantfg)) : colorToString(pmWnd.importantbg);
todoBg = colors.contains(pmWnd.todobg) ? (String) colorNames.elementAt(colors.indexOf(pmWnd.todobg)) : 

colorToString(pmWnd.todobg);
todoFg = colors.contains(pmWnd.todofg) ? (String) colorNames.elementAt(colors.indexOf(pmWnd.todofg)) : 

colorToString(pmWnd.todofg);
laterBg = colors.contains(pmWnd.laterbg) ? (String) colorNames.elementAt(colors.indexOf(pmWnd.laterbg)) : 

colorToString(pmWnd.laterbg);
laterFg = colors.contains(pmWnd.laterfg) ? (String) colorNames.elementAt(colors.indexOf(pmWnd.laterfg)) : 

colorToString(pmWnd.laterfg);

ich programmier jetzt seit knapp einem jahr Java, und hab das so noch nie angewendet, und du hast recht, ich werde es auch bestimmt nicht oft tun.

 

[bygones]

interessant ist, dass wenn man den Java Source Code sich anschaut findet man diese Art der Überprüfung sehr oft.

Ich mache davon öfters gebrauch - aber nur dann, wenn es ein kurzer, prägnanter Ausdruck ist:

String value = isThisOk ? "ja": "nein"

 

[bygones]

hab mal von einem kollegen gehört wenn methoden zu lange werden, dann sind sie nicht schön OO-programmiert.

Darüber lässt sich schreiben - aber jedes Detail in eine eigene Methode zu packen ist ebenso unsinnig...

Man sollte in Methode logische zusammenhängende Teile des Programmes vereinen. Wenn ein Test von mehreren versch. Seiten benötigt wird, dann z.b. ist eine Trennung natürlich sinnvoll.

Ansonsten bin ich aber auch nicht der Freund von zig Methoden, die alle nur ein, zwei zeilen Code behalten.... zu viele Methodenaufrufe sind auch nicht gut :?

 

[Nobody]

und kostet nebenbei speicher und dann ists kein wunder, dass sich viele über die langsamkeit von java aufregen.

bei vielen programmen mag es nicht auffallen, aber wenns wirklich komplexer wird und speicherintensiv, merkt man das dann schon