Geldwechselmaschine

Java-Forum Java-Grundlagen
1

Hallo liebe Forenuser/member,

ich bin lebensälterer Student (30 J.) im ersten Semester Wirtschaftsinfo und soll einen Geldwechselautomaten programmieren

vorab hierzu …ich bin blutjunger anfänger und sitze seit drei wochen jeden tag mehrere stunden am problem…ich bin endgültig am ende mit meinem latein und hoffe jemand kann mir weiterhelfen…wenns geht bitte so dass ich es auch nachvollziehen kann:

Aufgabe 1 : Klasse Geldwechselautomat

Entwerfen Sie eine Klasse, die einen Geldwechselautomaten darstellt. Dieser soll beliebige Geldbeträge so auf verschiedene Münzen aufteilen, dass die Gesamtzahl der Münzen möglichst klein ist.
Beispiel für einen Programmlauf (Benutzereingaben sind farblich hervorgehoben):

Eingabe: 7,46 €

Ausgabe:
3 Muenze/n zu 2,00 €
1 Muenze/n zu 1,00 €
0 Muenze/n zu 50 Cent
2 Muenze/n zu 20 Cent
0 Muenze/n zu 10 Cent
1 Muenze/n zu 5 Cent
0 Muenze/n zu 2 Cent
1 Muenze/n zu 1 Cent

Weiter?(j/n) j

Die acht Münzwerte (2€, 1€, 50cent, 20cent, 10cent, 5cent, 2cent, 1cent) sind in einem Array der Klasse Geldwechselautomat abzuspeichern.

Definieren Sie für die Klasse Geldwechselautomat folgende Methoden:

Berechnung des einzuwechselnden Betrages in Münzwerte in der Methode umrechnung() 



Einlesen der Geldbeträge in der Methode einlesen(). Achten Sie darauf, dass Geldbeträge sowohl in Euro (z.B. 7,46 €) als auch nur in Cent (z.B. 746 cent) eingegeben werden können. 



Ausgabe der Münzbeträge in der Methode ausgabe() mit den Angaben:
    Ausgabe des zu wechselnden Betrages
    Anzahl der Münzen und Münzwerte 

Achten Sie darauf, für Geldbeträge 2 Nachkommastellen anzuzeigen.
Versuchen Sie, den Betrag so zu wechseln, dass von jedem der acht Münzen etwas dabei ist.. 



Sie können weitere Methoden definieren, wenn Sie welche benötigen.

Aufgabe 2 : main-Funktionin der Klasse Geldwechselautomat

Entwerfen Sie eine main-Funktion zum Starten des Geldwechselautomaten. Es wird ein Objekt der Klasse Geldwechselautomaten erzeugt. Dieses fordert nun den Benutzer auf, einen Geldbetrag einzugeben, um ihn in Münzen zu wechseln. Der Geldwechselautomat wechselt solange, bis der Benutzer eine 0 eingibt.
Hinweise:

Bitte keine Umlaute, kein ß und keine Zeichen oberhalb Ascii-Code 128 in Bezeichnern oder Dateinamen verwenden!
Verwenden Sie sprechende Variablennamen , also nicht "i", sondern "idealgewicht".
Bitte Attribute als "private" deklarieren!

meine Lösung dazu sind zwei Klassen…ich bin schon relativ weit gekommen habe gestern auch mit meinem Tutor geschrieben der hat mir ne kommentierte fassung zurückgeschrieben aber darf nicht mehr sagen weil er die aufgabe auch korrigieren wird.

einmal…

import java.util.Scanner;

public class berechneWechselgeld

{

	public static void main(String[] args) {
		@SuppressWarnings("resource")
		Scanner sc = new Scanner(System.in);

		/**
		 * Deine Abbruchkriterien sind falsch, eine Eingabe ohne Zeichen ist
		 * nicht zugelassen, eine EIngabe mit ',' liefert auch Fehler. cent wird
		 * nicht erkannt, man MUSS Cent schreiben und in jedem Fall wird eine
		 * Endlosschleife produziert
		 */
		String geldbetrag;
																// Warum nicht gleich geldbetrag was zuweisen?
		geldbetrag = sc.nextLine();

		System.out.println("Eingabe in €:");
																// while (!(geldbetrag = Scanner.nextLine()).equals(0))
																// erst Initialisieren, dann klappt das auch mit Vergleichen
																// und wenn du etwas in einem String suchst, dann entweder " " oder
																// einzelnen Buchstabe ' '
		while (!(geldbetrag.equals("0"))) { 					// solange die Eingabe nicht 0 ist
			float wert = umrechnung(geldbetrag);

			Geldwechsel_automat ga = new Geldwechsel_automat();
																// ga.umrechnung(geldbetrag); //-> Der Fehler sagt: du hast für
																// deine Methode den Falschen Datentyp genommen
																// ga.umrechnung(FLOAT!!!!)
			ga.umrechnung(geldbetrag);
			System.out.println(ga);

		}
	}

	private static float umrechnung(String geldbetrag) {
		if (geldbetrag.contains("€")) { 						// Falls das Euro Zeichen vorkommt
			geldbetrag = geldbetrag.replace("€", "").trim(); 	// Zeichen
																// entfernen und
																// leerzeichen
																// entfernen
			return Float.parseFloat(geldbetrag);
		} else if (geldbetrag.contains("Cent")) { 				// Falls das Wort "Cent"
																// vorkommt
			geldbetrag = geldbetrag.replace("Cent", "").trim(); // Wort entfernen und leerzeichen entfernen
			return Float.parseFloat(geldbetrag) / 100f; 		// Wert anpassen
		} else { 												// Ansonsten
			System.out.println("Ungültige Eingabe");
			return 0;
		}
	}
}

und dazu dann passend

public class Geldwechsel_automat 

{
    private int[] wechselgeld = new int[8];				
    
    public int[] umrechnung(float geldbetrag) 
    {
 
        int[] wechselgeld = new int[8];
        int iwechselgeld = Math.round(geldbetrag * 100);
 
 
        // Für 2€
        wechselgeld[0] = iwechselgeld / 200;
        iwechselgeld = iwechselgeld % 200;
 
        // Für 1€
        wechselgeld[1] = iwechselgeld / 100;
        iwechselgeld = iwechselgeld % 100;
 
        // Für 0,50€
        wechselgeld[2] = iwechselgeld / 50;
        iwechselgeld = iwechselgeld % 50;
 
        // Für 0,20€
        wechselgeld[3] = iwechselgeld / 20;
        iwechselgeld = iwechselgeld % 20;
 
        // Für 0,10€
        wechselgeld[4] = iwechselgeld / 10;
        iwechselgeld = iwechselgeld % 10;
 
        // Für 0,05€
        wechselgeld[5] = iwechselgeld / 5;
        iwechselgeld = iwechselgeld % 5;
 
        // Für 0,02€
        wechselgeld[6] = iwechselgeld / 2;
        iwechselgeld = iwechselgeld % 2;
 
        // Für 0,01€
        wechselgeld[7] = iwechselgeld / 1;
        iwechselgeld = iwechselgeld % 1;
 
        this.wechselgeld = wechselgeld;
        return wechselgeld;
 
    }
 
    public String toString() 
 
    {
        {        
 
            String ausgabe = "Ausgabe: ";
            for (int eingabe = 0; eingabe < wechselgeld.length; eingabe++) 
            {
 
                switch (eingabe) 
                {
                case 0:
                    ausgabe += "
 Muenze/n zu 2,00 €:";
                    break;
                case 1:
                    ausgabe += "
 Muenze/n zu 1,00 €:";
                    break;
                case 2:
                    ausgabe += "
 Muenze/n zu 0,50 Euro:";
                    break;
                case 3:
                    ausgabe += "
 Muenze/n zu 0,20 Euro:";
                    break;
                case 4:
                    ausgabe += "
 Muenze/n zu 0,10 Euro:";
                    break;
                case 5:
                    ausgabe += "
 Muenze/n zu 0,05 Euro:";
                    break;
                case 6:
                    ausgabe += "
 Muenze/n zu 0,02 Euro:";
                    break;
                case 7:
                    ausgabe += "
 Muenze/n zu 0,01 Euro:";
                    break;
 
                default:
                    ausgabe += "
 Fehler ";
                    break;
                }
 
                ausgabe += wechselgeld[eingabe];
                ausgabe += " ";
            }
 
            return ausgabe;
 
        }
    }    
}

beide klassen liegen im selben package was meinen namen trägt…

ich saß die ganze nacht über noch dran habe bestimmt zehn kaffe schon intus und sehe den wald vor bäumen nicht mir…

könnt ihr mir sagen wo jetzt der entscheidene fehler liegt…möglichst nachvollziehbar und step by step…

zu mir : ich hatte vorher noch nie progerfahrung…ist also mein erstes semester mit meiner ersten sprache java …bitte seid gnädig mit mir

und danke allen die hilfreiches posten im voraus

[edit SlaterB: aus Titel herausgenommen: „bis Freitag“]

2 
  ga.umrechnung(geldbetrag);
  System.out.println(ga);

du willst doch erst deine statische umrechnungsmethode aufrufen und das Ergebnis dieses Aufrufs dann an ga.umrechnung übergeben

Außerdem ist die Sache etwas verworren:

Bemerkung: ga hat einen Zustand (und println(ga) druckt diesen Zustand aus), wozu dann der Rückgabewert der Methode?

Ich denke mal, die Aufgabe war eher so gemeint, dass der Automat die Konstanten 200,100,50,20,10,5,2,1 in einem Array speichert…

3

Kannst DU mal kurz beschreiben, wass eigentlich Dein Problem ist?

bye
TT

4

Eigentlich hast du die Aufgabe ja völlig verkehrt angegangen.

Tipp: fange klein an, verwende dummy-Methoden, mach immer kleine Schritte (Übersetzten, Testen) usw.

Lies die Aufgabenstellung GENAU

package de.bw;

import java.util.Arrays;

public class WechselgeldMain

{
	public static void main(String[] args) {
		Geldwechselautomat g = new Geldwechselautomat();
        g.einlesen();
		g.umrechnung();
		g.ausgabe();
		// Blödsinn in der Aufgabenstellung:
		// Der Geldwechselautomat wechselt solange, bis der Benutzer eine 0 eingibt.
		// Beispiel für einen Programmlauf (Benutzereingaben sind farblich hervorgehoben): Weiter?(j/n) j
	}
}

//Definieren Sie für die Klasse Geldwechselautomat folgende Methoden:
class Geldwechselautomat{
	
	private int[] muenzen = new int[]{200,100,50,20,10,5,2,1};
	private int[] ausgabe = new int[muenzen.length];
	private int  eingabe;

	//Einlesen der Geldbeträge in der Methode einlesen(). 
	public void einlesen(){
		this.eingabe = 749;
	}
	
	//Berechnung des einzuwechselnden Betrages in Münzwerte in der Methode umrechnung() 
	public void umrechnung(){}
	
	//Ausgabe der Münzbeträge in der Methode ausgabe() mit den Angaben:
	public void ausgabe(){
		System.out.println("Eingabe: "+eingabe+" Ausgabe "+Arrays.toString(ausgabe));
	}
}
5

Hab’s gerade mal getestet. Abgesehen von Kleinigkeiten scheint das schon weitgehend zu funktionieren:

  • Klassenname: „Geldwechselautomat“, nicht „Geldwechsel_automat“ (unwichtig? Naja…)

  • Bei ga.umrechnung(...) muss der float-wert übergeben werden: ga.umrechnung(wert);

  • Ansonsten hängt’s hauptsächlich an der Eingabe/Abbruchbedingung, wie ja auch schon in dem Kommentar steht. Wie viel Fehlerbehandlung da denn nun erwartet wird, weiß man nicht. Im Moment wäre eine Eingabe wie 1.2€3456 gültig, aber sei’s drum. Eine Möglichkeit, die main zu schreiben, wäre

    public static void main(String[] args) 
    {
        @SuppressWarnings("resource")
        Scanner sc = new Scanner(System.in);
        while (true)
        {
            System.out.println("Eingabe in €:");
            String geldbetragString = sc.nextLine();
            if (geldbetragString.equals("0"))
            {
                System.out.println("Tschuess!");
                break;
            }
            float geldbetragFloat = umrechnung(geldbetragString);
            if (geldbetragFloat != 0.0f)
            {
                Geldwechselautomat ga = new Geldwechselautomat();
                ga.umrechnung(geldbetragFloat);
                System.out.println(ga);
            }
        }
    }

mit verschiedenen stilistischen hins und hers (irgendwie finde ich das nicht so „wichtig“. Alles was „wichtig“ ist, steht quasi per Definition nicht in der „main“…)

  • Dass der Ausgabe-String in der „toString“-Methode zusammengebaut wird, ist zwar „praktisch“ und vielleicht OK, aber ich würde dafür zwei Methoden machen:
public String erstelleAusgabeString() {
    // Was vorher in toString stand
    ...
}

public void ausgabe() {
    System.out.println(erstelleAusgabeString());
}

Ist aber wohl auch nur ein Detail.

Das einzige, was ich (im didaktischen Sinn) für wirklich wichtig halte, ist das, was Bleiglanz schon angedeutet hat:

Die acht Münzwerte (2€, 1€, 50cent, 20cent, 10cent, 5cent, 2cent, 1cent) sind in einem Array der Klasse Geldwechselautomat abzuspeichern.

Konkret geht es beim Programmieren oft (und auch wenn mir klar ist, dass man damit manchmal zu weit gehen kann) um Verallgemeinerungen und insbesondere um Automatisierung. Dabei ist oft das Ziel, einen komplexen, komplizierten Prozess (oder eben „Algorithmus“) in Form eines Programms zu beschreiben, und den dann mit verschiedenen Eingaben zu füttern und ablaufen zu lassen. Für dich waren diese „Eingaben“ bisher offenbar die nahe liegenden: Der Geldbetrag der gewechselt werden soll. Das ist aber nicht alles. Im Moment ist die „umrechnung“-Methode nicht schön (und genaugenommen auch die „toString“-Funktion), weil sie repetitiv und nicht erweiterbar sind. Wenn das ganze in Zukunft auch noch 1,50€-Münzen zurückeben können soll, muss die Schleife usw. angepasst werden.

Der Prozess, der dort durchlaufen wird, kann allgemeiner beschrieben werden. Was hast du bisher (mit viel Copy+Paste) in der „umrechnen“-Methode gemacht?


für (jeden münzbetrag in cent) {
    berechne was passende Wechselgeld (d.h. die Anzahl der Münzen für diesen Münzbetrag)
    berechne, wie viel dann noch gewechselt werden muss (dieses "iwechselgeld")
}

Das ist das was DU mit der Tastatur und Copy+Paste ausgeführt hast!

Lass das den Computer machen!

Schau erstmal, dass das Programm „funkioniert“, wie es soll. Dann mach’ eine Sicherheitskopie, die du ggf. am Freitag abgeben kannst, um eine 3- zu bekommen.

Dann versuch’ das Programm zu verbessern:

class Geldwechselautomat {

    private final int muenzWerte[] = new int[] { 200, 100, 50, ... };

    public int[] umrechnung(float geldbetrag) 
    {
        int muenzAnzahl[] = ...;

        for (int i=0; i<muenzWerte.length; i++) 
        {
            muenzAnzahl** = ...
            ...
        }
        return muenzAnzahl;
    }

 
    public String erstelleString(int muenzAnzahl[]) 
    {
        ....
        for (int i=0; i<muenzWerte.length; i++) 
        {
            // In der "erstelleWertString"-Funktion wird dann auch die Sache mit den Kommastellen relevant
            ausgabeString += "Muenze/n zu "+ erstelleWertString(muenzWerte**) +": "+muenzAnzahl**+"
";
        }
        return ausgabeString;
    }    
}

EDIT: Da war Bleiglanz noch schneller, und es stimmt: Du solltest die Klasse genau so strukturieren, wie es in der Aufgabenstellung steht (auch wenn das nicht immer Sinn macht). Bei dem, was ich geschrieben habe, ging es eher um die übergeordnete Idee, bzw. die Frage, warum man denn die Beträge in einem Array speichern sollte usw.

6

Das Stückeln (so heißt das unter Bänkern) könnte man auch mit etwas mehr Objektorientierung gestalten:```class Muenze {
private final name;
private final float wertInEuro;
private int anzahl=0;
public Muenze(float wert, String name){ this.wertInEuro=wertInEuro; this.name=name}

public float berechneRest(float betragInEuro){
this.anzahl = /* hier ausrechnen wie viel von der aktuellen Münze benötigt werden /
float rest = // hier ausrechenen, wie groß der Rest ist */
return rest;
}

public String toString() {
return name+" x "+anzahl;
}
}``````class Stuecklung{
private List muenzen = // alle verfügbaren Münzen
Arrays.asList( // eine standard-Methode zum erstellen von ListenberechneRest
new Munze(“2€”,200.0), new Muenze(“1€”,100.0),new Muenze(“50cent”,50), /* und so weiter */
);

public String berechne(float betragInEuro){
float rest=betragInEuro; // am Anfasng ist alles der Rest…
for(Muenze muenze:muenzen) { // alle oben definierten Muenzendurch gehen
rest = muenze.berechneRest(rest); // jede Münze berechnet, was vom Rest übrig bleibt, nach dem sie sich selbst so oft wie möglich abgezogen hat.
}
return muenzen.toString();
}
}```

Wichtige Randnotiz:
Primitive Datentypen wie Float und Doube sind per se ungenau und für Real-Life-Anwendungen, die Geldwerte Berechnen sollen, ungeeignet.

bye
TT

7

[QUOTE=Timothy_Truckle;119512]Wichtige Randnotiz:
Primitive Datentypen wie Float und Doube sind per se ungenau und für Real-Life-Anwendungen, die Geldwerte Berechnen sollen, ungeeignet.[/QUOTE]

Das stimmt, dennoch hast du oben float benutzt. Wissenschaftliche Aufgaben lassen sich damit aber ganz gut berechnen.

At TO: An einer Stelle oder jeder Stelle wirst du (int) Math.round(Double.parseDouble(value)*100.0) aufrufen müssen, schaue dir diese Methode an:
Double (Java Platform SE 6)
Das Hilft schon ein Stück

(Ich mache immer noch Java SE 1.6)

Sonnige Grüße

8

[quote=CyborgBeta]Das stimmt, dennoch hast du oben float benutzt.[/quote]Schein ja in der Aufgabe so vorgesehen…

[OT][quote=CyborgBeta;119526]Wissenschaftliche Aufgaben lassen sich damit aber ganz gut berechnen.[/quote]Ja, wenn’s nicht so sehr auf die Genauigkeit ankommt sondern mal lieber schnell Ergebnisse bekommen will.[/OT]

bye
TT

9

[OT][QUOTE=Timothy_Truckle;119528]Ja, wenn’s nicht so sehr auf die Genauigkeit ankommt sondern mal lieber schnell Ergebnisse bekommen will.[/QUOTE]

Z. B. der Millimeter- oder Mikrometerbereich, lässt sich damit einfach super berechnen.[/OT]

10

[Ot]Float(/double) ist immer dann geeignet wenn man nicht mit der exakten Zahl von PI rechnet sondern auch 3.14 vollkommen ausreicht und das deckt fast alle Aufgabengebiete der Welt ab, die wissenschaftliche mit eingeschlossen.
Es sei denn es handelt sich um Bänker und ihr Geld.[/ot]

11

Wollt ihr helfen, oder off-topic weiter machen?

12

@TT so schön deine Lösung ist, so geht sie doch an der Aufgabenstellung vorbei!

"Versuchen Sie, den Betrag so zu wechseln, dass von jedem der acht Münzen etwas dabei ist… "

// jede Münze berechnet, was vom Rest übrig bleibt, nach dem sie sich selbst so oft wie möglich abgezogen hat.

Beispiel 4,- zu wechseln. Fängt man mit 2 Euro an, so wäre das ergebnis 2 x 2,-

Fängt man mit -,01 an so käme man auf 400 x -,01

Ein Algorithmus der dies bewerkstelligt ist z.B. einer der über alle Münzen aufsteigend Sortiert versucht immer eine Hinzuzulegen und zur nächsthöheren wechselt, bis kein Restbetrag mehr offen ist.

1 x 0,01 = Rest 3,99
1 x 0,02 = Rest 3,97
1 x 0,05 = Rest 3,92
1 x 0,10 = Rest 3,82
1 x 0,20 = Rest 3,62
1 x 0,50 = Rest 3,12
1 x 1,- = Rest 2,12
1 x 2,- = Rest 0,12

D.G. 2
1 x 0,01 = R 0,11
1 x 0,02 = R 0,09
1 x 0,05 = R 0,04

D.G. 3

1 x 0,01 = R 0,03
1 x 0,02 = R 0,01

D.G. 4

1 x 0,01 = R 0,00

Resultat:
4 x 0,01
3 x 0,02
2 x 0,05
1 x 0,10
1 x 0,20
1 x 0,50
1 x 1,00
1 x 2,00

13

[OT][QUOTE=TMII]Es sei denn es handelt sich um Bänker und ihr Geld.[/QUOTE]

Bitte nicht Flame-war anfangen.[/OT]

helfen

Unklar. Sagen wir, es wird immer die betragsmäßig größte Münze gewählt. Wäre das auch diese möglichst klein?

50 Cent, 1mal 50 Cent, oder 2mal 20 Cent und 1mal 10 Cent.

70 Cent?

Haushaltsübliche Beträge/Stückelung heißt das glaube ich im Fachjargon.

Sry, liegt bei mir auch sehr lange zurück, heißt es Münzbetrag, Münzwert - oder Geldwert? Oder BIP?

Jedenfalls, setze 200, falls kleiner 0, setzte 200-100, falls größer, setze 100-0, falls kleiner, setze 100-100, falls 0=0, setze 100-50 , usw .

So würde ich das glaube ich anfangen.

@TT: Doch nicht für jede Münze ein eigenes Objekt!

14

[quote=CyborgBeta]@TT: Doch nicht für jede Münze ein eigenes Objekt![/quote]Warum nicht? Genau darum geht’s doch in der OO: kleine Klassen mit sehr speziellen Aufgaben, von denen man parametrisierte Objekte erzeugt.

*** Edit ***

[quote=Unregistered;119534]@TT so schön deine Lösung ist, so geht sie doch an der Aufgabenstellung vorbei!

"Versuchen Sie, den Betrag so zu wechseln, dass von jedem der acht Münzen etwas dabei ist… "[/quote]Nunja, Ich hatte bei den Anforderungen bei

[quote=schwertmeister;119502]Dieser soll beliebige Geldbeträge so auf verschiedene Münzen aufteilen, dass die Gesamtzahl der Münzen möglichst klein ist.[/quote]Aufgehört, weil der von Dir zitierte der ersten Anforderung widerspricht.

[quote=CyborgBeta;119535]Unklar. Sagen wir, es wird immer die betragsmäßig größte Münze gewählt. Wäre das auch diese möglichst klein?[/quote]Ich denke ja.
Beispielsweise kannst Du 7 Cent verschieden Stückeln, aber nur eine Stücekung ist minimal:
1x5cent + 1x2Cent = 2 Münzen

und bei 8 Cent klappt das auch:
1x5cent + 1x2Cent + 1x1Cent = 3 Münzen
Alternative:
4x2Cent = 4 Münzen.

Aber wenn DU einen Betrag findes wo das anders ist dann Zeige ihn mir.

bye
TT

15

Was haltet ihr davon?

Hab nochmal neu angefangen und versucht es objektorientierter zu verfassen,
aber funktieren tut es immer noch nicht

     
    public class Geldwechselautomat {
     
    	private int[] muenzenwerte = new int[8];
     
    	public static void main(String[] args)
    	
    	{
    		Geldwechselautomat auto = new Geldwechselautomat();
    		String wert = auto.einlesen();
     
     
    	}
     
    	private void umrechnung(int wert)
    	
    	{
    		int[] wechselgeld = new int[8];
            int iwechselgeld = Math.round(wert * 100);
     
     
            // Für 2€
            wechselgeld[0] = iwechselgeld / 200;
            iwechselgeld = iwechselgeld % 200;
     
            // Für 1€
            wechselgeld[1] = iwechselgeld / 100;
            iwechselgeld = iwechselgeld % 100;
     
            // Für 0,50€
            wechselgeld[2] = iwechselgeld / 50;
            iwechselgeld = iwechselgeld % 50;
     
            // Für 0,20€
            wechselgeld[3] = iwechselgeld / 20;
            iwechselgeld = iwechselgeld % 20;
     
            // Für 0,10€
            wechselgeld[4] = iwechselgeld / 10;
            iwechselgeld = iwechselgeld % 10;
     
            // Für 0,05€
            wechselgeld[5] = iwechselgeld / 5;
            iwechselgeld = iwechselgeld % 5;
     
            // Für 0,02€
            wechselgeld[6] = iwechselgeld / 2;
            iwechselgeld = iwechselgeld % 2;
     
            // Für 0,01€
            wechselgeld[7] = iwechselgeld / 1;
            iwechselgeld = iwechselgeld % 1;
     
            this.muenzenwerte = wechselgeld;
            
     
    	}
     
    	private String einlesen()
    	
    	{
    		System.out.println("Eingabe: "); 
    		String gescannt;
    		Scanner scanner = new Scanner(System.in); 
    		while(true)
    		{
    			gescannt = scanner.nextLine();
    			System.out.println(gescannt);
    			if(gescannt.equals("0 Cent") | gescannt.equals("0 €"))
    			{
    				System.out.println("Ohne Geldeinwurf kein weiteres wechseln mehr möglich...");
    				break;
    			}
    			int wert = getWert(gescannt);
    			umrechnung(wert);
    		}	
     
    		scanner.close();
     
    		return gescannt;
    	}
     
    	private void auslesen()
    	
    	{
    		{        
    			 
                String auslesen = "Ausgabe: ";
                for (int eingabe = 0; eingabe < muenzenwerte.length; eingabe++) 
                {
     
                    switch (eingabe) 
                    {
                    case 0:
                        auslesen += "
 Muenze/n zu 2,00 €:";
                        break;
                    case 1:
                        auslesen += "
 Muenze/n zu 1,00 €:";
                        break;
                    case 2:
                        auslesen += "
 Muenze/n zu 0,50 Euro:";
                        break;
                    case 3:
                        auslesen += "
 Muenze/n zu 0,20 Euro:";
                        break;
                    case 4:
                        auslesen += "
 Muenze/n zu 0,10 Euro:";
                        break;
                    case 5:
                        auslesen += "
 Muenze/n zu 0,05 Euro:";
                        break;
                    case 6:
                        auslesen += "
 Muenze/n zu 0,02 Euro:";
                        break;
                    case 7:
                        auslesen += "
 Muenze/n zu 0,01 Euro:";
                        break;
     
                    default:
                        auslesen += "
 Fehler ";
                        break;
                    }
     
                    auslesen += muenzenwerte[eingabe];
                    auslesen += " ";
                }
    		}
        }
     
    	private int getWert(String wert)
    	
    	{
    		int eingabe = 0;
     
    		String[] a = wert.split(" ");
    		if(a[1].equals("Cent")){
    			eingabe = Integer.parseInt(a[0]);
    		} else {
    			String b = a[0].replace(",", "");
    			eingabe = Integer.parseInt(b);
    		}
    		return eingabe;
    	}
    }```
16

Stimmt, danke, so einen Betrag gibt es wahrscheinlich nicht, aber ich weiß nicht, wie man das zeigen kann. Lina?

At TO:
Let me google that for you
Let me google that for you
dann landest du bei java-forum
und Datei: WechselGeld.java ,
was ich aber nicht ganz verstehe.
auto liber autom oder automat heißen.

@ TT : Woher weiß ich, daß eine Folge von Münzbeträgen minimal ist? (Sry, für diese Frage an dieser Stelle)
Also wenn das mit 200, 100, 50, 20 , usw. nicht so wäre, bräuchte ich eine Heuristik oder?

17

wichtiger als 150 Zeilen zu schaffen ist ein paar wenige auch zu verstehen und zu kontrollieren,

was für Arten von Eingaben willst du haben, welche Werte sollen dafür rauskommen?
im Moment funktioniert ‚300 Cent‘ zu Wert 300, oder auch ‚3,00 Euro‘ zu Wert 300,

und in umrechnung() wird nochmal 100 multipliziert zu iwechselgeld = 30000, so gewünscht?
mit einfachen System.out.println() der Zwischenvariablen festzustellen

kann man natürlich zu 150 Zwei Euro-Münzen machen, die Rechnung funktioniert auch immerhin,
mit noch einem ausrechnen()-Aufruf und darin auch tatsächlich Ausgabe des zusammengebauten Strings würde man schon was sehen,

lauter einfache Schritte, woran scheitert es?
wichtig: durchatmen, ganz elementar kontrollieren wer welche Methoden aufruft,
Zwischenstände auch so ausgeben, muss nicht sofort die saubere Endausgabe sein,

auch ruhig zu Beginn jeder Methode eine Ausgabe als Kontrolle ob sie und in welcher Reihenfolge sie aufgerufen werden,
einfachste Schritte zum Nachvollziehen des eigenen Programms, angewöhnen!

18

ja ich glaube ich bin grade etwas betriebsblind…sitze seit heute morgen um 10 dran (abgezogen zwei mahlzeiten und ne brise frischluft auf balkon)…kann glei nicht mehr…das muss aber fertig werden

19

[quote=schwertmeister]Hab nochmal neu angefangen und versucht es objektorientierter zu verfassen[/quote]Wenn es objektorientiert wäre gäbe es irgendwo auch Objekte.

[quote=schwertmeister;119541]aber funktieren tut es immer noch nicht[/quote]So eine unspezifische Aussage hilft nicht weiter.

Fang mit der einfachsten Funktionalität an und teste diese getrennt, am besten automatidiert mit UnitTests. ei den meisten IDE’s ist JUnit bereits integriert und so ein Test könnte dann so aussehen:```class MuenzeTest{ // ich greife mal meinen Vorschlag nochmal auf… ;o)
@Test
public void testBerechneRest_betragKleinerWert_restUnveraendert(){
Muenze muenze = new Muenze(2.00, “test”);
float restVorher = 1.99;

 float restNachher = muenze.berechneRest(restVorher);

assertEquals(restVorher,restNachher);

}

@Test
public void testBerechneRest_betragGroesserWert_restWenigerMuenzWert(){
Muenze muenze = new Muenze(2.00, “test”);
float restVorher = 3.99;

 float restNachher = muenze.berechneRest(restVorher);

assertEquals(1.99,restNachher);

}

}```
Auf diese Weise lässt Du dann Dein Programm in ganz kleinen Schitten wachsen, und weist genau, was schon wie erwartet funktioniert.

bye
TT

20

Also in Real gibt es viele Automaten, die 1 oder 2 Cent nicht zulassen, als wären diese nix wert, und dann ist es tatsächlich ein Problem, welches nicht einfach ‘probiert’ werden kann. ‘Schiefe’ Beträge usw.
Na klar, ganze Zahlen können durch 1 2 5 usw. geteilt werden.
Aber sagen wir, ich mische das, 50 10 100 2 200 usw., wie weiß ich dann, diese Anzahl ist minimal? Das war eigentlich meine Frage.

At TO: Du brauchst eine Schleife für eine Eingabe und mind. eine Methode, welche den zuaufzustückelnden Betrag entgegennimmt, und dann was macht.