Kaffeemaschinen

Kaffee und Emotionen

Kaffeemaschine:

# Python-Dictionary, sehr ähnlich zu JSON-Datenstrukturen
MENU = {
    "Espresso": {
        "zusammensetzung": {
            "wasser": 50,
            "kaffeebohnen": 18,
        },
        "preis": 1.5,
    },
    "Latte": {
        "zusammensetzung": {
            "wasser": 200,
            "milch": 150,
            "kaffeebohnen": 24,
        },
        "preis": 2.5,
    },
    "Cappuccino": {
        "zusammensetzung": {
            "wasser": 250,
            "milch": 100,
            "kaffeebohnen": 24,
        },
        "preis": 3.0,
    }
}

ressourcen = {
    "wasser": 300,
    "milch": 200,
    "kaffeebohnen": 100
}

geldbetrag = 0
eingeschaltet = True

def reichen_ressourcen(auswahl_zusammensetzung):
    """Returns True when order can be made, False when amount is insufficient"""
    for item in auswahl_zusammensetzung:
        if auswahl_zusammensetzung[item] > ressourcen[item]:
            print(f"Leider nicht genug {item}")
            return False
    return True    

def verarbeitung_muenzen():
    """Returns the total calculated from coins inserted."""
    insgesamt = int(input("Wie viele 10-Rappen? ")) * 0.1
    insgesamt += int(input("Wie viele 20-Rappen? ")) * 0.2
    insgesamt += int(input("Wie viele 50-Rappen? ")) * 0.5
    insgesamt += int(input("Wie viele 1-Franken? ")) * 1
    insgesamt += int(input("Wie viele 2-Franken? ")) * 2
    return insgesamt

def ist_geld_ausreichend(geld_erhalten, auswahl_kosten):
    """Return True when the payment is accepted, or False if money is insufficient."""
    if geld_erhalten >= auswahl_kosten:
        wechselgeld = round(geld_erhalten - auswahl_kosten, 2)
        print(f"Sie erhalten CHF {wechselgeld} zurück.")
        global geldbetrag  # Damit die globale Variable auch in Funktion erreichbar ist
        geldbetrag += auswahl_kosten
        return True
    else:
        print("Das Geld reicht leider nicht aus. Geld wird zurückgegeben.")
        return False

def kaffee_ausgeben(auswahl, zusammensetzung):
    """Die Ressourcen des Kaffeeautomats entsprechend der Auswahl verringern."""
    for item in zusammensetzung:
        ressourcen[item] -= zusammensetzung[item]
    print(f"Ihr {auswahl} wird zubereitet. Geniessen Sie Ihren Kaffee ☕")    

while eingeschaltet:

    auswahl = input("Was möchten Sie? Espresso | Latte | Cappuccino: ")

    if auswahl == "off":
        eingeschaltet = False

    elif auswahl == "status":
        print(f"Wasser: {ressourcen['wasser']}")
        print(f"Milch: {ressourcen['milch']}")
        print(f"Kaffeebohnen: {ressourcen['kaffeebohnen']}")
        print(f"Geld insgesamt eingenommen: CHF {geldbetrag}")

    else:
        wahl = MENU[auswahl]

        if reichen_ressourcen(wahl["zusammensetzung"]):
            # Nr. 5 Anforderungsanalyse
            bezahlung = verarbeitung_muenzen()

            # Nr. 6 Anforderungsanalyse
            if ist_geld_ausreichend(bezahlung, wahl["preis"]):
                # Nr. 7 Anforderungsanalyse
                kaffee_ausgeben(auswahl, wahl["zusammensetzung"])

Upgrade zum Grundprogramm:

Folgende Sachen wurden hunzugefügt:

1. Sicherstellen, dass das Programm bei ungültiger Eingabe nicht abstürzt
2. Funktion um Wasser/Milch/Bohnen nachzufüllen
3. Angabe der Kosten für das gewählte Getränk (vor der Geldeingabe)

MENU = {
    "Espresso": {
        "zusammensetzung": {
            "wasser": 50,
            "kaffeebohnen": 18,
        },
        "preis": 1.5,
    },
    "Latte": {
        "zusammensetzung": {
            "wasser": 200,
            "milch": 150,
            "kaffeebohnen": 24,
        },
        "preis": 2.5,
    },
    "Cappuccino": {
        "zusammensetzung": {
            "wasser": 250,
            "milch": 100,
            "kaffeebohnen": 24,
        },
        "preis": 3.0,
    }
}

ressourcen = {
    "wasser": 300,
    "milch": 200,
    "kaffeebohnen": 100
}

geldbetrag = 0
eingeschaltet = True

def reichen_ressourcen(auswahl_zusammensetzung):
    """Returns True when order can be made, False when amount is insufficient"""
    for item in auswahl_zusammensetzung:
        if auswahl_zusammensetzung[item] > ressourcen.get(item, 0):  # Sicherstellen, dass der Key existiert
            print(f"Leider nicht genug {item}.")
            return False
    return True

def verarbeitung_muenzen():
    """Returns the total calculated from coins inserted."""
    print("Bitte Münzen einwerfen:")
    insgesamt = int(input("Wie viele 10-Rappen? ")) * 0.1
    insgesamt += int(input("Wie viele 20-Rappen? ")) * 0.2
    insgesamt += int(input("Wie viele 50-Rappen? ")) * 0.5
    insgesamt += int(input("Wie viele 1-Franken? ")) * 1
    insgesamt += int(input("Wie viele 2-Franken? ")) * 2
    return insgesamt

def ist_geld_ausreichend(geld_erhalten, auswahl_kosten):
    """Return True when the payment is accepted, or False if money is insufficient."""
    if geld_erhalten >= auswahl_kosten:
        wechselgeld = round(geld_erhalten - auswahl_kosten, 2)
        print(f"Sie erhalten CHF {wechselgeld} zurück.")
        global geldbetrag
        geldbetrag += auswahl_kosten
        return True
    else:
        print("Das Geld reicht leider nicht aus. Geld wird zurückgegeben.")
        return False

def kaffee_ausgeben(auswahl, zusammensetzung):
    """Die Ressourcen des Kaffeeautomats entsprechend der Auswahl verringern."""
    for item in zusammensetzung:
        ressourcen[item] -= zusammensetzung[item]
    print(f"Ihr {auswahl} wird zubereitet. Geniessen Sie Ihren Kaffee ☕")

def auffuellen():
    """Füllt die Ressourcen des Automaten auf."""
    ressourcen["wasser"] += int(input("Wie viel Wasser hinzufügen? "))
    ressourcen["milch"] += int(input("Wie viel Milch hinzufügen? "))
    ressourcen["kaffeebohnen"] += int(input("Wie viele Kaffeebohnen hinzufügen? "))
    print("Ressourcen wurden erfolgreich aufgefüllt.")

while eingeschaltet:
    auswahl = input("Was möchten Sie? Espresso | Latte | Cappuccino | status | off | auffuellen: ").capitalize()

    if auswahl == "Off":
        eingeschaltet = False

    elif auswahl == "Status":
        print(f"Wasser: {ressourcen.get('wasser', 0)}ml")
        print(f"Milch: {ressourcen.get('milch', 0)}ml")
        print(f"Kaffeebohnen: {ressourcen.get('kaffeebohnen', 0)}g")
        print(f"Geld insgesamt eingenommen: CHF {geldbetrag:.2f}")

    elif auswahl == "Auffuellen":
        auffuellen()

    elif auswahl in MENU:
        wahl = MENU[auswahl]
        print(f"Kosten für {auswahl}: CHF {wahl['preis']:.2f}")

        if reichen_ressourcen(wahl["zusammensetzung"]):
            bezahlung = verarbeitung_muenzen()
            if ist_geld_ausreichend(bezahlung, wahl["preis"]):
                kaffee_ausgeben(auswahl, wahl["zusammensetzung"])
    else:
        print("Ungültige Eingabe. Bitte wählen Sie ein gültiges Getränk oder eine Option.")

Ziel:

• Ziel:

• Simuliert einen Kaffeeautomaten, der Espresso, Latte und Cappuccino anbietet.

• Hauptfunktionen:

• reichen_ressourcen(): Prüft, ob genügend Ressourcen (z. B. Wasser, Milch, Kaffeebohnen) für das gewählte Getränk verfügbar sind.

• verarbeitung_muenzen(): Berechnet den Betrag, den der Benutzer durch Münzeingabe bezahlt.
• ist_geld_ausreichend(): Überprüft, ob das eingeworfene Geld ausreicht. Gibt Wechselgeld zurück, falls nötig.
• kaffee_ausgeben(): Reduziert die Ressourcen im Automaten, bereitet das Getränk vor und gibt eine Nachricht aus.

• auffuellen(): Ermöglicht das Nachfüllen von Wasser, Milch und Kaffeebohnen.

• Steuerung:

• Der Benutzer wählt durch Eingabe (Espresso, Latte, Cappuccino, status, off, auffuellen), was er möchte.

• Bei status zeigt das Programm die verbleibenden Ressourcen und das eingenommene Geld.
• Bei auffuellen können die Ressourcen aufgefüllt werden.

• Bei off wird der Automat ausgeschaltet.

• Zusatz:

• Vor der Münzeingabe zeigt das Programm den Preis des gewählten Getränks an.

• Ungültige Eingaben führen zu einer Fehlermeldung, ohne dass das Programm abstürzt.

Kaffeemaschinen Objektorientiert erstellt:

Darstellung durch PUML-Diagramm

400.

Erklärung:

• Kaffeemaschine hat Attribute (ressourcen, geldbetrag) und Methoden (reichen_ressourcen, kaffee_ausgeben, auffuellen).
• MENU enthält die verfügbaren Getränke.
• RESSOURCEN definiert die verschiedenen Ressourcen wie Wasser, Milch und Kaffeebohnen.
• Die Pfeile (-->) zeigen die Abhängigkeit der Kaffeemaschine von den Klassen RESSOURCEN und MENU.

das ist das Hauptprogramm das dann jeweils auf die unteren programme zugreift

from maschine import Kaffeemaschine
from menu import MENU
from ressourcen import RESSOURCEN

kaffeemaschine = Kaffeemaschine(RESSOURCEN)
eingeschaltet = True

while eingeschaltet:
    auswahl = input("Was möchten Sie? Espresso | Latte | Cappuccino | status | off | auffuellen: ").capitalize()

    if auswahl == "Off":
        eingeschaltet = False

    elif auswahl == "Status":
        print(f"Wasser: {kaffeemaschine.ressourcen.get('wasser', 0)}ml")
        print(f"Milch: {kaffeemaschine.ressourcen.get('milch', 0)}ml")
        print(f"Kaffeebohnen: {kaffeemaschine.ressourcen.get('kaffeebohnen', 0)}g")
        print(f"Geld insgesamt eingenommen: CHF {kaffeemaschine.geldbetrag:.2f}")

    elif auswahl == "Auffuellen":
        kaffeemaschine.auffuellen()

    elif auswahl in MENU:
        wahl = MENU[auswahl]
        print(f"Kosten für {auswahl}: CHF {wahl['preis']:.2f}")

        if kaffeemaschine.reichen_ressourcen(wahl["zusammensetzung"]):
            bezahlung = float(input("Wie viel Geld werfen Sie ein? "))
            if bezahlung >= wahl["preis"]:
                wechselgeld = round(bezahlung - wahl["preis"], 2)
                print(f"Sie erhalten CHF {wechselgeld} zurück.")
                kaffeemaschine.geldbetrag += wahl["preis"]
                kaffeemaschine.kaffee_ausgeben(auswahl, wahl["zusammensetzung"])
            else:
                print("Das Geld reicht leider nicht aus. Geld wird zurückgegeben.")
    else:
        print("Ungültige Eingabe. Bitte wählen Sie ein gültiges Getränk oder eine Option.")

dann habe ich in maschine diesen code:

class Kaffeemaschine:
    def __init__(self, ressourcen):
        self.ressourcen = ressourcen
        self.geldbetrag = 0

    def reichen_ressourcen(self, zusammensetzung):
        for item in zusammensetzung:
            if zusammensetzung[item] > self.ressourcen.get(item, 0):
                print(f"Leider nicht genug {item}.")
                return False
        return True

    def kaffee_ausgeben(self, auswahl, zusammensetzung):
        for item in zusammensetzung:
            self.ressourcen[item] -= zusammensetzung[item]
        print(f"Ihr {auswahl} wird zubereitet. Geniessen Sie Ihren Kaffee ☕")

    def auffuellen(self):
        self.ressourcen["wasser"] += int(input("Wie viel Wasser hinzufügen? "))
        self.ressourcen["milch"] += int(input("Wie viel Milch hinzufügen? "))
        self.ressourcen["kaffeebohnen"] += int(input("Wie viele Kaffeebohnen hinzufügen? "))
        print("Ressourcen wurden erfolgreich aufgefüllt.")

und für menu habe ich das:

MENU = {
    "Espresso": {
        "zusammensetzung": {
            "wasser": 50,
            "kaffeebohnen": 18,
        },
        "preis": 1.5,
    },
    "Latte": {
        "zusammensetzung": {
            "wasser": 200,
            "milch": 150,
            "kaffeebohnen": 24,
        },
        "preis": 2.5,
    },
    "Cappuccino": {
        "zusammensetzung": {
            "wasser": 250,
            "milch": 100,
            "kaffeebohnen": 24,
        },
        "preis": 3.0,
    }
}


in ressourcen

RESSOURCEN = {
    "wasser": 300,
    "milch": 200,
    "kaffeebohnen": 100
}

für ressourcen habe ich das:

RESSOURCEN = {
    "wasser": 300,
    "milch": 200,
    "kaffeebohnen": 100
}

Ich habe einen Main-Ordner erstellt und dort alle Dateien abgelegt. Und wenn man diesen Ordner öffnet mit Vs-Code und das Hauptfile aufmacht dann greift dies automatisch auf die anderen Dokumente zu.

Objektorientierte Programmierung: Konzepte und Beispiele

Vererbung

Vererbung erlaubt es einer Klasse, die Attribute und Methoden einer anderen Klasse zu übernehmen.

class Animal { void eat() { System.out.println("Eating"); } }  
class Dog extends Animal { void bark() { System.out.println("Barking"); } }

Kapselung

Kapselung bezeichnet das Prinzip, bestimmte Daten und Methoden einer Klasse nur innerhalb dieser Klasse zugänglich zu machen. Dadurch werden wichtige Informationen vor unerwünschtem Zugriff und Änderungen von außen geschützt.

class Person { private String name; public void setName(String n) { name = n; } public String getName() { return name; } }

Vorteil der Kapselung

Kapselung schützt Attribute vor unkontrollierten Änderungen von außen und verhindert ungültige Eingaben, was die Stabilität und Sicherheit der Klasse gewährleistet.

class BankAccount { private double balance; public void deposit(double amt) { if (amt > 0) balance += amt; } public double getBalance() { return balance; } }

Polymorphismus

Polymorphismus erlaubt es, dass Methoden in verschiedenen Klassen gleich benannt, aber unterschiedlich implementiert werden. Dadurch können Objekte verschiedener Klassen einheitlich angesprochen werden, während sie ihr spezifisches Verhalten zeigen. Dies führt zu einem flexibleren und modulareren Design.

class Animal { void sound() { System.out.println("Sound"); } }  
class Dog extends Animal { void sound() { System.out.println("Woof"); } }

Scope (Anwendungsbereich)

Der Anwendungsbereich definiert, wo eine Variable im Programm gültig ist.

void example() { int x = 10; if (x > 5) { int y = 20; System.out.println(x + y); } }

Konstruktor

Ein Konstruktor ist eine spezielle Methode einer Klasse, die beim Erzeugen eines neuen Objekts aufgerufen wird, um das Objekt zu initialisieren.

class Person { String name; Person(String n) { name = n; } }

Getter-Methode

Eine Getter-Methode ist eine Methode, die den Wert eines privaten Attributs zurückgibt, ohne dass direkt auf das Attribut zugegriffen wird.

class Car { private String model; public String getModel() { return model; } }

Setter-Methode

Eine Setter-Methode ist eine Methode, die es ermöglicht, den Wert eines privaten Attributs kontrolliert zu ändern.

class Car { private String color; public void setColor(String c) { color = c; } }