# Kaffeeautomat Programmieren



## mexas450 (17. Apr 2014)

Hallo Leute,

wie im Betreff schon erwähnt soll ich einen Kaffeeautomaten programmieren. Ich bin noch totaler Anfänger in Java Programmierung. Hatte zwar schon mal C im Studium aber das ist auch schon 2 Jahre her. Bevor ich euch mein Problem schildere,würde ich euch bitten mir eventuelle Literatur Empfellungen zu schicken. So und jetzt zum Problem: die Aufgabenstellung sieht wie folgt aus!

Es soll eine Simulation für einen Kaffeeautomaten programmiert werden.
Zunächst ist der Automat mit 1 kg Kaffeepulver, 1 kg Milchpulver und 1 kg
Zucker gefüllt. Wasser ist in beliebiger Menge verfügbar. Als Wechselgeld
ist der Automat mit 10 x 1€, 10 x 50 ct, 10 x 20 ct und 10 x 10 ct geladen.
Nach dem Programmstart wird der Benutzer in einem Dialog gefragt,
a) ob er einen großen oder kleinen Kaffee trinken möchte bzw. ob er das
Programm beenden möchte,
b) ob er seinen Kaffee weiß oder schwarz trinken möchte und
c) wieviel Stück Zucker er haben möchte.
Wurde ein Produkt ausgewählt, ist zu überprüfen, ob genug Kaffeepulver,
Milchpulver und Zucker für die Bestellung verfügbar ist. Legen Sie hierbei
zugrunde, dass ein kleiner Kaffee 50g Kaffeepulver, ggf. 10g Milchpulver
und 2g Zucker/Stück benötigt. Bei einem großen Kaffee verdoppeln sich
alle Werte. Falls nicht genug Kaffeepulver, Milchpulver bzw. Zucker verfügbar
ist, wird eine Fehlermeldung ausgegeben und das Programm beendet.
Falls alles in ausreichender Menge vorhanden ist, wird als nächstes auf
dem Bildschirm der Preis des gewählten Produktes angezeigt. Ein kleine
Kaffee soll 60 ct, ein große Kaffee 1,10€ kosten. Wird der Kaffee weiß
gewünscht, werden zusätzlich 10 ct berechnet.
Im weiteren Verlauf des Programms muss der Geldbetrag „eingeworfen“
werden, und zwar in der Form, dass folgende Eingaben akzeptiert werden:
• Gibt der Kunde eine 1 oder 2 ein, wird diese Eingabe als 1 € bzw. 2 €
interpretiert. Das Eurozeichen muss hierbei nicht angegeben werden.
• Gibt der Kunde 10, 20 oder 50 ein, wird der entsprechende Wert als
Cent-Betrag gewertet, also entsprechend 10 ct, 20 ct und 50 ct.
• Gibt der Kunde eine andere Zahl ein, wird ein Fehler gemeldet und der
Kunde aufgefordert die letzte Eingabe zu wiederholen.
• Fehleingaben anderer Art (z.B. „bla“) müssen nicht berücksichtigt werden
und dürfen sogar dazu führen, dass das Programm abstürzt.
Sobald genug Geld eingeworfen wurde, soll auf dem Bildschirm angezeigt
werden, welcher Kaffee bestellt wurde und wieviel Rückgeld der Kunde
erhält, und zwar in der Weise, dass man die Staffelung der verschiedenen
Münzen erkennt. Hier ein Beispiel für ein erfolgreiche Bestellung:

Großer Kaffee Weis mit Zucker
Rückgeld: 1 x 1 €, 3 x 20 ct, 1 x 10 ct

- 2-
Nachdem ein Kunde seinen Kaffee erhalten hat, soll es möglich sein, weitere
Bestellungen entgegen zu nehmen.
Das Programm wird beendet, wenn nicht mehr genug Kaffeepulver, Milchpulver
oder Zucker verfügbar ist oder wenn ein Anwender statt eines Kaffees
das Programmende wünscht (siehe oben). In beiden Fällen soll auf
dem Bildschirm angezeigt werden, wieviel Kaffeepulver, Milchpulver bzw.
Zucker noch im Automaten verfügbar ist und wieviel Geld sich im Automaten
befindet. Das Geld soll entsprechend der Stücklung angegeben werden,
d.h. es soll angezeigt werden, wieviele Münzen sich vom Typ 10 ct, 20 ct,
50 ct, 1€ und 2 € im Automaten befinden. Beispiel:
Das Programm bietet einige Freiheiten in der Implementierung. Das nachfolgende
Bild zeigt, wie sich das Programm insgesamt einem Benutzer präsentieren
kann. Ausgaben des Programms sind in dem Bild Blau gesetzt,
Eingaben des Kunden sind schwarz gesetzt:

Fehler: Nicht genug Kaffeepulver vorhanden
Kaffepulver: 0g, Milchpulver: 990g, Zucker: 998g
Einnahmen: 12 x 2 €, 4 x 1 €, 7 x 50 ct, 13 x 20 ct, 1 x 10 ct
Programm beendet.

Willkommen. Heute im Angebot:
1: Kleiner Kaffee
2: Großer Kaffee
Bitte wählen Sie ein Produkt: 1
Wie möchten Sie Ihren Kaffee:
1: Schwarz
2: Weiß
Bitte wählen Sie: 2
Wieviel Stück Zucker möchten Sie [0 - 5]: 1
Sie möchten einen kleinen Kaffee mit Milch und 1 Stück Zucker.
Bitte Werfen Sie 70 ct ein: 50
Bitte Werfen Sie noch 20 ct ein: 10
Bitte Werfen Sie noch 10 ct ein: 1
Kleiner Kaffee Weis mit Zucker
Rückgeld: 1 x 50 ct, 1 x 20 ct, 2 x 10 ct

Willkommen. Heute im Angebot:
1: Kleiner Kaffee
2: Großer Kaffee
Bitte wählen Sie ein Produkt: 0
Kaffepulver: 950g, Milchpulver: 990g, Zucker: 998g
Einnahmen: 0 x 2 €, 11 x 1 €, 10 x 50 ct, 9 x 20 ct, 9 x 10 ct
Programm beendet.


und so sieht bis jetzt mein Quelltext aus:

```
package SWT1;
import java.util.*;

public class Main 
{
    public static Scanner scanner = new Scanner (System.in);                    // Einbinden der Scanner-Funktion
  
    public static final String Produkt1 = "Kleinen Kaffee";                     // Variablen-Konstante: Kleinen Kaffee (Ausgabe)
    public static final String Produkt2 = "Großen Kaffee";                      // Variablen-Konstante: Großen Kaffee (Ausgabe)
    public static final String Milch1 = "mit Milch";                            // Variablen-Konstante: mit Milch (Ausgabe)
    public static final String Milch2 = "ohne Milch";                           // Variablen-Konstante: ohne Milch (Ausgabe)
    public static final double Produkt10 = 50;                                  // Variablen-Konstante: Kleiner Kaffee 50g (Berechnung)
    public static final double Produkt20 = 100;                                 // Variablen-Konstante: Großer Kaffee 100g (Berechnung)
    public static final double Milch10 = 10;                                    // Variablen-Konstante: Milch-Kleiner Kaffee 10g (Berechnung)
    public static final double Milch20 = 20;                                    // Variablen-Konstante: Milch-Großer Kaffee 20g ( Berechnung)
    public static final double Zucker = 2;                                      // Variablen-Konstante: Zucker pro Stück 2g ( Berechnung)
    public static final double Kaffeepulver_gesamt = 1000;                      // Variablen-Konstante: Kaffeepulver 1kg (Start)
    public static final double Milchpulver_gesamt = 1000;                       // Variablen-Konstante: Milchpulver 1kg (Start)
    public static final double Zucker_gesamt = 1000;                            // Variablen-Konstante: Zucker 1kg (Start)
   
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////    
        public static void main (String[] args)                                  // Anfang des Hauptprogramm
       {
            
       /*     double mp_gesamt = Milchpulver_gesamt;
            double zk_gesamt = Zucker_gesamt;   */
            
            String repeat = "n";                                                // Abbruchbedingung der do-while-Schleife
            do                                                                  // Beginn der do-while-Schleife (Neustart)
            {                                            
            System.out.println ("Willkommen. Heute im Angebot:\n" );            // Begrüßung
            
            System.out.println ("1: Kleiner Kaffee" );                          // Ausgabe "Kleiner Kaffee"
            System.out.println ("2: Großer Kaffee\n" );                         // Ausgabe "Großer Kaffee"
            System.out.println ("Bitte wählen Sie ein Produkt:" );              // Eingabe der Größe durch Benutzer
            int Produkt = scanner.nextInt ();                                   // Scan der Größe
            String AdG = Auswahl_der_Groeße (Produkt);                          // Aufruf der Funktion "Auswahl_der_Größe"
            double AdGB = Auswahl_der_Groeße_Berechnung (Produkt);              // Aufruf der Funktion "Auswahl_der_Größe_Berechnung"
            
            System.out.println ("Wie möchten Sie Ihren Kaffee:" );              // Ausgabe Abfrage ob Schwarz oder Weiß
            System.out.println ("1: Schwarz" );                                 // Ausgabe "Schwarz"
            System.out.println ("2: Weiß" );                                    // Ausgabe "Weiß"
            System.out.println ("Bitte wählen Sie:" );                          // Wählen
            int Kaffee = scanner.nextInt ();                                    // Scan ob SW oder WS
            String Sw = Schwarz_Weiß (Kaffee);                                  // Aufruf der Funktion "Schwarz_Weiß"
            double SwB = Auswahl_der_Groeße_Berechnung (Kaffee);                // Aufruf der Funktion "Auswahl_der_Größe_Berechnung"  
            
            System.out.print ("Wieviel Stücke Zucker möchten Sie [0-5]:" );     // Abfrage: Wieviele Stücke Zucker    
            int Anzahl = scanner.nextInt ();                                    // Scan der Zuckerstücke
            double Zr = Zucker (Anzahl);                                        // Aufruf der Funktion "Zucker"
            
            System.out.printf ("Sie möchten einen %s %s mit %.0f Stück "        // Systemausgabe des Kaffes
                                + "Zucker ",AdG,Sw,Zr);
            
            System.out.printf ("\n\n Kaffepulvermenge,Zuckermenge %.0f %.0f",
                                AdGB,SwB);                                      // Systemausgabe der Berechnung    
            
          
            System.out.println("Nochmal (j/n)?");                               // Abfrage Neustart-Programmstart
            Scanner sc = new Scanner(System.in);                                           
            repeat = sc.next();
            } 
            while (repeat.equals("j"));                                         // Ende der do-while-Schleife
            
        }
                                                                                // Ende des Hauptprogrammes
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////      
        public static String Auswahl_der_Groeße (int Produkt)                   // Anfang: Funktion-Auswahl der Kaffeegröße
        {
            if (Produkt == 1)                                                   // Kleiner Kaffee
               return Produkt1;                                                 // Rückgabe "Kleiner Kaffee"
            
            if (Produkt == 2)                                                   // Großer Kaffee
               return Produkt2;                                                 // Rückgabe "Großer Kaffee"
           
            return "Unbekannt";                                                 // Rückgabe wenn nicht 1 oder 2 gedrückt
        }                                                                       // Ende: Funktion-Auswahl der Kaffeegröße 
        public static double Auswahl_der_Groeße_Berechnung ( int Produkt)       // Anfang: Funktion-Auswahl der Kaffeegröße_Berechnung
                {   
                    double kp_gesamt = Kaffeepulver_gesamt; 
                   
                        if (Produkt == 1)                                       // Kleiner Kaffee
                        {     
                            double kk_B =  kp_gesamt - Produkt10;    
                            return kk_B;
                        }     
                            if (Produkt == 2)                                   // Großer Kaffee
                            {   
                                double gk_B =  kp_gesamt - Produkt20;    
                                return gk_B;
                            }
                 return 0;                                                      // Rückgabe wenn nicht 1 oder 2 gedrückt   
                } 
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////        
        public static String Schwarz_Weiß (int Kaffee)                          // Anfang: Funktion-Auswahl Schwarz_Weiß
        {
            if (Kaffee == 1)                                                    // Schwarzer Kaffee
                return Milch1;                                                  // Rückgabe "Schwarz"
            
            if (Kaffee == 2)                                                    // Weißer Kaffee
                return Milch2;                                                  // Rückgabe "Weiß"
            
            return "Unbekannt";                                                 //Rückgabe wenn nicht 1 oder 2 gedrückt
        } 
     /*    public static double Schwarz_Weiß_Berechnung ( int Kaffee )          // Anfang: Funktion-Auswahl Schwarz_Weiß_Berechnung
            {
              
                
                
                                                                                // Rückgabe wenn nicht 1 oder 2 gedrückt   
            }*/
                                                                                // Ende: Funktion-Auswahl Schwarz_Weiß
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////        
        public static double Zucker (int Anzahl)                                // Anfang: Funktion-Auswahl Zucker
        {
            return Anzahl;                                                      // Rückgabe Anzahl der Stücke                        
        }                                                                       // Ende: Funktion-Auswahl Zucker
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
```

Ich bin ja schon so weit bekommen das ich ja fragen kann ob kaffee klein oder groß usw. Nun wollte ich mich an die Berechnung ran machen. Ich weiß aber (noch) nicht wie ich in Java sagen kann das er mit einem berechneten Wert weiter rechnen soll. Wenn ich das erstmal habe wäre ich mega happy. Über positive Kritik wäre ich auch sehr dankbar. Ich möchte noch dazu erwähnen das ich auf diesem Wege ein paar Hilfestellung/Tipps und Tricks suche und nicht jemand der mir die komplette Aufgabe löst. In diesem Sinne...

Danke schon mal im Vorraus für kleine Hinweise zur Aufgabenlösung!!!


----------



## Machareder (17. Apr 2014)

du möchtest wissen wie man mit einem berechneten Wert weiterrechnet? 
dann solltest du dir dringend mal die Grundlegenden Sachen anschauen 
du deklarierst z.B:

```
int i = 5;
```
und rechnest dann

```
i = i - 3;
```
dann wird dir bei der Ausgabe

```
System.out.println(i);
```
zwei ausgegeben
du könntest natürlich immer wieder einen neuen int anlegen, also:

```
int t = i - 3;
```


----------

