# Übungszettel



## benny543 (16. Nov 2010)

Hey ich studiere BWL und seit diesem Semester muss ich Informatik belegen. Leider hab ich noch nie irgendetwas programmiert, weder in Java noch irgend einer anderen Sprache. Daher bitte ich euch um Hilfe. Unten seht ihr die Aufgaben die ich bekommen habe, und die noch nicht alzu viel mit programmieren zu tun haben aber schon daran scheitere ich. ich hoffe ihr könnt mir helfen.
MfG benny543



> 1.)
> Nehmen Sie an, dass int a=1 und double d=1.0 gilt, und dass die folgenden Ausdrücke
> unabhängig voneinander sind. Evaluieren Sie die Ausdrücke und erklären Sie stichwortartig
> das Ergebnis:
> ...


----------



## XHelp (16. Nov 2010)

Das können wir bestimmt: stell Fragen, poste deine Lösung zur Korrektur, stell Vermutungen an...


----------



## benny543 (16. Nov 2010)

bei Aufgabe 2 habe ich durch probieren herausgefunden das es sich um ein programm zur bestimmung von primzahlen handelt. außerdem hab ich mitbekommen das boolean nur wahr oder falsch kennt, richtig? allerdings komme ich immer noch nicht drauf welchen wert die variable b in abh. von n annimmt.


----------



## bone2 (16. Nov 2010)

benny543 hat gesagt.:


> bei Aufgabe 2 habe ich durch probieren herausgefunden das es sich um ein programm zur bestimmung von primzahlen handelt. außerdem hab ich mitbekommen das boolean nur wahr oder falsch kennt, richtig? allerdings komme ich immer noch nicht drauf welchen wert die variable b in abh. von n annimmt.



vielleicht wahr bei primzahlen und falsch wenn es keine ist?^^


----------



## XHelp (16. Nov 2010)

Ja, ein boolean ist entweder wahr oder falsch, was sicherlich auch in der Vorlesung erklärt wurde...
Du hast es richtig rausgefunden, wenn dass das Programm eine Zahl auf Primzahl testet.
Ist n prim? Da gibt es 2 Antworten: wahr oder falsch. Wozu könnte 
	
	
	
	





```
b
```
 also da sein?


----------



## benny543 (16. Nov 2010)

b bestimmt ob es wahr oder falsch ist. für wahr darf bei division durch n keine kommastelle folgen n % i == 0) und n/ i darf nicht n sein (aber wie geht das wenn für i eine zeile drüber steht int i= 1; n durch 1 ist ja immer wieder n)


kann int dezimalstellen angeben; Nein oder??


----------



## XHelp (16. Nov 2010)

Integer ist eine ganze Zahl.
Wann ist n/x==n? nur bei 1. Also schließt du dadurch bei der Überprüfung die 1 aus. Es macht auch Sinn, denn durch 1 ist jede natürliche Zahl restlos teilbar. Das steht aber vermutlich nur zur Verwirrung da.


----------



## Eldorado (16. Nov 2010)

Weiß du was eine Schleife ist?


----------



## benny543 (16. Nov 2010)

eine schleife ist dachte ich ein vorgang bei dem das programm solange zu einem punkt zurück springt bis alle prozesse durchgerechnet sind. also bei der addition von 12 und 14 rechnet er erst 2+4 und dann springt er zurück und rechnet 10+10 +(2+4). ich hoff mal das ich jetzt keinen total stuss erzählt habe^^


----------



## Eldorado (16. Nov 2010)

das was du denke ich meinst ist die Rekursion. Das ist eine Schleife:

```
for (int i = 1; i <= n - 1; i++) {

}
```
Sie startet bei 1 und läuft solange bis i kleiner-gleich n-1 ist und bei jedem Schleifendurchlauf wir i um ein erhöht. i++ ist gleich i=i+1
Vielleicht verstehst du jetzt das Programm besser.


----------



## benny543 (16. Nov 2010)

also ist b richtig wenn gilt: for (int i = 1; i <= n - 1; i++) {

und b ist falsch wenn: if ((n % i == 0) && (n / i != n)) {

ich hab die ganze zeit gedacht das der komplette ausdruck:
for (int i = 1; i <= n - 1; i++) {
if ((n % i == 0) && (n / i != n)) {
für b= false gilt

versteh ichs jetzt richtig??


noch ne andere frage was muss bei den sachen rechnen (warum stehen die operatoren vor dem =?):
a %= 
d += 
d -= 
d -=


----------



## Gast2 (16. Nov 2010)

benny543 hat gesagt.:


> noch ne andere frage was muss bei den sachen rechnen (warum stehen die operatoren vor dem =?):
> a %=
> d +=
> d -=
> d -=



Das sind Kurzformen für:


```
a %= x; <=> a = a % x;
a += x; <=> a = a + x;
a -= x; <=> a = a - x;
```


----------



## benny543 (16. Nov 2010)

okay
wird es dann gerechnet als
a = a%3/a+3 oder als a=a%(3/a+3) 

beim ersten fall würde ja 3 rauskommen und im zweiten Fall 0


----------



## Gast2 (16. Nov 2010)

Wie wäre es mit ausprobieren?

Es ist:

```
a %= 3 / a + 3; <=> a = a % ( 3 / a + 3 )
```
Zum Testen:

```
public class Test {
	public static void main(String[] args) {
		int a = 1;
		a = 46 / 9;
		System.out.println(a);
		a = 46 % 9 + 4 * 4 - 2;
		System.out.println(a);
		a = 45 + 43 % 5 * (23 * 3 % 2);
		System.out.println(a);
		a %= 3 / a + 3;
		System.out.println(a);
	}
}
```

Macht:
5
15
48
0


----------



## dehlen (16. Nov 2010)

also zu deiner Frage mit der for-Schleife 

eine for schleife wird solange ausgeführt,solange die Auswertung der Schleifenbedingung true ist.
Bevor die Schleife ausgeführt wird, wird eine Anweisung zur Intialisierung genau einmal ausgeführt.
Die Schleifenbedingung wird vor Ausführung des Schleifenrumpfes ausgewertet (so dass die Schleife eventuell gar nicht durchlaufen wird). Eine Inkrement-Anweisung wird nach jeder Ausführung des Schleifenrumpfes ausgeführt.


```
for (Intialisierung; Schleifenbedingung; Inkrement) {
Anweisungen
}
// ein Beispiel sieht dann so aus:

for (int i = 0; i<sammlung.size(); i++) {
System.out.println(sammlung.get(i));
}
```
Ich hoffe du kannst die for-Schleife nun besser verstehen


zur If Bedingung:

die If Bedingung hat 2 Formen:


```
if (Ausdruck) {
Anweisung
}

//oder

if (Ausdruck) }
Anweisung
}
else {
Anweisung
}

// Beispiel:

if (zahl<0) {
meldeFehler();
}
else {
verarbeiteteZahl(zahl);
}
```

So ich hoffe du kannst die if Bedingung nun auch besser verstehen

Boolean:
Logische Variablen haben zwei Zustände, die man als an oder aus, wahr oder falsch, ja oder nein interpretieren kann. In Java wird ein solcher Wahrheitswert durch den Datentyp boolean repräsentiert. Sein Wertebereich besteht nur aus zwei Werten, nämlich true und false.

Vergleichsoperationen, die später in dieser Lerneinheit behandelt werden, liefern ein Ergebnis vom Typ boolean.


Beispiel:

```
class TestBoolean {
   public static void main(String args[]) {
      boolean fehlerAufgetreten = false;
      System.out.println("Wert von fehlerAufgetreten = "
                         + fehlerAufgetreten);
   }
}

//Ergebnis:
Wert von fehlerAufgetreten = false
```

und zu deinen Integer Variablen:

In Java gibt es vier Datentypen für die Darstellung von ganzen Zahlen: byte, short, int und long. Sie unterscheiden sich nur in ihrer Größe und ihrem Wertebereich. Im ersten Bit wird jeweils das Vorzeichen gespeichert.

In Java sind ganzzahlige Werte standardmäßig vom Typ int.

SO das wäre nur noch mal kurz ein wenig "Grammatik " hoffe es hilft dir das programm zu verstehen

Edit:
also soweit ich das jetzt verstehe (bin auch noch nicht so lange bei java ) müsstest du es demnach so interpretieren

b ist der Operator der prüft ob eine Aussage wahr oder falsch ist
es wird deklariert das b = true ist solange die for Schleife ausgeführt wird also solange i kleiner gleich n-1 ist

und wenn die if bedingung erfüllt ist

wenn diese beiden sachen nicht erfüllt sind dann ist b = false
und es wird ein MessageDialog ausgegeben.......
richtig oder?! 
würde mich auch mal interessieren ob ich schon was dazu gelernt habe also ob ich recht habe  =)


----------



## benny543 (16. Nov 2010)

okay danke.... jetzt hab ich das sogar als Programmiernoob das verstanden 

mittlerweile habe ich mich mal an aufgabe 4 getraut und folgendes heraus bekommen:

```
import javax.swing.JOptionPane;
class Aufgabe18 {

     public static void main(String[] argv) {
		
	int a, b;
	a = Integer.parseInt(JOptionPane.showInputDialog ("a = "));
	b = Integer.parseInt(JOptionPane.showInputDialog ("b = "));

	  switch (a%b) {
		case 0: JOptionPane.showMessageDialog (null,"der Rest ist 				0");
		break;

		case 2: JOptionPane.showMessageDialog (null,"der Rest ist 			eine einstellige Primzahl");
		break;
		case 3: case 5: case 7: JOptionPane.showMessageDialog  			(null,"der Rest ist eine einstellige Primzahl und 			ungerade");
		break;

		case 1: case 9:  JOptionPane.showMessageDialog (null,"der 			Rest ist ungerade");
		break;

		default: JOptionPane.showMessageDialog  (null,"Der Rest 			ist weder 0, noch eine 	einstellige Primzahl und 				auch nicht ungerade.");
  }	
 }
}
```


bin ja schon glücklich das ich beim compilieren keine fehler mehr hab... aber das ergebnis stimmt leider nict immer... z.B. wenn ich für a= 14 und b=20 nehme müsste als ergebnis kommen: der Rest ist eine einstellige Primzahl und ungerade, stattdessen kommter Rest ist weder 0, noch eine 	einstellige Primzahl und auch nicht ungerade.

findet jemand den fehler??... bin mir nicht sicher ob es richtig ist wenn man schreibt: case 1: case 2: case 3:    -->geht sowas??


----------



## Gast2 (16. Nov 2010)

Geh einfach die Schleife durch:

```
// n=4;
		boolean b = true;
		for (int i = 1; i <= n - 1; i++) {
			// erster durchgang - i = 1;
			                 //3 
			if ((n % i == 0) && (n / i != n)) {
			  // 3 % 1 == 0 UND  3 / 1 != 4 
		      //  true      UND     true
				b = false;
			  // eigentlich würd ich hier nen break machen - hat ja eigentlich
			  // keinen Sinn weiter zu machen.
			}
		}
```


----------



## benny543 (16. Nov 2010)

das ist jetzt für Aufgabe 2 oder?? 



fassy hat gesagt.:


> Geh einfach die Schleife durch:
> 
> ```
> // n=4;
> ...


----------



## dehlen (16. Nov 2010)

also nur um mal von einem der mehr ahnung hat als ich bestätigt zu bekommen... meine erklärung des programmes war doch richtig oder ?! 

und zu switch ja kannst du so machen... hier :
(Habe das schonmal in einem Thread gepostet... egal hier nochmal für dich ;-)

also switch verzweigt auf basis eines einzelnen wertes in eine beliebige Anzahl von Fällen(cases) daher muss deine Programmierstruktur ca so aussehen:
Java Code:  

```
switch (Ausdruck( {
case Wert1:Anweisung1;
break;
case Wert2:Anweisung2;
break;
//weitere Fälle
default:Anweisung3;
break;
}
```

anhand dessen kannst du dir ja ganz einfach überlegen bei jeder switch Anweisung die du noch haben wirst was welcher Wert ist =)

btw die break-Anweisung sorgt dafür,dass die Auführung nicht die die folgende case-Klausel "durchläuft" 

die default-Klausel die "alle anderen Fälle" abdeckt ist optional.Wenn keine default-Klausel angegeben ist, wird möglicherweise kein Fall ausgeführt

und noch etwas: du brauchst das break nicht immer
wenn du von dem "Durchlaufen" gebrauch machen willst, sodass die z.B ersten 3 Werte zur Ausführung von Anweisung 1 und die Werte 4 und 5 zur Ausführung von Anweisung 2 führen, dann muss deine Struktur so aussehen:
Java Code:  

```
switch (Ausdruck) {
case Wert1:
case Wert2;
case Wert3;
Anweisung1;
break;
case Wert4;
case Wert5;
Anweisung2;
break;
//weiter Fälle hier
default;
Anweisung3;
break;
}
```


----------



## Gast2 (16. Nov 2010)

benny543 hat gesagt.:


> findet jemand den fehler??... bin mir nicht sicher ob es richtig ist wenn man schreibt: case 1: case 2: case 3:    -->geht sowas??



Case "fällt durch"
Aber ich würd es etwas anders machen:


```
public static boolean istGrade(int i){
		return i % 2 == 0;
	}
	
	public static boolean isEinstelligePrimzahl(int i){
		boolean isPrime = false;
		int[] primes = new int[]{2,3,5,7}; // Primzahlen kleiner 10;
		if(i > 9){ // ist auf jeden Fall zweistellig ;)
			return false;
		}
		for(int prime : primes){
			if(i == prime){ // ist eine primzahl aus der liste
				isPrime = true;
				break;
			}
			if(i % prime == 0){
				// durch eine primzahl teilbar - also kein primzahl
				break;
			} else {
				isPrime = true;
			}
		}
		return isPrime;
	}
	
	public static void main(String[] argv) {

		int a, b;
		a = Integer.parseInt(JOptionPane.showInputDialog("a = "));
		b = Integer.parseInt(JOptionPane.showInputDialog("b = "));
		int modResult = a%b;
		
		int restResult = 0; // damit rechnen wir uns ein zweistellige bitmaske für das switch
		
		
		if(isEinstelligePrimzahl(modResult)){
			restResult += 1; // setze das erste bit 
		}
		if(istGrade(modResult)){
			restResult += 2; // setze das zweite bit 
		}
		
		switch (modResult) {
		case 0:
			JOptionPane.showMessageDialog(null, "der Rest ist 0");
			break;
		case 1:
			JOptionPane.showMessageDialog(null, "der Rest ist einstellige Primzahl");
			break;
		case 2:
			JOptionPane.showMessageDialog(null, "der Rest ist grade");
			break;
		case 3:
			JOptionPane.showMessageDialog(null, "der Rest ist grade und einstellige Primzahl");
			break;
		default:
			JOptionPane
					.showMessageDialog(
							null,
							"Der Rest ist weder 0, noch eine  einstellige Primzahl und  auch nicht ungerade.");
		}
	}
```

EDIT:// noch nen kleiner Fehler drin - versuch den mal zu finden


----------



## dehlen (16. Nov 2010)

schöne lösung fassy .. aber in der aufgabe steht sie SOLLEN es mit switch machen ;-)


----------



## Gast2 (16. Nov 2010)

dehlen hat gesagt.:


> schöne lösung fassy .. aber in der aufgabe steht sie SOLLEN es mit switch machen ;-)



Jein - mit switch ist es ja. Es steht ja nicht dabei wie man das switch nutzen muss... ein case von 0 bis 9 ist irgendwie Banane...


----------



## dehlen (16. Nov 2010)

ja ok so gesehen hast du recht... hatte die aufgabe nur so verstanden das es mit case gemacht werden soll ;-)

btw ihr seit mir noch ne antwort schuldig... =)


> also soweit ich das jetzt verstehe (bin auch noch nicht so lange bei java ) müsstest du es demnach so interpretieren
> 
> b ist der Operator der prüft ob eine Aussage wahr oder falsch ist
> es wird deklariert das b = true ist solange die for Schleife ausgeführt wird also solange i kleiner gleich n-1 ist
> ...




UND?? =) danke ihr seid ein super forum!


----------



## Gast2 (16. Nov 2010)

Nicht ganz. b ist eigentlich ersteinmal uninteressant. Zuerst wird festgelegt das b = true ist. Also davon ausgegangen dass die Zahl eine Primzahl ist. In der Schleife wird der index hochgezählt und dann in dem if bestimmt ob beide Ausdrücke true sind. Wenn das zutrifft bedeuted dies dass die Zahl keine Primzahl ist und b wird auf false gesetzt. 

Nachdem die Schleife komplett durchgelaufen ist (was unnötig ist wenn das erste mal b auf false gesetzt wird) wird ein Dialog gezeigt der nur den Wert von b anzeigt.

b sagt also nur ob die eingegebene Zahl eine Primzahl ist oder nicht - spielt in der Berechnung aber keine Rolle.


```
public static boolean istNichtGrade(int i) {
		return !(i % 2 == 0);
	}

	public static boolean isEinstelligePrimzahl(int i) {
		boolean isPrime = false;
		int[] primes = new int[] { 2, 3, 5, 7 }; // Primzahlen kleiner 10;
		if (i > 9 || i == 1) { // ist auf jeden Fall zweistellig und 1 ist keine Primzahl ;)
			return false;
		}
		for (int prime : primes) {
			if (i == prime) { // ist eine primzahl aus der liste
				isPrime = true;
				break;
			}
			if (i % prime == 0) {
				// durch eine primzahl teilbar - also kein primzahl
				break;
			} else {
				isPrime = true;
			}
		}
		return isPrime;
	}

	public static void main(String[] argv) {

		int a, b;
		a = Integer.parseInt(JOptionPane.showInputDialog("a = "));
		b = Integer.parseInt(JOptionPane.showInputDialog("b = "));
		int modResult = a % b;
		System.out.println(a+" % "+b+" = "+modResult);
		if (modResult == 0) {
			JOptionPane.showMessageDialog(null, "der Rest ist 0");
		} else {
			int restResult = 0; // damit rechnen wir uns ein zweistellige
								// bitmaske
								// für das switch 00: 01 => 1, 10 => 2, 11 => 3
			if (isEinstelligePrimzahl(modResult)) {
				System.out.println("Rest "+modResult+" ist einstellige Primzahl");
				restResult += 1; // setze das erste bit
			} else {
				System.out.println("Rest "+modResult+"  ist keine Primzahl");
			}
			if (istNichtGrade(modResult)) {
				System.out.println("Rest "+modResult+"  ist nicht grade");
				restResult += 2; // setze das zweite bit
			} else {
				System.out.println("Rest "+modResult+"  ist grade");
			}
			switch (restResult) {
			case 1:
				JOptionPane.showMessageDialog(null,
						"der Rest ist einstellige Primzahl: "+modResult);
				break;
			case 2:
				JOptionPane.showMessageDialog(null, "der Rest ist ungrade: "+modResult);
				break;
			case 3:
				JOptionPane.showMessageDialog(null,
						"der Rest ist grade und einstellige Primzahl: "+modResult);
				break;
			default: // 0 und alles andere
				JOptionPane
						.showMessageDialog(
								null,
								"Der Rest ist weder 0, noch eine  einstellige Primzahl und  auch nicht ungerade.");
			}
		}
	}
```


----------



## dehlen (16. Nov 2010)

natürlich.... -.- 
ja hast natürlich recht... danke nochmal... so konnte ich wenigstens was hier zu dem problem beitragen und habe trotzdem noch selber was gelernt


----------



## benny543 (16. Nov 2010)

Muss mich auch schon mal bei euch allen bedanken ohne euch hätte ich noch tagelang zu tun bzw. hät ich irgendwann einfach aufgegeben... TOP von euch!!!!

jetzt muss ich aber nochmal ne frage zu 1. stellen und zwar könnte jemand bitte mal eine von den ausdrücken mathematisch herleiten, wo der Operator vor dem = steht?? (also bei d+= 1.5*3+(++a) oder a%= 3/a+3) weil ich ja eine erklärung zu dem ergebnis verfassen muss und ich zwar jetzt die ergebnisse habe durch das programm von fassy:


> Wie wäre es mit ausprobieren?
> 
> Es ist:
> Java Code:
> ...



aber immer noch nicht weiß wie man es berechnet.... hab z.B. bei der Aufgabe d+= 1.5*3+(++a) folgendes gerechnet:

d= d+1.5*3+(1+a)
d=1.0+4.5+1+1
d=7.5 
das ergebnis müsste laut programm aber 15.5 sein
;(


----------



## Gast2 (16. Nov 2010)

d+= 1.5*3+(++a):

d = d + ( 1.5 * 3 + ( 1 + a))

Also zu dem Zeitpunkt wäre das:
a: 0; d: 9.0

Somit:
d = 9.0 + (1.5 * 3 + (1 + 0))
d = 9.0 + (1.5 * 3 + 1 )
d = 9.0 + (4.5 + 1)
d = 9.0 + 5.5
d = 14.5


```
public static void main(String[] argv) {

		int a = 1;
		double d = 1.0;
		a = 46 / 9;
		System.out.println("a: "+a+"; d: "+d);
		a = 46 % 9 + 4 * 4 - 2;
		System.out.println("a: "+a+"; d: "+d);
		a = 45 + 43 % 5 * (23 * 3 % 2);
		System.out.println("a: "+a+"; d: "+d);
		a %= 3 / a + 3;
		System.out.println("a: "+a+"; d: "+d);
		d = 4 + d * d + 4;
		System.out.println("a: "+a+"; d: "+d);
		d += 1.5 * 3 + (++a);
		System.out.println("a: "+a+"; d: "+d);
		d -= 1.5 * 3 + a++;
		System.out.println("a: "+a+"; d: "+d);
		d -= .9;
		System.out.println("a: "+a+"; d: "+d);
	}
```

Um der nächsten Frage vorzubeugen: Denke dran wann bei a++ das inkrement angewendet wird! Erst nach dem die Zeile abgearbeitet wurde! Zu Zeit der Anweisung hat a noch den alten Wert!


----------



## benny543 (16. Nov 2010)

> Also zu dem Zeitpunkt wäre das: a: 0; d: 9.0


warum ist d: 9.0 und a:0


----------



## Gast2 (16. Nov 2010)

Ich gehe mal davon aus das die Änderungen an den Variablen von oben nach unten sich mitverändern, also die Operationen die Werte nachhaltig ändern und nicht immer wieder auf die Startwerte zurückgesetzt werden... Wenn das nicht so ist wäregilt ja d = 1.0 und a = 1 und somit das Ergebniss:

d = 1.0 + (1.5 * 3 + (1 + 1))
d = 1.0 + (1.5 * 3 + 2)
d = 1.0 + (4.5 + 2)
d = 1.0 + 6.5
d = 7.5

Kommt drauf an wie man die Aufgabe interpretiert. Aber ich würde von meiner Annahme ausgehen da damit auch Folgefehler auffallen.


----------



## benny543 (16. Nov 2010)

ah jetzt versteh ich das... aba ich glaub das die leute die sich de aufgabe ausgedacht haben wollten das die werte immer wieder zum Startwert zurückgesetzt werden wegen der Aussage :Nehmen Sie an, dass int a=1 und double d=1.0 gilt, und dass die folgenden Ausdrücke unabhängig voneinander sind.


----------



## Gast2 (16. Nov 2010)

benny543 hat gesagt.:


> und dass die folgenden Ausdrücke unabhängig voneinander sind.



Das hatte ich überlesen. Dann ergibt der Ausdruck d = 7.5.


----------



## Gast2 (16. Nov 2010)

```
int a = 1;
		double d = 1.0;
		a = 46 / 9;
		System.out.println("a: "+a+"; d: "+d);
		a = 1; 
		d = 1.0;
		a = 46 % 9 + 4 * 4 - 2;
		System.out.println("a: "+a+"; d: "+d);
		a = 1; 
		d = 1.0;
		a = 45 + 43 % 5 * (23 * 3 % 2);
		System.out.println("a: "+a+"; d: "+d);
		a = 1; 
		d = 1.0;
		a %= 3 / a + 3;
		System.out.println("a: "+a+"; d: "+d);
		a = 1; 
		d = 1.0;
		d = 4 + d * d + 4;
		System.out.println("a: "+a+"; d: "+d);
		a = 1; 
		d = 1.0;
		d += 1.5 * 3 + (++a);
		System.out.println("a: "+a+"; d: "+d);
		a = 1; 
		d = 1.0;
		d -= 1.5 * 3 + a++;
		System.out.println("a: "+a+"; d: "+d);
		a = 1; 
		d = 1.0;
		d -= .9;
		System.out.println("a: "+a+"; d: "+d);
	}
```

a: 5; d: 1.0
a: 15; d: 1.0
a: 48; d: 1.0
a: 1; d: 1.0
a: 1; d: 9.0
a: 2; d: 7.5
a: 2; d: -4.5
a: 1; d: 0.09999999999999998


----------



## benny543 (16. Nov 2010)

noch vier kleine letzte fragen für heut:
1. warum kommt bei der Rechnung laut Programm -4.5 raus: 
d-= 1.5*3+a++                        -> a++ gilt doch als a+1 oder ist das nur bei ++a?
d= 1-(4.5+1+1)
d= -5.5

2. Wie kann man das Ergebnis, 0.09999999999999998, von d-=.9 mathematisch erklären?

3. Was muss man hier berechnen: byte x = 133 ???

4. Was muss man hier berechnen: int y = (int)9.9009

THX


----------



## XHelp (16. Nov 2010)

1. Mach doch:

```
int a = 5;
System.out.println(a);
System.out.println(a++);
System.out.println(a);
a = 5;
System.out.println(a);
System.out.println(++a);
System.out.println(a);
```
dann solltest du erkennen was los ist

2. Binärdarstellung von Kommazahlen
3und4. wie was muss man da berechen? Das was da steht... :bahnhof:


----------



## Gast2 (16. Nov 2010)

benny543 hat gesagt.:


> noch vier kleine letzte fragen für heut:
> 1. warum kommt bei der Rechnung laut Programm -4.5 raus:
> d-= 1.5*3+a++                        -> a++ gilt doch als a+1 oder ist das nur bei ++a?
> d= 1-(4.5+1+1)
> d= -5.5



Hatte ich oben schon mal geschrieben. Bei dem Post-Inkrement a++ wird a um eins erst nach dem Ausdruck erhöht. a ist in der Zeile 1. Das a++ kannst du komplett ignorieren. Das würde erst in der nächsten Anweisung die danach kommt eine Rolle spielen. ++a ist da anders. Da wird erst inkrementiert und dann der restliche Ausdruck ausgwertet

Also nur d= 1-(4.5+1)



benny543 hat gesagt.:


> 2. Wie kann man das Ergebnis, 0.09999999999999998, von d-=.9 mathematisch erklären?


Durch die Limitierung des Datentypen. Vergleiche z.B. float:

```
float d = 1.0f;
	d -= 0.9f;
	System.out.println(d);
```
0.100000024

Es wird halt irgendwann gerunded.



benny543 hat gesagt.:


> 3. Was muss man hier berechnen: byte x = 133 ???



Nix! Das compiled so mal gar nicht. Ist so kein gültiger Java Ausdruck. Wenn dann müsste man mit [c]byte x = (byte) 133[/c] die 133 auf byte casten.



benny543 hat gesagt.:


> 4. Was muss man hier berechnen: int y = (int)9.9009


Beim casten nach int werden die .9009 "abgeschnitten" - ergo ist y = 9


----------



## Eldorado (16. Nov 2010)

zu 1)
a = 1; 
d = 1.0;
d -= 1.5 * 3 + a++; // a wird zum rechnen benutzt und danach um 1 erhöht => a=2
letzte Zeile ausgeschrieben:
d = d - (1,5*3 + a++)
d = 1.0 - (4,5 + 1)
d = 1.0 - 5,5
d= -4,5

Edit: Einfach zu langsam^^


----------



## benny543 (16. Nov 2010)

habs grad gesehn bei 3. und 4.

3. ist nich möglich weil byte werte max. von -128 bis 127 definiert sind

4. int werte können nicht als dezimalstellen dargestellt werden


----------



## Gast2 (16. Nov 2010)

benny543 hat gesagt.:


> habs grad gesehn bei 3. und 4.
> 
> 3. ist nich möglich weil byte werte max. von -128 bis 127 definiert sind
> 
> 4. int werte können nicht als dezimalstellen dargestellt werden



Bedingt richtig - siehe meine Antwort


----------



## benny543 (16. Nov 2010)

fassy hat gesagt.:


> Bedingt richtig - siehe meine Antwort



jo hab ich schon...^^ hab einen Moment zu früh geantwortet



VIELEN VIELEN DANK NOCHMAL AN ALLE DIE MIR HEUT GEHOLFEN HABEN applaus: :toll OHNE EUCH WÄRE ICH ECHT AUFGESCHMISSEN GEWESENbahnhof... MORGEN PROBIER ICH MICH MAL NOCH AN AUFGABE 3 rtfm UND DANN WERD ICH EUCH BESTIMMT NOCHMAL BELÄSTIGEN MÜSSEN^^


----------



## XHelp (16. Nov 2010)

fassy hat gesagt.:


> Hatte ich oben schon mal geschrieben. Bei dem Post-Inkrement a++ wird a um eins erst nach dem Ausdruck erhöht. a ist in der Zeile 1. Das a++ kannst du komplett ignorieren. Das würde erst in der nächsten Anweisung die danach kommt eine Rolle spielen.



Es wird nicht am Ende des Ausdrucks erhöht, sondern direkt nach dem Auslesen:

```
int a = 5;
int b = a++ + a++;
// b ist 11, a ist 7
```


----------



## Gast2 (16. Nov 2010)

Das ist richtig. Da hab ich noch nie drüber nachgedacht. [c]a++ + a++[/c] ist mir bisher noch nie untergekommen


----------



## Andi_CH (17. Nov 2010)

Hm zwar logisch dass a=11 ist aber ich hab trotzdem 10 erwartet :-( tja, man hat nie ausgelernt


----------



## Eule123 (17. Nov 2010)

benny du hast nicht zufällig den walter in programmierung ? ;-)


----------

