Wechselautomat

Bitte aktiviere JavaScript!
Ob man es nun prozedural oder OO löst, ist nicht so wichtig, nur funktional wie von @httpdigest vergeschlagen würde ich es für den Anfang nicht lösen.

BTW muenze / 100.0 ist noch nicht so schön, da besser ein DecimalFormat + setMultiplier(int newValue) ;) So würden es Profis machen...

setCurrency(Currency currency) ggf. auch mal ein Blick wert!
 
Wenn ich das versinnbildliche, dann habe ich ein Anzahl Geldsäulen auf dem Tisch. Diese haben einen long-Wert(200,100,50,20,10,5,2,1), und eine int als Anzahl. Nun brauche ich eine Methode "machLeer()", die die Säule leer macht, "int getAnzahl()" für die anzahl der Münzen und "long berechneAnzahl( long betrag);. Obwohl mir jetzt die englische Entsprechung nicht einfällt, wäre der Kunstruktor "public Sauele( long wert)".

Herauskommen würde etwas sowas:
Java:
puplic void main(){
    long betrag;
    long rest;
    Saeule zweiEuro= new Saeule(200);
    Sauele einEuro= new Sauele(100);
    Sauele fuenfzigCent= new Saule(50);
    Sauele zwanzigCent= new Sauele(20);
    Sauele zehnCent= new Sauele(10);
    Sauele fuenfCent= new Saele(5);
    Sauele zweiCent= new Sauele(2);
    Sauele eincent= new Sauele(1);
    betrag= 436;
    rest= zweiEuro.berechneAnzahl(betrag);
    betrag=rest;
    rest=einEuro.berechneAnzahl(betrag);
    betrag=rest;
    rest=fuenfzigCent.berechneAnzahl(betrag);
    betrag=rest;
    rest=zwanzigCent.berechneAnzahl(betrag);
    betrag=rest;
    rest=zehnCent.berechneAnzahl(betrag);
    betrag=rest;
    rest=fuenfCent.berechneAnzahl(betrag);
    betrag=rest;
    rest=zweiCent.berechneAnzahl(betrag);
    betrag=rest;
    rest=einCent.berechne Anzahl(betrag);
    System.out.println(zweiEuro.getAnzahl());
    System.out.println(einEuro.getAnzahl());
    System.out.println(fuenfzigCent.getAnzahl());
    System.out.println(zwanzigCent.getAnzahl());
    System.out.println(zehnCent.getAnzahl());
    System.out.println(fuenfCent.getAnzahl());
    System.out.println(zweiCent.getAnzahl());
    System.out.println(einCent.getAnzahl());

}
Das wäre jetzt die direkte Umsetzung der physischen Situation in Code. Als Fachmann würde man jetzt in einem weiteren Schritt die gleichartigen Programmzeilen zusammenfassen, wahrscheinlich durch ein Array of Saeule(s).

Didaktisch finde ich es aber dennoch gut so, weil man zuerst die Datenobjekte aufgrund vorhandener materiell vorhandener Dinge erstellt, dann feststellt, dass sie ähnliches Machen, man sie also in einer Klasse zusammenfassen kann und dann diese Objekte miteinander kommunizieren. Wobei hier die Methodenaufrufe der realen Tätigkeit angenähert sind, so dass das Programm im Ablauf schon verständlich gehalten ist.
 
Wenn ich das versinnbildliche, dann habe ich ein Anzahl Geldsäulen auf dem Tisch.
Man könnte das noch weiter spinnen, denn es geht ja um einen Wechselautomaten, den man sich als Gerät vorstellen kann.
Das Gerät besitzt ein Ausgabefach, das die Münzen für die Ausgabe sammelt, außerdem befinden sich in diesem Gerät mehrere "Münzspender". Ein solcher Münzspender gibt eine entsprechende Anzahl an Münzen aus (-> Ausgabefach) und kann mit einem weiteren Münzspender verbunden sein, der sich um den Restbetrag kümmert.

Das bringt uns dann zu etwas wie (Skizze, Code ungetestet EDIT: funktioniert):

Java:
interface Muenzsammler {
    void sammle(int wert, int anzahl);
}
Java:
class Muenzspender {
    public static Muenzspender LEER_SPENDER = new Muenzspender() {
        @Override
        void wechsle(int betrag) {}
    };

    final int wert;
    final Muenzsammler ausgabe;
    final Muenzspender naechster;

    private Muenzspender() { this.ausgabe = null; this.naechster = null; this.wert = 0; }

    Muenzspender(int wert, Muenzsammler ausgabe) { this(wert, ausgabe, LEER_SPENDER); }
    Muenzspender(int wert, Muenzsammler ausgabe, Muenzspender naechster) {
        if (ausgabe == null) { throw new IllegalArgumentException("Ohne Ausgabe wird das nix."); }
        if (naechster == null) { throw new IllegalArgumentException("Weiterer Muenzspender erforderlich"); }

        this.wert = wert;
        this.naechster = naechster;
        this.ausgabe = ausgabe;
    }

    void wechsle(int betrag) {
        ausgabe.sammle(wert, betrag / wert);
        naechster.wechsle(betrag % wert);
    }
}
Java:
class Muenzwechsler {
    private Muenzspender spender;
    private Muenzsammler centSammler = new Muenzsammler() {
        @Override
        public void sammle(int wert, int anzahl) {
             System.out.printf("%d x %d-Cent-Muenze(n)\n", anzahl, wert);
        }
    };

    private Muenzsammler euroSammler = new Muenzsammler() {
        @Override
        public void sammle(int wert, int anzahl) {
             System.out.printf("%d x %d-Euro-Muenze(n)\n", anzahl, wert / 100);
        }
    };
  
    public Muenzwechsler() {
        Muenzspender einCent = new Muenzspender(1, centSammler);
        Muenzspender zweiCent = new Muenzspender(2, centSammler, einCent);
        Muenzspender fuenfCent = new Muenzspender(5, centSammler, zweiCent);
        Muenzspender zehnCent = new Muenzspender(10, centSammler, fuenfCent);
        Muenzspender zwanzigCent = new Muenzspender(20, centSammler, zehnCent);
        Muenzspender fuenfzigCent = new Muenzspender(50, centSammler, zwanzigCent);
        Muenzspender einEuro = new Muenzspender(100, euroSammler, fuenfzigCent);
        spender = new Muenzspender(200, euroSammler, einEuro);
    }

    public void wechsle(int betrag) {
        spender.wechsle(betrag);
    }
}
Java:
import java.util.Scanner;

class GeldwechselnFizzBuzzEdition {
    public static void main(String[] args) {
        Muenzwechsler wechsler = new Muenzwechsler();
        Scanner sc = new Scanner(System.in);
        boolean done = false;
        do {
            System.out.print("Betrag: ");
            double betrag = sc.nextDouble();
            done = betrag <= 0.0;
            if (!done) {
                int cent = (int)(Math.round(betrag*100.0));
                wechsler.wechsle(cent);
            }
        } while (!done);
    }
}
 
Das Management befürchtet, dass im Programm hart verdrahtete Münzvarianten (€2, €1, ..., €0,01) nicht zukunftssicher sind, falls neue Euromünzen in den Umlauf kommen (wie es zum Beispiel bei der €10 Sondermünzprägung der Fall ist, die auch als gültiges Zahlungsmittel gilt). Stattdessen sollte dies über eine externe Programmkonfiguration flexibel festgelegt werden können.
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben