# implizite Klammerung



## JavaAnfänger1235 (23. Nov 2017)

Hallo liebe Leute,
ich habe folgende Aufgabe:

Ihre Aufgabe ist es zu den folgenden Ausdrücken die implizite Klammerung vollständig anzugeben. Gehen Sie davon aus, dass die Variablen i, j und k vom Typ int, a und b vom Typ boolean sind, und entsprechend deklariert und initialisiert wurden:
Was muss ich da genau beachten.
Hier das 1. Beispiel:

a = i % j * k <= i * i * i || b;

Meine Lösung: a =( (i % j) * k )<= ((i * i * i )|| b);

Stimmt das. Der 1. Teil vor dem <= kann auch anders geklammert sein oder? Java rechnet doch von rechts nach links.


----------



## Meniskusschaden (24. Nov 2017)

Nein, das kann nicht richtig sein. Du siehst es, wenn du dir die Datentypen von i*i*i und b bewusst machst.


----------



## Blender3D (24. Nov 2017)

Hier kannst Du die Prioritäten der Operatoren nachlesen. Damit fällt die Lösung leichter.
http://www.javaschubla.de/2007/javaerst0190.html


----------



## JavaAnfänger1235 (24. Nov 2017)

Danke euch
D.h es müsste so sein :

a =( ((i % j) * k )<= (i * i * i ))|| b;
oder?
In der 1. Klammer könnte auch umgeklammert werden, da % und * die gleiche Priorität haben??


----------



## truesoul (24. Nov 2017)

JavaAnfänger1235 hat gesagt.:


> Danke euch
> D.h es müsste so sein :
> 
> a =( ((i % j) * k )<= (i * i * i ))|| b;
> ...



Also wie wäre dann nach deiner Interpretation die andere Lösung? 

Der Satz "In der 1. Klammer könnte auch umgeklammert werden" verstehe ich nicht. 
Was könnte in der 1. Klammer noch umgeklammert werden? 

Grüße


----------



## JavaAnfänger1235 (24. Nov 2017)

a =( (i %( j * k ))<= (i * i * i ))|| b;

So wäre das?


----------



## truesoul (24. Nov 2017)

Hallo.

Nein.

Ein Beispiel:


```
int i = 15;
int j = 2;
int k = 8;

System.out.println(((i % j) * k)); // 8
System.out.println((i % (j * k))); // 15
```

Aber du sagtest ja schon % und * haben die gleiche Prio. Dann beachte doch mal die zweite Klammer.

*Edit:* Mit den Klammer setzt du Ausführungsreihenfolge.

Grüße


----------



## JavaAnfänger1235 (24. Nov 2017)

a =( ((i % j) * k )<= (i * i * i ))|| b;
Das wäre dann richtig.
Ja rechnet also von links nach rechts.
Mir ist klar, dass man bei anderer Klammerung ein anderes Ergebnis erhält, aber man weis ja nicht was gerechnet werden soll. Und wenn die Prio von * und% gleich ist, sind doch egtl beide Möglichkeiten richtig?


----------



## Flown (24. Nov 2017)

Nein, wenn beide gleichwertig sind, dann ist eine links-nach-rechts Evaluierung.


----------



## JavaAnfänger1235 (24. Nov 2017)

Ok dann ist es mir klar
a =( ((i % j) * k )<= (i * i * i ))|| b;
Das stimmt dann so?


----------



## Flown (24. Nov 2017)

Aber man kann das alles nachlesen: JLS


----------



## truesoul (24. Nov 2017)

Anscheinend nicht  

Wie gesagt % und * sind gleichwertig! 

Grüße


----------



## Flown (24. Nov 2017)

truesoul hat gesagt.:


> Anscheinend nicht


Sarkasmus?


----------



## JavaAnfänger1235 (24. Nov 2017)

Stimmt die Klammerung so dann:
a =( ((i % j) * k )<= (i * i * i ))|| b;?


----------



## Flown (24. Nov 2017)

Gegenfrage: Was glaubst du? Stimmt es oder nicht?


----------



## JavaAnfänger1235 (24. Nov 2017)

Ich glaube es stimmt


----------



## Flown (24. Nov 2017)

Jetzt kannst du es noch verifizieren, indem du einfach beide Expression (mit und ohne Klammerung) in ein Testprogramm wirst und auswirfst. Wenn das Gleiche rauskommt kannst du dir sicher sein.


----------



## JavaAnfänger1235 (24. Nov 2017)

Gut das werde ich machen 
Ich hätte noch ein paar Beispiele. Vllt könnt ihr kurz drüberschauen:

2.)
b = a || i < j && j < k && k > 0;
 3. )
a = j -i * k / i == j -k / i * i & b; 
4.)
 b = (double) i / j / k > i / j / k;

Zu 2.)
b = a ||(( i < j )&&( j < k) && (k > 0))
Zu 3.)
a = ((j -((i * k) / i ))== (j -((k / i )* i) )))& b; 
Zu 4.)
b = (double)( (((i / j) / k) >(( i / j )/ k)));

Ich hoffe das stimmt so
Dann hätte ich es verstanden.


----------



## Flown (24. Nov 2017)

Ich kann dir nur raten verifiziere deine Ergebnisse in dem du sie einfach mit code testest. Denn ich glaube nicht, dass sich jemand hier hinsetzt und das nochmal durchgeht.


----------



## JavaAnfänger1235 (24. Nov 2017)

Ok. D.h ich lasse mir den Ausdruck mit Klammern und ohne ausgeben und muss feststellen, dass dasselbe rauskommt


----------



## Flown (24. Nov 2017)

Kurz um: Ja. Verwende dabei Primzahlen wenn möglich (dann siehst du das Ergebnis eindeutiger).


----------



## Meniskusschaden (24. Nov 2017)

JavaAnfänger1235 hat gesagt.:


> Stimmt die Klammerung so dann:
> a =( ((i % j) * k )<= (i * i * i ))|| b;?


Meines Erachtens fehlt da noch ein Klammernpaar. Wenn man es ganz streng sieht fehlen sogar zwei Paare.


----------



## JavaAnfänger1235 (24. Nov 2017)

@Flown: Danke dir 
@ Meniskusschaden:

a =( (((i % j) * k )<= (i * i * i ))|| b);
Meinst du eine Klammer nach dem b?
Und wo noch?


----------



## Meniskusschaden (24. Nov 2017)

Ja, das meine ich. Das andere Klammernpaar würde ich bei `i * i * i` setzen.


----------



## JavaAnfänger1235 (24. Nov 2017)

Ja stimmt
Jetzt ergibt das mehr Sinn.
Dankeschön


----------



## truesoul (24. Nov 2017)

Hallo.

Oder bei dieser Klammerung ((i % j) * k ) kann man auch die Klammerung von (i % j) weg lassen.

Grüße


----------



## truesoul (24. Nov 2017)

Flown hat gesagt.:


> Sarkasmus?



Ja. Schließlich kam ja noch die Frage vom TE. 



JavaAnfänger1235 hat gesagt.:


> Ok dann ist es mir klar
> a =( ((i % j) * k )<= (i * i * i ))|| b;
> *Das stimmt dann so?*



Grüße


----------



## Meniskusschaden (24. Nov 2017)

truesoul hat gesagt.:


> Oder bei dieser Klammerung ((i % j) * k ) kann man auch die Klammerung von (i % j) weg lassen.


Was das angeht bin ich mir hinsichtlich der Aufgabenstellung nicht ganz sicher. Soll man die Assoziativität vollständig über Klammern abbilden oder nur dort, wo sie von der links-rechts-Assoziativität abweicht? Ich bin von Ersterem ausgegangen. Im anderen Fall könnte man natürlich ein paar Klammern wieder fallen lassen.


----------



## temi (24. Nov 2017)

JavaAnfänger1235 hat gesagt.:


> [...] implizite Klammerung vollständig anzugeben.


Das hört sich für mich nach allen Klammern an.


----------



## Meniskusschaden (24. Nov 2017)

Kommt eben darauf an, wie der Begriff "implizite Klammerung" definiert ist.


----------



## JavaAnfänger1235 (26. Nov 2017)

Hallo, ich habe ein Problem bei der Aufgabe:
Folgendes soll geklammert werden:
b = (double) i / j / k > i / j / k;

Meine Lösung: 
	
	
	
	





```
b = (double)(((i / j) / k) > ((i / j) / k));
```

Das funktioniert aber in Java nicht : Konvertrierungsfehler

Warum geht dann folgendes: 
	
	
	
	





```
b = (double)((i / j) / k) > ((i / j) / k);
```

Ich hätte gedacht casten hätte die höchste Prio???


----------



## Meniskusschaden (26. Nov 2017)

JavaAnfänger1235 hat gesagt.:


> Ich hätte gedacht casten hätte die höchste Prio???


Warum willst du denn dann den ganzen ursprünglich ungeklammerten Bereich vorher ausführen lassen?


JavaAnfänger1235 hat gesagt.:


> Das funktioniert aber in Java nicht : Konvertrierungsfehler


Nebenbei: Der ursprüngliche Ausdruck enthält auch einen Konvertierungsfehler.


----------



## JavaAnfänger1235 (26. Nov 2017)

D.h wenn ich das habe: b = (double) i / j / k > i / j / k;
Und die vollständige implizite Klammerung angeben soll: Dann wäre die Lösung:

```
b = (double)(((i / j) / k) > ((i / j) / k));
```


----------



## Meniskusschaden (26. Nov 2017)

Nein.
Nur zur Klärung, ob wir vielleicht bzgl. der Bedeutung von "höherer Priorität" aneinander vorbei reden: Die Multiplikation hat eine höhere Priorität als die Addition. Siehst du das auch so oder genau umgekehrt?


----------



## JavaAnfänger1235 (26. Nov 2017)

ich sehe es genau so: Wie wäre die richtige Lösung?


----------



## Meniskusschaden (26. Nov 2017)

Wie würdest du denn `a * b + c + d` klammern?


----------



## JavaAnfänger1235 (26. Nov 2017)

(((a*b)+c)+d)


----------



## Meniskusschaden (26. Nov 2017)

Und wie würdest du `(double) b + c + d` klammern?


----------



## JavaAnfänger1235 (26. Nov 2017)

(double)(((b+c)+d)))


----------



## Meniskusschaden (26. Nov 2017)

```
a * b + c + d
(double) b + c + d
```
Die Multiplikation hat eine höhere Priorität als die Addition. Ein Typecast hat auch eine höhere Priorität als die Addition. Warum klammerst du die Ausdrücke dann so unterschiedlich?


----------



## JavaAnfänger1235 (26. Nov 2017)

D.h erst wird gecastet und dann addiert: Dann so:
((((double) b)+c)+d)
so?


----------



## Meniskusschaden (26. Nov 2017)

Ja, so würde ich es auch machen. Das müsstest du jetzt eigentlich auf den Originalausdruck übertragen können.


----------



## JavaAnfänger1235 (26. Nov 2017)

Danke; ((((double) i) / j) / k) Bis zum > ist das ja so. Aber wie verschachtle ich das dann. Das > hat eine geringere Prio als \ ?


----------



## Meniskusschaden (26. Nov 2017)

Dann kannst du ja die Klammern so setzen, dass die Divisionen vor dem Vergleich durchgeführt werden.


----------



## JavaAnfänger1235 (26. Nov 2017)

((((((double) (i) / j) / k) )> (i )/ j) / k));
Das stimmt nicht. Irgendwie habe ich einen Denkfehler.


----------



## Meniskusschaden (26. Nov 2017)

Da ist eine schliessende Klammer zu viel. Wenn du die richtige entfernst, müsste es stimmen. Außerdem glaube ich nicht, dass die Aufgabenstellung Klammern um das i erwartet. Das würde ich noch entfernen.


----------



## JavaAnfänger1235 (26. Nov 2017)

((((((double) i) / j) / k) )> i )/ j) / k);
Das ist doch trotzdem falsch?


----------



## Meniskusschaden (26. Nov 2017)

Das war die falsche Klammer. Du musst die Klammern nicht grundsätzlich von links nach rechs setzen, sondern so, dass die Operationen in der richtigen Reihenfolge ausgeführt werden. Je höher die Priorität, desto weiter innen muß die Klammer sein.


----------



## JavaAnfänger1235 (26. Nov 2017)

Kannst du mir es biite zeigen. Ich verstehe das schon mit der prio. Kann es aber klammertechnisch nicht umsetzen.


----------



## Meniskusschaden (26. Nov 2017)

JavaAnfänger1235 hat gesagt.:


> Kannst du mir es biite zeigen.


Man kann z.B. so klammern: `((a*b)+(c*d))`


JavaAnfänger1235 hat gesagt.:


> Ich verstehe das schon mit der prio. Kann es aber klammertechnisch nicht umsetzen.


Ehrlich gesagt kann ich nicht so richtig nachvollziehen, wo da noch Umsetzungsschwierigkeiten liegen könnten, wenn man es verstanden hat.


----------



## JavaAnfänger1235 (26. Nov 2017)

b= (((i / j) / k) ) >(((i / j) / k)); Das wäre ja ohne double. Zusammen kriege ich es nicht hin


----------



## Meniskusschaden (26. Nov 2017)

Das double hattest du doch schon korrekt eingeklammert. Warum lässt du es nicht einfach so? Welchen Zweck hat `(double)` denn im Originalausdruck?


----------



## JavaAnfänger1235 (26. Nov 2017)

Es soll den Ausdruck danach in ein double Datentyp umwandeln:


((((double) i) / j) / k) das habe ich. Und jetzt muss ich > umsetzen?


----------



## Meniskusschaden (26. Nov 2017)

JavaAnfänger1235 hat gesagt.:


> Es soll den Ausdruck danach in ein double Datentyp umwandeln:


Welchen Ausdruck?


----------



## Meniskusschaden (26. Nov 2017)

JavaAnfänger1235 hat gesagt.:


> ((((double) i) / j) / k) das habe ich.


Richtig.


JavaAnfänger1235 hat gesagt.:


> Und jetzt muss ich > umsetzen?


Ist das unter den verbliebenen Operatoren wirklich derjenige mit der höchsten Priorität?


----------



## JavaAnfänger1235 (26. Nov 2017)

Das  (((i / j) / k) ) >(((i / j) / k))


----------



## JavaAnfänger1235 (26. Nov 2017)

Meniskusschaden hat gesagt.:


> Ist das unter den verbliebenen Operatoren wirklich derjenige mit der höchsten Priorität?


Nein erstmal \, aber dazwischen ist ja >


----------



## Meniskusschaden (26. Nov 2017)

JavaAnfänger1235 hat gesagt.:


> Das (((i / j) / k) ) >(((i / j) / k))


Nein, das ist nicht der Ausdruck, auf den `(double)` sich im Originalausdruck bezieht. Ein Typecast hat unter den beteiligten Operatoren die höchste Priorität und im Originalausdruck gibt es keine Klammern.


JavaAnfänger1235 hat gesagt.:


> Nein erstmal \, aber dazwischen ist ja >


Aber "links vor rechts" gilt nur bei Operatoren mit gleicher Priorität.


----------



## JavaAnfänger1235 (26. Nov 2017)

(((((((double) i) / j) / k)>i) / j) / k)

Dann so?


----------



## Meniskusschaden (26. Nov 2017)

JavaAnfänger1235 hat gesagt.:


> (((((((double) i) / j) / k)>i) / j) / k)
> 
> Dann so?



Wird die Division damit vor dem Größenvergleich durchgeführt?


----------



## JavaAnfänger1235 (26. Nov 2017)

Nein, aber wo soll ich die klammer dann setzen. Es fehlt noch ein Paar:
(((((((double)( i) / j) / k))>(i) / j) / k))
So dann?


----------



## Meniskusschaden (26. Nov 2017)

Nein. Ich glaube, du solltest mal in Ruhe darüber nachdenken und nicht wild herum probieren. Ich klinke mich für heute aus.


----------



## JavaAnfänger1235 (26. Nov 2017)

Trotzdem vielen Dank für deine Hilfe


----------



## JavaAnfänger1235 (27. Nov 2017)

ISt es so: ((((double) (i / (j / k)))>(i / (j / k))));


----------



## Meniskusschaden (27. Nov 2017)

Nein. Du hast dir noch immer nicht bewusst gemacht, worauf `(double)` sich bezieht. Ausserdem werden Ausdrücke mit gleicher Priorität von links nach rechts abgearbeitet. Z.B. müsste hier `(i / (j / k))` zuerst i durch j dividiert und das Ergebnis dann durch k dividiert werden. Warum willst du erst j durch k dividieren?
Du musst dafür sorgen, dass erst der Typecast ausgeführt wird, dann die Divisionen von links nach rechts und dann der Vergleich.


----------



## JavaAnfänger1235 (27. Nov 2017)

Kannst du es mir bitte zeigen, dann krieg ich vllt den Knoten aus meinem Kopf;(


----------



## temi (27. Nov 2017)

```
(double) b + c + d
```

Der double-Cast bezieht sich auf das, was direkt dahinter steht. Im Beispiel also "b".


```
(double) (b + c) + d
```

Worauf bezieht er sich deiner Meinung nach jetzt?


----------



## JavaAnfänger1235 (27. Nov 2017)

Auf das d?


----------



## JavaAnfänger1235 (27. Nov 2017)

Danke dass ihr mir alle helfen wollt. Das ist wirklich ein gutes Forum


----------



## temi (27. Nov 2017)

JavaAnfänger1235 hat gesagt.:


> Auf das d?


Äh - das war jetzt ein Scherz, oder?


----------



## JavaAnfänger1235 (27. Nov 2017)

Auf das (b + c)


----------

