# Newbee vermasselt Prüfung, nun Fehlersuche step-by-step



## morphi79 (11. Oktober 2005)

Hallo Leute,

da ich meine Prüfung in JAVA voll in den Sand gesetzt hab, hoffe ich dass ihr mir etwas weiterhelfen könnt. Ich habe mir nochmals die Aufgaben geholt. Vielleicht könnt Ihr mir dabei helfen, damit ich sehen kann, was ich falsch gemacht habe.

Gleich mal zur ersten Aufgabe, gegeben ist folgendes:

```
public class Hausarbeit1 {

public static void main(String[] args) {

short zahl1 = 1234;

short zahl2 = 5678;

zahl1++;

zahl2++;

int ergebnis = (zahl1 + zahl2) << 4;

short kurz = (short)ergebnis;

System.out.println(zahl1);

System.out.println(zahl2);

System.out.println(ergebnis);

System.out.println(kurz);

}

}
```
 
Nun meine Aufgabe:
Nehmen Sie nun einige Erweiterungen an dieser Klasse vor. Definieren Sie eine Methode toShort(), die ein Argument vom Typ int bekommt, dessen Wert in einen Wert vom Typ short umwandelt und zurückgibt. Definieren Sie ebenso eine Methode toFloat(), die einen Wert vom Typ double in einen Wert vom Typ float umwandelt.
Ersetzen Sie nun den expliziten Cast in der Methode main() durch die Verwendung von toShort(). Dividieren Sie in main() ferner den Wert von Ergebnis durch 9.876 und speichern Sie das Resultat in einer Variable doppelt vom Typ double. Weisen Sie diesen Wert anschließend unter Verwendung von toFloat() einer Variable einfach vom Typ float zu. Ergänzen Sie die Ausgabeanweisungen um die Ausgabe der Werte der beiden neuen Variablen.

Die Methode kann ich doch einfach so einsetzen, oder nicht?
int toShort = short(ergebnis)


----------



## Nospherates (11. Oktober 2005)

Hi,
also für mich klingt das eher nach sowas in der Art:

Auszug Main:

```
short kurz = to_short(ergebnis);
```

Und vorher definierst du noch die Methode to_short:


```
private short to_short (int x){
 return short(x);
}
```

Das gleiche mit leichten Abwandlungen eben für to_Float. Naja die Division war denke ich mal nicht das Problem.
Hoffe mal hab das jetzt richtig verstanden .

Gruß


----------



## morphi79 (11. Oktober 2005)

Wäre dass dann mal der Anfang soweit?


```
public class Hausarbeit1 {

public static void main(String[] args) {

short zahl1 = 1234;

short zahl2 = 5678;

zahl1++;

zahl2++;

int ergebnis = (zahl1 + zahl2) << 4;

short kurz = (short)ergebnis;

 

private short toShort (int x){

 return short(x);

}

short kurz = toShort(ergebnis);

 

private float toFloat (double y) {

 return float(y);

}

float kurz = toFloat(ergebnis);

 

System.out.println(zahl1);

System.out.println(zahl2);

System.out.println(ergebnis);

System.out.println(kurz);

}

}
```


----------



## Nospherates (11. Oktober 2005)

Hi,
naja nicht ganz. Habt ihr Methoden nicht durchgenommen? Zumindest wirkt es auf mich so als wenn es für dich Neuland ist. Es müsste so aussehen:



```
public class Hausarbeit1 {

private short to_Short (int x){
 return short(x);
}

private float to_Float (double y) {
 return float(y);
}

public static void main(String[] args) {

short zahl1 = 1234;
short zahl2 = 5678;
zahl1++;
zahl2++;
int ergebnis = (zahl1 + zahl2) << 4;
short kurz = toShort(ergebnis);

double doppelt = ergebnis / 9.876;
float einfach = toFloat(doppelt);

System.out.println(zahl1);
System.out.println(zahl2);

System.out.println(ergebnis);
System.out.println(kurz);
System.out.println(doppelt);
System.out.println(einfach);
}

}
```

Das ist jetzt schon die ganze Aufgabe glaube ich. Wenn du Verständnisfragen hast stell sie einfach. Blind abschreiben würde dich ja nicht wirklich weiterbringen .

Gruß


----------



## morphi79 (11. Oktober 2005)

naja, wir haben die nur kurz angeschnitten. in der prüfung sind 85% durchgefallen. Aber es bringt mir ja nichts, wenn ich es nicht verstehe. Das mit den Methoden hab ich jetzt die letzten 2 Tage durchgemacht. Es geht ja nur darum, dass ich die richtige Lösung mit meiner geschriebenen Aufgabe verlgeichen kann. Damit kann ich dann am besten sehen, wo meine Schwachpunkte liegen. Ich hoffe es zumindest. Ich glaub jetzt ich habs verstanden. So nun werde ich mal die nächste Aufgabe ansehen. Hoffe Ihr helft mir weiter, wenn ich das nicht verstehe.


----------



## morphi79 (11. Oktober 2005)

Als nächstes hätte ich eine Frage. Ich soll eine eine Klasse Konto erstellen, die in
einfacher Weise ein Bankkonto beschreibt. Das habe ich auch gemacht mit zwei Klassen:
Hier die Klasse Konto

```
public class Konto {
	// Instanzvariable
	private double kontostand;
 
	// Konstruktor
	public Konto(double stand_neu) {
kontostand = stand_neu;
	}
 
	// Kontostand abfragen
	public double getKontostand() {
return kontostand;
	}
 
	// Geldbetrag auf das Konto einzahlen
	public void einzahlen(double betrag) {
kontostand = kontostand + betrag;
	}
 
	// Geldbetrag vom Konto abheben
	public void abheben(double betrag) {
kontostand = kontostand - betrag;
	}
}
```
Hier die Klasse KontoTester

```
public class KontoTester {
	public static void main(String[] args) {
Konto einKonto;
 
// Konto anlegen
einKonto = new Konto(500.00);
System.out.println("Erster Kontostand: " + einKonto.getKontostand());
 
// Vom Konto abheben
einKonto.abheben(150.00);
System.out.println("Kontostand nach abheben von 150.00: "
	 + einKonto.getKontostand());
 
// Auf Konto einzahlen
einKonto.einzahlen(11.23);
System.out.println("Kontostand nach einzahlen von 11.23: "
	 + einKonto.getKontostand());
 
// Vom Konto abheben
einKonto.abheben(400.00);
System.out.println("Kontostand nach abheben von 400.00: "
	 + einKonto.getKontostand());
 
// Auf Konto einzahlen
einKonto.einzahlen(222.50);
System.out.println("Kontostand nach einzahlen von 222.50: "
	 + einKonto.getKontostand());
 
// Vom Konto abheben
einKonto.abheben(47.62);
System.out.println("Kontostand nach abheben von 47.62: "
	 + einKonto.getKontostand());
	}
}
```
 
Jetzt möchte ich folgendes hinzufügen:
- Ein Konto erhält als zusätzliche Eigenschaft eine Kontonummer, die als Wert
vom Typ long gespeichert wird. Die Kontonummer kann nur bei der Erzeugung
eines Konto-Objekts gesetzt werden. Danach soll sie nur noch abgefragt, aber
nicht mehr geändert werden können.
- Die Methode abheben() wird so geändert, dass nur noch Abhebungen möglich
sind, die durch Guthaben gedeckt sind. Die Methode soll einen Wahrheitswert
zurückgeben, der angibt, ob die Abhebung durchgeführt wurde. Wird versucht,
einen Betrag abzuheben, der größer als der Kontostand ist, so soll der
Kontostand unverändert bleiben und der Wert false zurückgegeben werden.
Anderenfalls soll die Abhebung ausgeführt und der Wert true zurückgegeben
werden.
- Die Klasse KontoTester will ich so abändern, das das erzeugte Konto die Kontonummer
12345678 erhalten soll. Am Ende der Methode main() soll die Kontonummer abgefragt
und ausgegeben werden. Bei jeder einzelnen Abhebung soll getestet werden, ob sie
erfolgreich war. Nur, wenn eine Abhebung ausgeführt werden konnte, soll der neue
Kontostand ausgegeben werden, anderenfalls soll jeweils die Meldung „Guthaben
nicht ausreichend.“ ausgegeben werden.
Die Eigenschaft Kontonummer ist ja einfach hinzugefügt. Nur wie kann ich die Kontonummer nur bei der Erzeugung eines Konto-Objekts gesetzt werden und nur noch abfragen, aber nicht mehr ändern?


----------



## Nospherates (11. Oktober 2005)

Hi,
das du die Nummer nur bei Erzeugung erstellen kannst und dann nur noch Abfragen darfst, erreichst du dadurch das du den Wert nur im Konstruktor animmst um ihn da zu setzen. Über eine Methode schaffst du dann die Möglichkeit auf die Nummer zugreifen zu können, aber nur zum lesen. Eine setzende Methode lässt du einfach weg.

Gruß


----------



## morphi79 (11. Oktober 2005)

Also muss ich hier 
	
	
	



```
// Konstruktor
	public Konto(double stand_neu) {
kontostand = stand_neu;
	}
```

die Kontonummer einsetzen, oder?


```
// Konstruktor
	public Konto(double stand_neu, int kontonummer) {
kontostand = stand_neu;
kontonummer = kontonummer;
 }
```
 
und die Methode:

```
// Kontonummer auslesen
	public void kontonummer(int kontonummer) {
kontonummer = kontonummer;	}
```
richtig?


----------



## torsch2711 (11. Oktober 2005)

Aehm, du willst doch die kontonummer auslesen oder?
 Sprich sowas hier machen:


 public int getKontoNummer() {
            return this.kontonummer;
 }

 this ist nicht zwingend notwendig.

 Habs mir nur irgendwie angewöhnt, da wir ja auch OO-orientiert denken 


 Gruss,

 Torsten


----------



## Nospherates (11. Oktober 2005)

du musst zuerst eine entsprechende Variabel deklarieren. Dann den Konstruktor, wie du ja schon korrekt geschrieben hast...

```
private int kontonr;
 // Konstruktor
public Konto(double stand_neu, int kontonummer) {
  kontostand = stand_neu;
  kontonr = kontonummer;
}
```

Und die Methode müsste genau anders rum sein. So wie du sie beschrieben hast würdest du ja die Nummer ändern! Müsste also so aussehen: 


```
// Kontonummer auslesen
public int getKontonummer() {
  return kontonr;	
}
```

Gruß

[EDIT] Siehe teilweise den schnelleren Vorposter  [/EDIT]


----------



## morphi79 (11. Oktober 2005)

ah, ok jetzt kommt es langsam. Dann würde die Klasse Konto so aussehen:

```
public class Konto {
	// Instanzvariable
	private double kontostand;
	private int kontonr;
 
	// Konstruktor
	public Konto(double stand_neu, int kontonummer) {
	kontostand = stand_neu;
	kontonr = kontonummer;
	}
	
	// Kontostand abfragen
	public double getKontostand() {
 return kontostand;
	}
	
	// Geldbetrag auf das Konto einzahlen
	public void einzahlen(double betrag) {
 kontostand = kontostand + betrag;
	}
	
	// Geldbetrag vom Konto abheben
	public void abheben(double betrag) {
 kontostand = kontostand - betrag;
	}
 
	// Kontonummer auslesen
	public int getKontonummer() {
	return kontonr; 
}
}
```
 
und wie bekomme ich sowas hin?
Die Methode abheben() wird so geändert, dass nur noch Abhebungen möglich
sind, die durch Guthaben gedeckt sind. Die Methode soll einen Wahrheitswert
zurückgeben, der angibt, ob die Abhebung durchgeführt wurde. Wird versucht,
einen Betrag abzuheben, der größer als der Kontostand ist, so soll der
Kontostand unverändert bleiben und der Wert false zurückgegeben werden.
Anderenfalls soll die Abhebung ausgeführt und der Wert true zurückgegeben
werden.

Mit einer If Bedinung?


----------



## Nospherates (11. Oktober 2005)

Hi, 
auch das ist ziemlich simpel. Ich geb diesmal keinen Code vor sondern nur die Theorie . 
Die Funktion muss statt void true oder false zurückgeben in Form eins boolean Wertes. False wenn das Konto nicht gedeckt ist und true wenn die Abhebung eben erfolgreich war.
Was nun zurückgegeben wird ermittelst du über eine If-Abfrage. Damit prüfst du ob der Kontostand über dem abzuhebenden Wert liegt oder eben nicht. 
Versuch das mal in Code umzusetzen und poste nochmal .

Gruß


----------



## morphi79 (11. Oktober 2005)

```
// Geldbetrag vom Konto abheben
	public boolean abheben(double betrag) {
if (kontostand=<0) kontostand = kontostand - betrag;
	}
```

so ?


----------



## Nospherates (11. Oktober 2005)

Hm.. teilweise 

Also der Kopf der Methode ist korrekt. Die Abfrage ist nicht wirklich richtig. Der Kontostand muss ja NACH dem Abheben 0 oder höher sein. Momentan testest du ja nur ob er davor 0 oder höher ist.
Ansonsten müsstest du noch ein return true oder false einbauen, je nach Resultat der Abfrage.

gruß


----------



## morphi79 (11. Oktober 2005)

```
// Geldbetrag vom Konto abheben
	public boolean abheben(double betrag) {
if (kontostand - betrag =<0) {kontostand = kontostand - betrag;return true}return false;
	}
```
#
und so?


----------



## TommyMo (11. Oktober 2005)

Hi!

also so gehts auch nicht   

du behebst, wenn der kontostand <= 0 ist, also entweder gleich 0 oder kleiner als 0, also negativ ist. Du solltest dir die if Anweisung noch einmal genauer ansehn. 

Zweitens: soll gleich in der Abfrage abgehoben werden? Du hast ja schon eine Methode die dir Geld von deinem Konto abhebt, die kannst du hier ganz locker einbaun 

Gruß
TOM


----------



## morphi79 (11. Oktober 2005)

```
// Geldbetrag vom Konto abheben
	public boolean abheben(double betrag) {
if (betrag > kontostand) {
return false;}
kontostand = kontostand - betrag;
}
```


----------



## TommyMo (11. Oktober 2005)

Jo, wir sind am richtigen Weg! Sehr gut! 

Wenn du das jetzt allerdings in einen Editor, sagen wir Eclipse eingeben würdest, würdest du einen Fehler erhalten ... Warum? Es fehlt noch eine Kleinigkeit am Ende, also nachdem du den Kontostand neu zugewiesen hast. Kleiner Tipp: ret ...   

Gruß
TOM


----------



## morphi79 (11. Oktober 2005)

```
// Geldbetrag vom Konto abheben
	public boolean abheben(double betrag) {
if (betrag > kontostand) {
return false;}
kontostand = kontostand - betrag;
return true;
```
 
dann dürfte es so passen, oder?

Und wie gehe ich das letzte an?

Die Klasse KontoTester will ich so abändern, das das erzeugte Konto die Kontonummer
12345678 erhalten soll. Am Ende der Methode main() soll die Kontonummer abgefragt
und ausgegeben werden. Bei jeder einzelnen Abhebung soll getestet werden, ob sie
erfolgreich war. Nur, wenn eine Abhebung ausgeführt werden konnte, soll der neue
Kontostand ausgegeben werden, anderenfalls soll jeweils die Meldung „Guthaben
nicht ausreichend.“ ausgegeben werden.

Hier nochmal die Klasse KontoTester

```
public class KontoTester {
	public static void main(String[] args) {
Konto einKonto;
 
// Konto anlegen
einKonto = new Konto(500.00);
System.out.println("Erster Kontostand: " + einKonto.getKontostand());
 
// Vom Konto abheben
einKonto.abheben(150.00);
System.out.println("Kontostand nach abheben von 150.00: "
	 + einKonto.getKontostand());
 
// Auf Konto einzahlen
einKonto.einzahlen(11.23);
System.out.println("Kontostand nach einzahlen von 11.23: "
	 + einKonto.getKontostand());
 
// Vom Konto abheben
einKonto.abheben(400.00);
System.out.println("Kontostand nach abheben von 400.00: "
	 + einKonto.getKontostand());
 
// Auf Konto einzahlen
einKonto.einzahlen(222.50);
System.out.println("Kontostand nach einzahlen von 222.50: "
	 + einKonto.getKontostand());
 
// Vom Konto abheben
einKonto.abheben(47.62);
System.out.println("Kontostand nach abheben von 47.62: "
	 + einKonto.getKontostand());
	}
}
```


----------



## TommyMo (11. Oktober 2005)

Jep, ich würde sagen die Methode abheben(..) stimmt so. 

Hm... bei deiner Main wirst du ein Problem bekommen, und zwar gleich beim Anlegen deines neuen Kontos. Schau dir doch nochmal den Constructor an, den du in den vorherigen Posts beschrieben hast, da fehlt dir bei 
	
	
	



```
... = new Konto(500.00, ...)
```
 noch die Kontonummer (beschrieben durch "..."). 

Die Ausgabe kannst du entweder nach jedem Aufruf der Methode abheben abfragen, da ja von abheben ein boolean Wert zurückgegeben wird, oder gleich direkt in der Methode die Ausgabe managen. Das überlass ich mal dir 

Für die Abfrage der Kontonummer hast du dir bereits einen Getter geschrieben (also eine Methode die dir die Kontonummer liefert). Einfach nur noch einsetzen (auch das überlass ich dir  )

Das sollts eigentlich gewesen sein. Bin schon gespannt auf deine Lösung! 

TOM


----------



## morphi79 (11. Oktober 2005)

mhh.... versuch


```
public class KontoTester {
	public static void main(String[] args) {
 Konto einKonto;
 
 // Konto anlegen
 einKonto = new Konto(500.00, "12345678");
 System.out.println("Die Kontonummer lautet: "+ einKonto.getKontonummer());
		System.out.println("Erster Kontostand: " + einKonto.getKontostand());
 
 // Vom Konto abheben
 einKonto.abheben(150.00);
 if (abheben = true){
 System.out.println("Kontostand nach abheben von 150.00: "
	  + einKonto.getKontostand());}
 System.out.println("Guthaben nicht ausreichend"´)
 
 // Auf Konto einzahlen
 einKonto.einzahlen(11.23);
 System.out.println("Kontostand nach einzahlen von 11.23: "
	  + einKonto.getKontostand());
 
 // Vom Konto abheben
 einKonto.abheben(400.00);
 System.out.println("Kontostand nach abheben von 400.00: "
	  + einKonto.getKontostand());
 
 // Auf Konto einzahlen
 einKonto.einzahlen(222.50);
 System.out.println("Kontostand nach einzahlen von 222.50: "
	  + einKonto.getKontostand());
 
 // Vom Konto abheben
 einKonto.abheben(47.62);
 System.out.println("Kontostand nach abheben von 47.62: "
	  + einKonto.getKontostand());
	}
}
```


----------



## TommyMo (11. Oktober 2005)

Sodala, wir kommen der Sache näher, aber was wäre das Leben ohne Fehler? Langweilig, oder?  In diesem Sinne ein paar Anregungen:



> // Vom Konto abheben
> einKonto.abheben(150.00);
> if (abheben = true){
> System.out.println("Kontostand nach abheben von 150.00: "
> ...



Was passiert hier genau? Lass es uns Schritt für Schritt durchgehn. 

Mit 
	
	
	



```
einKonto.abheben(150.00)
```

rufst du richtigerweise die Methode abheben aus, und überprüfst ob es möglich ist einen Betrag abzuheben. Soweit richtig! Im nächsten Schritt versuchst du eine Abfrage zu gestalten, ob der Wert von einKonto.abheben true oder false zurückliefert. Was du aber hier machst, ist das Aufrufen von einer Methode die es nicht gibt ... du hast keine Klassenmethode, das sind Methoden die in einer Klasse global zu Verfügung stehen (aber egal), die abheben heißt. Du hast lediglich die einKonto.abheben Methode, also kannst du auch die hier nur einsetzen. Da die Methode ja einen booleschen Wert zurückliefert, und if-Anweisungen nur boolesche Ausdrücke, also wahr oder nicht wahr, interpretieren können, solltest du die Methode gleich einbauen, also z.B. so:


```
if (einKonto.abheben(150)) { ... }
```

Was erhält man dabei? Du erhälst dabei die Aussage, "Ja, ich kann geld abheben" oder die Aussage "Nein, des geht nicht". Angenommen du kannst deine 150 abheben, dann liefert die Methode den Wert true, also geht die if-Anweisung in den {} Bereich. Hier kannst du dann auch spezifizieren was geschen soll, wenn dieser Fall eintritt (z.b. eine Ausgabe mit "Erfolgreich beho...."   ). Ist der Wert allerdings "false", also nicht erfüllt, dann wird nichts weiter passieren, und der schöne Code den du in den Bereich {} geschrieben hast, tja, der wird nicht ausgeführt. Um nun aber den "false" Fall auch abdecken zu können, gibt es ein ganz gefinkeltes "else". Das mußt du gleich darunter anbringen, z.B. so: 


```
if ( ... ) {
 .....
}
else {
 ...
}
```

Hier kannst du wiederum spezifizieren was passieren soll. In deinem Fall sagt das aus, dass keine Behebung möglich war ... also muss die Ausgabe lauten "Leider ...". 

So,ich hoffe ich hab dir nicht alles verraten 

Also, auf ein Neues 

TOM


----------



## TommyMo (11. Oktober 2005)

Ok, Rechschreibfehler sind bitte zu entschuldigen


----------



## morphi79 (11. Oktober 2005)

```
// Konto anlegen
 einKonto = new Konto(500.00, "12345678");
 System.out.println("Die Kontonummer lautet: "+ einKonto.getKontonummer());
		System.out.println("Erster Kontostand: " + einKonto.getKontostand());
 
 // Vom Konto abheben
 einKonto.abheben(150.00);
 if (einKonto.abheben(150)){
 System.out.println("Kontostand nach abheben von 150.00: "
	  + einKonto.getKontostand());}
 else{
 System.out.println("Guthaben nicht ausreichend"´);
 }
```
 also sollte es so aussehen?


----------



## TommyMo (11. Oktober 2005)

Jooo! Jetzt haben wirs gleich!!

Das einzige was du jetzt noch bedenken mußt, ist, dass jedesmal, wenn du die Methode meinKonto.abheben(..) aufrufst, egal ob in einer if-Anweisung oder nicht, der Betrag, sagen wir er ist valide, und darf abgehoben werden, auch tatsächlich abgehoben wird! Also in deinem Fall werden statt 150 Geldeinheiten 300 Geldeinheiten abgezogen. Der Rest stimmt!

TOM


----------



## kroesi (11. Oktober 2005)

Bis auf 


```
if (kontostand - betrag =<0)
```

sieht es gut aus , muss aber heissen :


```
if (kontostand - betrag >=0)
```

Sonst hebst dur nur ab, wenn du auf jedenfall kein Geld mehr hast oder minus machst ...   

Weiter so,

Krösi


----------



## TommyMo (11. Oktober 2005)

Ein Tipp noch, solche Aufgaben sind leicht mit einem Debugger nachzuvollziehen, also am besten ausprogrammieren und mit einem Debugger drüberfahren. Dann kannst du auch erkennen wie/was/wo passiert, welche Werte deine Variablen haben etc. 

TOM


----------



## morphi79 (11. Oktober 2005)

kroesi hat gesagt.:
			
		

> Bis auf
> 
> 
> ```
> ...


 
HÄ? Wo ist denn das?


----------



## morphi79 (11. Oktober 2005)

TommyMo hat gesagt.:
			
		

> Jooo! Jetzt haben wirs gleich!!
> 
> Das einzige was du jetzt noch bedenken mußt, ist, dass jedesmal, wenn du die Methode meinKonto.abheben(..) aufrufst, egal ob in einer if-Anweisung oder nicht, der Betrag, sagen wir er ist valide, und darf abgehoben werden, auch tatsächlich abgehoben wird! Also in deinem Fall werden statt 150 Geldeinheiten 300 Geldeinheiten abgezogen. Der Rest stimmt!
> 
> TOM


 
muss dann das hier 
	
	
	



```
if (einKonto.abheben(150)
```
 
so lauten? 

```
if (einKonto.abheben()
```


----------



## TommyMo (11. Oktober 2005)

Noch von der ersten Seite in der du die abheben Methode implementierst


----------



## TommyMo (11. Oktober 2005)

Nope, du kannst den ersten Aufruf von einKonto.abheben( ... ) einfach weglassen. Der Aufruf in der if-Anweisung reicht völlig. 

TOM


----------



## morphi79 (11. Oktober 2005)

```
// Vom Konto abheben
einKonto.abheben(150.00);
if (einKonto.abheben()){
System.out.println("Kontostand nach abheben von 150.00: "
	 + einKonto.getKontostand());}
else{
System.out.println("Guthaben nicht ausreichend"´);
}
```
 also passt das dann so?


----------



## TommyMo (11. Oktober 2005)

Falsche Version:

```
// behebe 150 geldeinheiten ...
einKonto.abheben(150);

// behebe 150 geldeinheiten ...
if (einKonto.abheben(150)) {
 ....
}
```

Also gesamt: 300 Geldeinheiten, du willst aber nur 150 beheben.

Das hier ist dir richtige Version:

```
// behebe 150 geldeinheiten ...
if (einKonto.abheben(150)) {
 ....
}
```

TOM


----------



## morphi79 (11. Oktober 2005)

```
public class KontoTester {
	public static void main(String[] args) {
 Konto einKonto;
 
 // Konto anlegen
 einKonto = new Konto(500.00, "12345678");
 System.out.println("Die Kontonummer lautet: "+ einKonto.getKontonummer());
		System.out.println("Erster Kontostand: " + einKonto.getKontostand());
 
 // Vom Konto abheben
 einKonto.abheben();
 if (einKonto.abheben(150.00)){
 System.out.println("Kontostand nach abheben von 150.00: "
	  + einKonto.getKontostand());}
 else{
 System.out.println("Guthaben nicht ausreichend"´);
 }
 // Auf Konto einzahlen
 einKonto.einzahlen(11.23);
 System.out.println("Kontostand nach einzahlen von 11.23: "
	  + einKonto.getKontostand());
 
 // Vom Konto abheben
 einKonto.abheben();
 if (einKonto.abheben(400.00)){
 System.out.println("Kontostand nach abheben von 400.00: "
	  + einKonto.getKontostand());}
 else{
 System.out.println("Guthaben nicht ausreichend"´);
 }
 
 // Auf Konto einzahlen
 einKonto.einzahlen(222.50);
 System.out.println("Kontostand nach einzahlen von 222.50: "
	  + einKonto.getKontostand());
 
 // Vom Konto abheben
 einKonto.abheben();
 if (einKonto.abheben(47.62)){
 System.out.println("Kontostand nach abheben von 47.62: "
	  + einKonto.getKontostand());}
 else{
 System.out.println("Guthaben nicht ausreichend"´);
 }
	}
}
```


----------



## TommyMo (11. Oktober 2005)

Oki doki, ich hab mich vielleicht nicht genau ausgedrückt. Was ich meinte war, lass das erste einKonto.abheben(...) weg. Bei dir siehts so aus:


```
// Vom Konto abheben
 einKonto.abheben();
 if (einKonto.abheben(400.00)){
 System.out.println("Kontostand nach abheben von 400.00: "
	  + einKonto.getKontostand());}
 else{
 System.out.println("Guthaben nicht ausreichend"´);
 }
```

einKonto.abheben(), abgesehen davon, dass es nicht funktionieren würde, da ein float Parameter erwartet werden würde ..., ist nicht notwendig. Lass es einfach weg. Wenn du es nämlich dabehälst, wird die Methode zweimal ausgeführt, also einmal vor, genau an der Stelle die wir gerade diskutieren, als auch IN der if-Anweisung. Die richtige Lösung muss also lauten:


```
// Vom Konto abheben
 if (einKonto.abheben(400.00)){
 System.out.println("Kontostand nach abheben von 400.00: "
	  + einKonto.getKontostand());}
 else{
 System.out.println("Guthaben nicht ausreichend"´);
 }
```

Das reicht vollkommen für das Behenben von 400 Geldeinheiten. 

Diese ganzen Abfragen könntest du dir aber ersparen, und es zentral in der Methode ausgeben. Dazu aber mehr, wenn du das Beispiel hier richtig auf die Reihe bekommen hast


----------



## morphi79 (11. Oktober 2005)

also dann so 



```
public class KontoTester {
	public static void main(String[] args) {
 Konto einKonto;
 
 // Konto anlegen
 einKonto = new Konto(500.00, "12345678");
 System.out.println("Die Kontonummer lautet: "+ einKonto.getKontonummer());
		System.out.println("Erster Kontostand: " + einKonto.getKontostand());
 
 // Vom Konto abheben
 if (einKonto.abheben(150.00)){
 System.out.println("Kontostand nach abheben von 150.00: "
	  + einKonto.getKontostand());}
 else{
 System.out.println("Guthaben nicht ausreichend"´);
 }
 // Auf Konto einzahlen
 einKonto.einzahlen(11.23);
 System.out.println("Kontostand nach einzahlen von 11.23: "
	  + einKonto.getKontostand());
 
 // Vom Konto abheben
 if (einKonto.abheben(400.00)){
 System.out.println("Kontostand nach abheben von 400.00: "
	  + einKonto.getKontostand());}
 else{
 System.out.println("Guthaben nicht ausreichend"´);
 }
 
 // Auf Konto einzahlen
 einKonto.einzahlen(222.50);
 System.out.println("Kontostand nach einzahlen von 222.50: "
	  + einKonto.getKontostand());
 
 // Vom Konto abheben
 if (einKonto.abheben(47.62)){
 System.out.println("Kontostand nach abheben von 47.62: "
	  + einKonto.getKontostand());}
 else{
 System.out.println("Guthaben nicht ausreichend"´);
 }
	}
}
```


----------



## TommyMo (11. Oktober 2005)

Yeeehaaa!! Du hast es


----------



## TommyMo (11. Oktober 2005)

Eine Verfeinerung wäre dann noch, damit du dir die ständige Abfragerei ersparst, dass du die if-Abfrage in die Methoden reinnimmst. Was mein ich damit schon wieder?  Ganz einfach, so wies jetzt gemacht wird, mußt du nach jeden Methodenaufruf


```
if (einKonto.abheben(..)) {
 System.out.println ....
}
else {
 System.out.println ...
}
```

abfragen. Das kannst du aber eigentlich schon in deiner Methode machen ... . Also, wenn behoben werden darf, gleich einen Output auf die Console rausschreiben ... . Das Gleiche beim Einzahlen


----------



## morphi79 (11. Oktober 2005)

TommyMo hat gesagt.:
			
		

> Eine Verfeinerung wäre dann noch, damit du dir die ständige Abfragerei ersparst, dass du die if-Abfrage in die Methoden reinnimmst. Was mein ich damit schon wieder?  Ganz einfach, so wies jetzt gemacht wird, mußt du nach jeden Methodenaufruf
> 
> 
> ```
> ...


 
ok, das werde ich mir heute abend reinziehen, das andere ist mir jetzt klar soweit


----------



## morphi79 (11. Oktober 2005)

ich will aber noch eine kleine sache angehen, welche so aussieht:


```
public class TestExceptions {
static String arr[] = {"Alpha", "Beta", "Gamma", "Zeta"};
public static void zeigeEintrag(int index) {
System.out.println("Eintrag " + index + " lautet: " +
arr[index]);
}
public static void main(String args[]) {
int index = Integer.parseInt(args[0]);
zeigeEintrag(index);
}
}
```
 
Wenn ich alles bis jetzt richtig gemacht habe, dann wandelt die Methode main() das erste Kommandozeilenargument in einen Wert vom Typ int um und ruft mit diesem Argument die Methode zeigeEintrag() auf. Diese Methode gibt den entsprechenden Eintrag des Arrays arr aus. Das wäre schon mal ein Teil der Aufgabe.

Jetzt soll die Klasse so umgeschrieben werden, dass die Methode zeigeEintrag() keine Exception
wirft, wenn der übergebene Index außerhalb der Array-Grenzen liegt, sondern
soll in einem solchen Fall die Meldung ausgegeben werden, dass es keinen Eintrag
mit diesem Index gibt. 
Als Hinweis ist noch gegeben: Verwenden Sie dazu Anweisungen zur Ausnahmebehandlung, nicht die Eigenschaft length des Arrays.
Ausnahmen, die durch ein fehlendes oder nicht numerisches Kommandozeilenargument auftreten, müssen nicht behandelt werden.


----------



## TommyMo (11. Oktober 2005)

Sehr gut! Dann wünsch ich dir noch fröhliches Schaffen! Der nächste Antritt wird schon gut laufen. 

Gruß
TOM


----------



## TommyMo (11. Oktober 2005)

Oki doki. Das hört sich, wenn ichs richtig verstanden habe, nach einem Try-Catch Block an.

Try-Catch is klar? 

Wenn ja, pack einfach die Zuweisung oder den Zugriff auf das Array in den Try Block, und die Behandlung, was du im Gegenfall machen willst, also wenn ein Fehler auftritt, in den Catch-Block. 

Gruss
TOM


----------



## kroesi (11. Oktober 2005)

Hi zusammen !

Also, sorry, aber ich glaub mein Browser spinnt, der hat mir die Seite heute auf nem anderen Rechner ganz anders dargestellt. Wollte nix posten, was eh schon gelöst ist und hier die Newbies verwirren.   

Werd mal meinen Browser-Cache löschen.

Glückwunsch übrigens, die nächste Prüfung klappt dann schon !

Krösi


----------



## morphi79 (12. Oktober 2005)

TommyMo hat gesagt.:
			
		

> Eine Verfeinerung wäre dann noch, damit du dir die ständige Abfragerei ersparst, dass du die if-Abfrage in die Methoden reinnimmst. Was mein ich damit schon wieder?  Ganz einfach, so wies jetzt gemacht wird, mußt du nach jeden Methodenaufruf
> 
> 
> ```
> ...


 
danke dir nochmals für deine ausführungen. hab mir es gestern abend angesehen und noch 2 aufgaben gemacht. ich glaub das hab ich jetzt drin.


----------



## morphi79 (12. Oktober 2005)

TommyMo hat gesagt.:
			
		

> Oki doki. Das hört sich, wenn ichs richtig verstanden habe, nach einem Try-Catch Block an.
> 
> Try-Catch is klar?
> 
> ...


mh... naja so klar ist das nicht.


----------



## morphi79 (12. Oktober 2005)

```
public class TestExceptions {
static String arr[] = {"Alpha", "Beta", "Gamma", "Zeta"};
public static void zeigeEintrag(int index) {
System.out.println("Eintrag " + index + " lautet: " +
arr[index]);
}
public static void main(String args[]) {
int index = Integer.parseInt(args[0]);
zeigeEintrag(index);
}
}
```


irgendwie so müsste das funktionieren, oder

```
try {
			zeigeEintrag();
		} catch(NichtMoeglichException) {
			System.out.println("Betrag kann nicht abgehoben werden");
		}
	}
}
```


----------



## TommyMo (12. Oktober 2005)

Hi!

Hm ... also nochmal zurück zur Aufgabenstellung: 

Mußt du eine eigene, d.h. selbstimplementierte Exceptionbehandlung implementieren, oder auf der gegebenen sehr guten von Java aufbauen? Wenn du auf die von Java aufbauen kannst, brauchst du dir keine eigene Klasse implementieren, wenn ja, dann muss diese Klasse von ... moment, ich bin mir jetzt auch nicht sicher, aber ich glaube Exception abgeleitet sein. 


```
public class MyTerribleExamException extends Exception {
 ...
}
```

Aber zunächst mal eine kleine Einführung in Exception, oder Fehlerbehandlung (soweit ich das verstanden habe zumindest  )

Exceptions sind nichts anderes als definierte Fehler, die bei gewissen Bedingungen auftauchen und "geworfen" werden. Dies erleichtert einerseits das Kontrollieren von Code, da du zur Laufzeit, also wenn der Code ausgeführt wird, einen definierten Fehler vorfindest, wenn ein solcher Fehlerfall auftritt, und zweitens hat man so auch die Möglichkeit das eigene Fehler oder Fehlerbedingungen zu definieren. Die Syntax sieht wie folgt aus:

Methode die eine Exception werfen soll:

```
public void myTestExceptionMethod( ... ) throws MyTerribleExamException {
 // do your stuff ...
 // if wrong then ...
 throw new MyTerribleExamException ("Fehlerbeschreibung");
}
```

Du siehst, es gibt also Methoden die Exceptions "werfen" (throw). Nun, wenn diese Methode verwendet wird, kann es eben passieren, dass ein Fehler auftritt, und eine Exception geworfen wird. Was, wenn das jetzt passiert? Ganz einfach, das Zauberwort, oder die Wörter sind "try-catch". Mit HIlfe von sogenannten try-catch Blöcken kannst du Exceptions jeglicher Art abfangen und auch behandeln (es gibt dann noch soetwas wie final, aber das wollen wir hier mal aussparen). Im try Block wird, wie der Name schon sagt, "versucht" etwas bestimmtes zu machen, z.b. auf einen Index eines Arrays zuzugreifen. Hierbei wird eine sensible Methode oder ein Vorgang ausgeführt. 


```
// wir befinden uns in einer beliebigen methode, z.b. main ....
try {
 // aufruf des sensiblen codes, der eine Exception werfen kann ...
 myTestExceptionMethod(...);
}
```

Hierbei können nun Exceptions auftreten. Der try Block registriert nun diesen Exceptionwurf, und leitet ihn an den catch Block (ums vorsichtig auszudrücken) weiter. Im catch Block wird diese Exception abgefangen und alles was dann IM catch Block an definierten Vorgehensweisen festgelegt worden ist, wird ausgeführt. Dies könnte, wie im Beispiel hier, eine Ausgabe auf die Console sein. 


```
catch (MyTerribleExamException e) {
 // reagiere auf die abgefangene Exception ...
 System.out.println("Jo! Eine Exception ist aufgetreten!");
}
```

Wenn man nicht genau weiß, welche Exception aufgetreten ist, dann kann man auch statt "MyTerribleExamException" einfach nur "Exception" schreiben (das ist möglich, da ja ein Objekt geworfen wird, und alle Exceptionklassen von Exception abgeleitet worden sind). 

Hm ... jo, ich hoffe es war einigermassen verständlich für dich. Wenn nicht, einfach posten 

Gutes Schaffen wünsch ich!

Gruß
TOM


----------



## Dennis Wronka (12. Januar 2006)

@morphi79:
Ich denk das probieren wir nochmal, denn mit sowas kann niemand arbeiten.
Gib doch mal an was Du genau nicht verstanden hast.


----------



## morphi79 (12. Januar 2006)

wenn ich diesen code habe


```
public class TestExceptions {
static String arr[] = {"Alpha", "Beta", "Gamma", "Zeta"};
public static void zeigeEintrag(int index) {
System.out.println("Eintrag " + index + " lautet: " +
arr[index]);
}
public static void main(String args[]) {
int index = Integer.parseInt(args[0]);
zeigeEintrag(index);
}
}
```
 
und möchte das machen:
Modifizieren Sie die Klasse so, dass die Methode zeigeEintrag() keine Exception wirft, wenn der übergebene Index außerhalb der Array-Grenzen liegt. Stattdessen soll in einem solchen Fall die Meldung ausgegeben werden, dass es keinen Eintrag mit diesem Index gibt. Verwenden Sie dazu Anweisungen zur Ausnahmebehandlung, nicht die Eigenschaft length des Arrays.

Muss ich dann zuerst eine Klasse mit extends bauen?


----------



## Dennis Wronka (12. Januar 2006)

Ich hab zwar nicht viel Ahnung von Java, aber fuer sowas ist doch try...catch zustaendig.

Also ein Konstrukt dieser Art (oder aehnlich):

```
try
{
 //
}
catch (Exception exc)
{
 //
}
```


----------



## morphi79 (12. Januar 2006)

in einer eigenen klasse oder?


----------



## Snape (12. Januar 2006)

Moin,
für mich sieht das eher danach aus:

```
public static void zeigeEintrag(int index)
{
  if ( index < 0 || index >= arr.length )
  {
    System.out.println("Fehlerhafter Index uebergeben");
  }
  else
  {
    System.out.println("Eintrag " + index + " lautet: " + arr[index]);
  }
}
```


----------



## morphi79 (12. Januar 2006)

jetzt bin ich noch mehr verwirrt....


----------



## NomadSoul (12. Januar 2006)

Snape hat gesagt.:
			
		

> Moin,
> für mich sieht das eher danach aus:
> 
> ```
> ...


Verwenden Sie dazu Anweisungen zur Ausnahmebehandlung, nicht die Eigenschaft length des Arrays

genau so soll er es nicht machen.
Er soll die ArrayOutOfBounce Exception fangen.


----------



## morphi79 (12. Januar 2006)

das mit try catch ist also das was ich brauche. muss ich dafür ne extra klasse machen? schon oder?


----------



## Snape (12. Januar 2006)

Nein, eher

```
public static void zeigeEintrag(int index)
{
  try
  {
    System.out.println("Eintrag " + index + " lautet: " + arr[index]);
  }
  catch(Exception e)
  {
    System.out.println("Fehlerhafter Index uebergeben");
  }
}
```


----------



## morphi79 (12. Januar 2006)

mhh. und die einfach hinzufügen? 


oh ist das kompliziert. ich wünsche keinem den lehrer, den ich in java hatte und alles aus büchern lernen ist sehr schwierig. danke für eure hilfe schon einmal. 

aber nochmal zurück. füge ich die einfach ein?


----------



## TommyMo (12. Januar 2006)

Exception ist eine Klasse im Java Framework. Da brauchst du keine neue Klasse erstellen. Ich hatte das aus deiner Angabe so verstanden, dass du eine eigene Klasse machen sollst dafür, das ist nämlich möglich, also von Exception abzuleiten. Wenn du nur einfaches Exceptionhandling verwenden möchtest reicht die Ausführung von Snape vollkommen. 

Gruß
TOM


----------

