Wachsen mit dem Buch "Java ist auch eine Insel"

Diskutiere Wachsen mit dem Buch "Java ist auch eine Insel" im Codeschnipsel u. Projekte Forum; In etwa so? Bedienungsanleitung: - es wird geprüft, ob das Produkt im Sortiment vorhanden - wenn nein: Meldung, Abbruchmöglichkeit - wenn ja:...

  1. Javinner
    Javinner Mitglied
    In etwa so?
    Bedienungsanleitung:
    - es wird geprüft, ob das Produkt im Sortiment vorhanden
    - wenn nein: Meldung, Abbruchmöglichkeit
    - wenn ja: Anzahl
    - wenn Summe das Guthaben übersteigt, weiterer Einkauf möglich: Abbruchmöglichkeit
    - wenn nicht: Abschlussrechnung
    Zwischenrechnung erfolgt nach jedem Kauf

    TanteEmmaLaden Version 2: Main (open)

    Code (Java):
    package einkaufstourzwei;

    import java.util.Scanner;

    /**
    *
    * @author Javinner
    */

    public class EinkaufsTourZwei
    {

        public static void main(String[] args)
        {
            Produkt produkt = new Produkt();
            Drucken drucken = new Drucken();
            Portemonnaie portemonnaie = new Portemonnaie();
            TanteEmmaLaden tel = new TanteEmmaLaden();

            //Guthaben anteilig ueberwiesen
            portemonnaie.setGuthaben(10);
            //Guthaben ausgezahlt
            double betrag = portemonnaie.getGuthaben();
            double kleinsterPreis = tel.getKleinsterPreis(tel.sortiment);
            double startKapital = betrag;
            int anzahlProdukt;
            boolean produktExistiert = false;
            String abfrage;

            //Butter, 1.29
            //Brot, 2.49
            //Milch, 0.79
            //Wurst, 1.99
            //Tee, 2.29
            //Einkauf
            while (betrag > 0 && betrag >= kleinsterPreis) {
                //Meldung: Produkteingabe
                drucken.infoProduktEingabe();
                //Existiert das Produkt
                while (!produktExistiert) {
                    //Eingabe Produktname
                    produkt.setName(new Scanner(System.in).nextLine());
                    //Wenn ja, Schleifenende
                    //Abbruch wenn Stop
                    if (produkt.getName().equalsIgnoreCase("Stop")) {
                        //Rechnung, Programmende
                        drucken.infoDruckeRechnung(tel.warenkorb, startKapital);
                        return;
                    }
                    produktExistiert = tel.istNameExistend(tel.sortiment, produkt);
                    //Produkt existiert nicht
                    if (!produktExistiert) {
                        //Meldung: Produkt wird nicht angeboten
                        drucken.infoProduktNichtAngeboten();
                        //Meldung: Produkteingabe
                        drucken.infoProduktEingabe();
                    }
                }
                //Bereit fuer die naechste Abfrage
                produktExistiert = false;
                //Meldung: Produktanzahl
                drucken.infoProduktAnzahl();
                //Abfrage Anzahl Ware
                anzahlProdukt = new Scanner(System.in).nextInt();
                //Abbruch wenn Null
                if (anzahlProdukt == 0) {
                    //Rechnung, Programmende
                    drucken.infoDruckeRechnung(tel.warenkorb, startKapital);
                    return;
                }
                //Durchsuchen des Array Sortiment
                for (int i = 0; i < tel.sortiment.length; i++) {
                    //Wenn Namen uebereinstimmen
                    if (tel.istGleicherName(tel.sortiment[i], produkt)) {
                        //Wenn ausreichend Guthaben fuer den Kauf
                        if (betrag >= tel.sortiment[i].getPreis() * anzahlProdukt) {
                            //Aktuallisieren Warenkorb
                            tel.warenkorb[i] += tel.sortiment[i].getPreis() * anzahlProdukt;
                            //Aktuallisieren Betrag
                            betrag -= tel.sortiment[i].getPreis() * anzahlProdukt;
                            //Drucke Zwischenrechnung
                            drucken.infoDruckeZwischenRechnung(produkt.getName(), tel.sortiment[i].getPreis(), anzahlProdukt);
                         //Weiterer Einkauf moeglich
                        } else if (betrag >= kleinsterPreis) {
                            //Meldung: warnmeldung
                            //Zeige Restguthaben
                            drucken.infoWarnMeldung(betrag);
                            //Ja/Nein Abfrage
                            abfrage = new Scanner(System.in).nextLine();
                            if (abfrage.trim().equalsIgnoreCase("Ja")) {
                                ;
                            } else {
                                //Rechnung, Programmende
                                drucken.infoDruckeRechnung(tel.warenkorb, startKapital);
                                return;
                            }
                        }
                    }
                }
            }
            //Rechnung
            drucken.infoDruckeRechnung(tel.warenkorb, startKapital);
        }
    }

    TanteEmmaLaden Version 2: Drucken (open)

    Code (Java):
    package einkaufstourzwei;

    import java.util.Date;

    /**
    *
    * @author Javinner
    */

    class Drucken
    {

        //Verschiedene Textbausteine;
        private final String abstand = "";
        private final String abschluss = "***************************** Abschluss ***";
        private final String ende = "*******************************************";
        private final String aktuellesGuthaben = "Aktuelles Guthaben: ";
        private final String einkaufssumme = "Einkaufssumme: ";
        private final String gegeben = "Gegeben: ";
        private final String restgeld = "Restgeld: ";
        private final String danke = "Vielen Dank für Ihren Einkauf";
        private final String produktEingabe = "Geben Sie den Produktnamen ein";
        private final String produktAnzahl = "Geben Sie die Anzahl an";
        private final String abbruchStop = "Abbruch mit \"Stop\"";
        private final String abbruchNull = "Abbruch mit '0'";
        private final String produktNichtAngeboten = "Das Produkt ist nicht im Sortiment";
        Date date = new Date();

        /**
         * Meldung: Aufforderung zur Angage Warenname
         */

        public void infoProduktEingabe()
        {
            System.out.println(produktEingabe);
            System.out.println(abbruchStop);
        }

        /**
         * Meldung: Aufforderung zur Angabe der Anzahl der Ware
         */

        public void infoProduktAnzahl()
        {
            System.out.println(produktAnzahl);
            System.out.println(abbruchNull);
        }
     
        public void infoProduktNichtAngeboten()
        {
            System.out.println(produktNichtAngeboten);
        }

        /**
         * druckt eine Zwischenrechnung aus; Es wird abgebildet: erste Spalte
         * {@code Produkt}, {@code Anzahl} und {@code Stueckpreis} zweite Spalte
         * {@code Gesamtpreis}
         *
         * @param string {@code Produktname}
         * @param preis {@code Produktpreis}
         * @param anzahlProdukte {@code Anzahl des Produktes}
         *
         */

        public void infoDruckeZwischenRechnung(String string, double preis, int anzahlProdukte)
        {
            //Aktuelles Produkt, Stueckpreis
            System.out.println(String.format("%-20s %dx %f", string, anzahlProdukte, preis));
            //Gesamtsumme
            System.out.println(String.format("%-30s %f", abstand, preis * anzahlProdukte));
        }

        /**
         * druckt abschliessende Rechnung aus; Es wird abgebildet:
         * {@code Einkaufssumme} {@code Gegeben} {@code Restgeld}
         * {@code ausgesprochener Dank} {@code Datum des Einkaufs}
         *
         * @param produkteArray {@code Array Produkte}
         * @param preiseArray {@code Array Preise}
         * @param startKapital {@code Gegebenes Geld}
         */

        public void infoDruckeRechnung(double[] preiseArray, double startKapital)
        {
            //Einkaufssumme
            double summe = 0;
            for (int i = 0; i < preiseArray.length; i++) {
                summe += preiseArray[i];
            }

            System.out.println(abschluss);
            System.out.println(String.format("%-30s %f", einkaufssumme, summe));
            System.out.println(String.format("%-30s %f", gegeben, startKapital));
            System.out.println(String.format("%-30s %f", restgeld, startKapital - summe));
            System.out.println();//Leerzeile
            System.out.println(danke);
            System.out.println(date);//aktuelles Datum
            System.out.println(ende);
        }

        /**
         * druckt eine {@code Warnmeldung} aus, wenn fuer ein bestimmtes Produkt das
         * Guthaben nicht ausreicht, jedoch ein weiterer Einkauf moeglich ist;
         * druckt das aktuelle {@code Guthaben} aus;
         *
         * @param betrag aktuelles {@code Guthaben}
         */

        public void infoWarnMeldung(double betrag)
        {
            System.out.println("Ihr Guthaben reicht dafür nicht aus, jedoch"
                    + "\nhaben Sie noch genug Guthaben für weiteren Einkauf."
                    + "\nmit \"Ja\" Einkauf fortsetzen");
            System.out.println(String.format("%-30s %f", aktuellesGuthaben, betrag));

        }
    }

    TanteEmmaLaden Version 2: Portemonnaie (open)

    Code (Java):
    package einkaufstourzwei;

    /**
    *
    * @author Javinner
    */

    class Portemonnaie
    {

        /**
         * aktuelles Guthaben
         */

        private double guthaben;

        /**
         * Das Guthaben wird auf {@code summe} gesetzt;
         *
         * @param summe {@code neues Guthaben}
         */

        public void setGuthaben(double summe)
        {
            this.guthaben = summe;
        }

        /**
         * liefert den aktuellen {@code Wert} des Portemonnaie;
         *
         * @return {@code aktuelles Guthaben}
         */

        public double getGuthaben()
        {
            return this.guthaben;
        }
    }

    TanteEmmaLaden Version 2: Produkt (open)

    Code (Java):
    package einkaufstourzwei;

    /**
    *
    * @author Javinner
    */

    class Produkt
    {

        /**
         * Private Variablen {@code name} und {@code preis}
         */

        private String name;
        private double preis;

        /**
         * initialisiert ein Konstruktor mit Parameterliste;
         *
         * @param name {@code name} des Produkts
         * @param preis {@code preis} des Produkts
         */

        public Produkt(String name, double preis)
        {
            this.name = name;
            this.preis = preis;
        }

        /**
         * default-Konstruktor
         */

        public Produkt()
        {
            this.name = null;
            this.preis = 0;
        }

        /**
         * liefert {
         *
         * @coee name} des Produktes nach aussen;
         *
         * @return {@code name} des Produkts
         */

        public String getName()
        {
            return this.name;
        }

        /**
         * liefert {
         *
         * @coee preis} des Produktes nach aussen;
         *
         * @return {@code preis} des Produkts
         */

        public double getPreis()
        {
            return this.preis;
        }

        /**
         * setzt neuen {@code name} des Produkts;
         */

        public void setName(String name)
        {
            this.name = name;
        }

        /**
         * setzt neuen {@code preis} des Produkts;
         */

        public void setPreis(double preis)
        {
            this.preis = preis;
        }

    }

    TanteEmmaLaden Version 2: TanteEmmaLaden (open)

    Code (Java):
    package einkaufstourzwei;

    /**
    *
    * @author Javinner
    */

    class TanteEmmaLaden
    {

        /**
         * Liste angebotener Produkte samt dazugehoerigen Preise;
         */

        Produkt[] sortiment = {new Produkt("Butter", 1.29),
            new Produkt("Brot", 2.49),
            new Produkt("Milch", 0.79),
            new Produkt("Wurst", 1.99),
            new Produkt("Tee", 2.29)};

        /**
         * Warenkorb des Kunden; Warenkorb entspricht in Laenge dem
         * Produktsortiment; Der Wert der Ware wird nach Postion und Namen dazu
         * addiert; Im weiteren Verlauf dient es der Endabrechnung,
         * {@code Klasse Drucken, void infoDruckeRechnung}
         */

        double[] warenkorb = new double[sortiment.length];

        /**
         * testet ein Array nach der {@code kleinsten Zahl}
         *
         * @param produkts {@code Array} welches getestet werden soll
         * @return {@code kleinste Zahl} des Arrays
         */

        public double getKleinsterPreis(Produkt[] produkts)
        {
            double zahl = Double.MAX_VALUE;
            for (Produkt p : produkts) {
                if (p.getPreis() < zahl) {
                    zahl = p.getPreis();
                }
            }
            return zahl;
        }

        /**
         * ueberprueft den Inhalt eines Arrays auf ein Namen;
         *
         * @param array {@code Produktarray} welcher geprueft wird
         * @param input {@code Stringeingabe} existiert
         * @return true wenn Uebereinstimmung
         */

        public boolean istNameExistend(Produkt[] array, Produkt input)
        {
            for (Produkt array1 : array) {
                if (input.getName().equalsIgnoreCase(array1.getName())) {
                    return true;
                }
            }
            return false;
        }

        /**
         * ueberprueft die Strings beider Objecte auf Gleichheit;
         *
         * @param array {@code Produktname array} des Produkts im Array
         * @param input {@code Produktname input} des Produkts Eingabe
         * @return true wenn {@code Produktname array} gleich
         * {@code Produktname input}
         */

        public boolean istGleicherName(Produkt array, Produkt input)
        {
            return (array.getName().equalsIgnoreCase(input.getName()));
        }

    }

    Programmablauf (open)

    Code (Java):
    Geben Sie den Produktnamen ein
    Abbruch mit "Stop"
    salz
    Das Produkt ist nicht im Sortiment
    Geben Sie den Produktnamen ein
    Abbruch mit "Stop"
    butter
    Geben Sie die Anzahl an
    Abbruch mit '0'
    2
    butter               2x 1,290000
                                   2,580000
    Geben Sie den Produktnamen ein
    Abbruch mit "Stop"
    Milch
    Geben Sie die Anzahl an
    Abbruch mit '0'
    3
    Milch                3x 0,790000
                                   2,370000
    Geben Sie den Produktnamen ein
    Abbruch mit "Stop"
    WURST
    Geben Sie die Anzahl an
    Abbruch mit '0'
    2
    WURST                2x 1,990000
                                   3,980000
    Geben Sie den Produktnamen ein
    Abbruch mit "Stop"
    Brot
    Geben Sie die Anzahl an
    Abbruch mit '0'
    5
    Ihr Guthaben reicht dafür nicht aus, jedoch
    haben Sie noch genug Guthaben für weiteren Einkauf.
    mit "Ja" Einkauf fortsetzen
    Aktuelles Guthaben:            1,070000
    ja
    Geben Sie den Produktnamen ein
    Abbruch mit "Stop"
    MILCH
    Geben Sie die Anzahl an
    Abbruch mit '0'
    1
    MILCH                1x 0,790000
                                   0,790000
    ***************************** Abschluss ***
    Einkaufssumme:                 9,720000
    Gegeben:                       10,000000
    Restgeld:                      0,280000

    Vielen Dank für Ihren Einkauf
    Wed Oct 11 11:12:30 CEST 2017
    *******************************************
     
    Zuletzt bearbeitet: 11. Okt. 2017
  2. Javinner
    Javinner Mitglied
    Schönheitsfehler:
    das Programm übernimmt bei Zwischenrechnung die Schreibweise der Eingabe,
    also, wenn Eingabe: "WURST", dann wird dies in die Zwischenrechnung mitübernommen.
    das liegt an der Methode
    Code (Java):

    infoDruckeZwischenRechnung(eingabe.getName(), tel.sortiment[i].getPreis(), anzahlProdukt)
     
    Richtig wäre es:
    Code (Java):

    infoDruckeZwischenRechnung(tel.sortiment[i].getName(),tel.sortiment[i].getPreis(), anzahlProdukt)
     
    Code (Java):

    /* jetzt wird richtig dargestellt! */
    Geben Sie den Produktnamen ein
    Abbruch mit "Stop"
    butter
    Geben Sie die Anzahl an
    Abbruch mit '0'
    2
    Butter               2x 1,290000
                                   2,580000
    Geben Sie den Produktnamen ein
    Abbruch mit "Stop"
    stop
    ***************************** Abschluss ***
    Einkaufssumme:                 2,580000
    Gegeben:                       10,000000
    Restgeld:                      7,420000

    Vielen Dank für Ihren Einkauf
    Wed Oct 11 13:17:52 CEST 2017
    *******************************************
     
  3. tommysenf
    tommysenf Aktives Mitglied
    Benutze die Klasse Produkt nicht für die Eingabe. Sondern lasse es dir vom Laden anhand des names aushändigen. Mache am besten das Array sortiment private. Dann kommst du automatisch zu einem vernünftigem Design.
    Eine Methode wie tel.getKleinsterPreis(tel.sortiment); braucht keinen Parameter, da der Laden ja seine Produkte kennt.
    Das ganze sollte grob umrissen in etwa so aussehen:
    Code (Text):
    String produktName = eingabe();
    Produkt auswahl = laden.getProdukt(produktName);
    if(auswahl.getPreis() .... ) { // Geldbetrag prüfen
            laden.addToWarenkorb(auswahl);
    }
    laden.druckeRechnung();
     
  4. Javinner
    Javinner Mitglied
    Vielen Dank für deine Zeit, wirklich lehrreich!
    Die Klasse Drucken gibt es nicht mehr, diese wurde in die Klasse TanteEmmaLaden
    integriert. Das mach auch mehr Sinn. Es gibt eine Methode mehr: Variable betrag
    wird duch getAktuellesGuthaben(auswahl, anzahlProdukt) aktualisiert.

    Was könnte ich noch besser machen?

    TanteEmmaLaden Version 3: Main (open)

    Code (Java):
    package einkaufstourdrei;

    import java.util.Scanner;

    /**
    *
    * @author Javinner
    */

    public class EinkaufsTourDrei
    {

        public static void main(String[] args)
        {

            Produkt auswahl;
            Portemonnaie portemonnaie = new Portemonnaie();
            TanteEmmaLaden tanteEmmaLaden = new TanteEmmaLaden();
            String produktName = null;

            portemonnaie.setGuthaben(10);//Guthaben anteilig ueberwiesen
            double betrag = portemonnaie.getGuthaben();//Guthaben ausgezahlt
            double kleinsterPreis = tanteEmmaLaden.getKleinsterPreis();
            double startKapital = betrag;
            int anzahlProdukt;
            boolean produktExistiert = false;

            //Butter, 1.29
            //Brot, 2.49
            //Milch, 0.79
            //Wurst, 1.99
            //Tee, 2.29
            while (betrag > 0 && betrag >= kleinsterPreis) {//Einkauf
                tanteEmmaLaden.druckeProduktEingabe();//Meldung: Produkteingabe
                while (!produktExistiert) {//Testschleife: Existenz Produkt
                    produktName = new Scanner(System.in).nextLine();//Eingabe Produktname
                    if (produktName.trim().equalsIgnoreCase("Stop")) {//Wenn Stop: Rechnung, Programmende
                        tanteEmmaLaden.druckeAbschlussRechnung(startKapital);//Rechnung, Programmende
                        return;
                    }
                    produktExistiert = tanteEmmaLaden.istProduktExistend(produktName);//Test: Existenz Produktname
                    if (!produktExistiert) {//Produkt existiert nicht
                        tanteEmmaLaden.druckeProduktNichtImSortiment();//Meldung: Produkt wird nicht angeboten
                        tanteEmmaLaden.druckeProduktEingabe();//Meldung: Produkteingabe
                    }
                }
                produktExistiert = false;//Bereit fuer die naechste Abfrage
                tanteEmmaLaden.druckeProduktAnzahl();//Meldung: Produktanzahl
                anzahlProdukt = new Scanner(System.in).nextInt();//Abfrage Anzahl Ware
                if (anzahlProdukt == 0) { //Abbruch wenn Null
                    tanteEmmaLaden.druckeAbschlussRechnung(startKapital);//Rechnung, Programmende
                    return;
                }
                auswahl = tanteEmmaLaden.getProdukt(produktName);//Ermittlung des Preises fuer den Produktnamen
                if (betrag >= auswahl.getPreis() * anzahlProdukt) { //Wenn ausreichend Guthaben
                    tanteEmmaLaden.addToWarenKorb(auswahl, anzahlProdukt);//Aktuallisieren Warenkorb
                    betrag -= tanteEmmaLaden.getAktuellesGuthaben(auswahl, anzahlProdukt);//Aktuallisieren Guthaben
                    tanteEmmaLaden.druckeZwischenRechnung(auswahl, anzahlProdukt);//Drucke Zwischenrechnung
                } else if (betrag >= kleinsterPreis) {
                    tanteEmmaLaden.druckeWarnMeldung(betrag);//Meldung: warnmeldung, Zeige Restguthaben
                    produktName = new Scanner(System.in).nextLine();//Ja/Nein Abfrage
                    if (produktName.trim().equalsIgnoreCase("Ja")) {
                        ;
                    } else {
                        tanteEmmaLaden.druckeAbschlussRechnung(startKapital);//Rechnung, Programmende
                        return;
                    }
                }
            }
            tanteEmmaLaden.druckeAbschlussRechnung(startKapital);//Rechnung
        }
    }

    TanteEmmaLaden Version 3: TanteEmmaLaden (open)

    Code (Java):
    package einkaufstourdrei;

    import java.util.Date;

    /**
    *
    * @author Javinner
    */

    class TanteEmmaLaden
    {

        /**
         * Verschiedene Textbausteine;
         */

        private final String abstand = "";
        private final String abschluss = "***************************** Abschluss ***";
        private final String ende = "*******************************************";
        private final String aktuellesGuthaben = "Aktuelles Guthaben: ";
        private final String einkaufssumme = "Einkaufssumme: ";
        private final String gegeben = "Gegeben: ";
        private final String restgeld = "Restgeld: ";
        private final String danke = "Vielen Dank für Ihren Einkauf";
        private final String produktEingabe = "Geben Sie den Produktnamen ein";
        private final String produktAnzahl = "Geben Sie die Anzahl an";
        private final String abbruchStop = "Abbruch mit \"Stop\"";
        private final String abbruchNull = "Abbruch mit '0'";
        private final String produktNichtAngeboten = "Das Produkt ist nicht im Sortiment";
        Date date = new Date();

        /**
         * Liste angebotener Produkte samt dazugehoerigen Preise;
         */

        private final Produkt[] sortiment = {new Produkt("Butter", 1.29),
            new Produkt("Brot", 2.49),
            new Produkt("Milch", 0.79),
            new Produkt("Wurst", 1.99),
            new Produkt("Tee", 2.29)};

        /**
         * Warenkorb des Kunden; Warenkorb entspricht in Laenge dem
         * Produktsortiment; Der Wert der Ware wird nach Postion und Namen dazu
         * addiert; Im weiteren Verlauf dient es der Endabrechnung,
         * {@code Klasse Drucken, void druckeAbschlussRechnung}
         */

        private double[] warenkorb = new double[sortiment.length];

        /**
         * Meldung: Aufforderung zur Angage Warenname
         */

        public void druckeProduktEingabe()
        {
            System.out.println(produktEingabe);
            System.out.println(abbruchStop);
        }

        /**
         * Meldung: Aufforderung zur Angabe der Anzahl der Ware
         */

        public void druckeProduktAnzahl()
        {
            System.out.println(produktAnzahl);
            System.out.println(abbruchNull);
        }

        public void druckeProduktNichtImSortiment()
        {
            System.out.println(produktNichtAngeboten);
        }

        /**
         * druckt eine Zwischenrechnung aus; Es wird abgebildet: erste Spalte
         * {@code Produkt}, {@code Anzahl} und {@code Stueckpreis} zweite Spalte
         * {@code Gesamtpreis}
         *
         * @param string {@code Produktname}
         * @param preis {@code Produktpreis}
         * @param anzahlProdukte {@code Anzahl des Produktes}
         *
         */

        public void druckeZwischenRechnung(Produkt produkt, int anzahlProdukte)
        {
            //Aktuelles Produkt, Stueckpreis
            System.out.println(String.format("%-20s %dx %f", produkt.getName(), anzahlProdukte, produkt.getPreis()));
            //Gesamtsumme
            System.out.println(String.format("%-30s %f", abstand, produkt.getPreis() * anzahlProdukte));
        }

        /**
         * druckt abschliessende Rechnung aus; Es wird abgebildet:
         * {@code Einkaufssumme} {@code Gegeben} {@code Restgeld}
         * {@code ausgesprochener Dank} {@code Datum des Einkaufs}
         *
         * @param produkteArray {@code Array Produkte}
         * @param preiseArray {@code Array Preise}
         * @param startKapital {@code Gegebenes Geld}
         */

        public void druckeAbschlussRechnung(double startKapital)
        {
            double summe = 0;
            for (int i = 0; i < this.warenkorb.length; i++) {
                summe += this.warenkorb[i];
            }

            System.out.println(abschluss);
            System.out.println(String.format("%-30s %f", einkaufssumme, summe));
            System.out.println(String.format("%-30s %f", gegeben, startKapital));
            System.out.println(String.format("%-30s %f", restgeld, startKapital - summe));
            System.out.println();//Leerzeile
            System.out.println(danke);
            System.out.println(date);//aktuelles Datum
            System.out.println(ende);
        }

        /**
         * druckt eine {@code Warnmeldung} aus, wenn fuer ein bestimmtes Produkt das
         * Guthaben nicht ausreicht, jedoch ein weiterer Einkauf moeglich ist;
         * druckt das aktuelle {@code Guthaben} aus;
         *
         * @param betrag aktuelles {@code Guthaben}
         */

        public void druckeWarnMeldung(double betrag)
        {
            System.out.println("Ihr Guthaben reicht dafür nicht aus, jedoch"
                    + "\nhaben Sie noch genug Guthaben für weiteren Einkauf."
                    + "\nmit \"Ja\" Einkauf fortsetzen");
            System.out.println(String.format("%-30s %f", aktuellesGuthaben, betrag));

        }

        /**
         * aktuallisiert den Warenkorb; Der Array sortiment wird dabei durchlaufen
         * und wenn der {@code produkt} Name mit dem Produktnamen im Array
         * uebereinstimmt, wird der {@code produkt} Preis x {@code anzahlProdukt} im
         * Warenkorb dazu addiert;
         *
         * @param produkt {@code produkt} Produktname
         * @param anzahlProdukt {@code anzahlProdukt} Produktanzahl
         */

        public void addToWarenKorb(Produkt produkt, int anzahlProdukt)
        {
            for (int i = 0; i < this.sortiment.length; i++) {
                if (this.sortiment[i].getName().equalsIgnoreCase(produkt.getName())) {
                    this.warenkorb[i] += this.sortiment[i].getPreis() * anzahlProdukt;
                }
            }
        }

        /**
         * berechnet den Wert des momentanen Einkaufs und liefert diesen;
         *
         * @param produkt {@code produkt} Produktpreis
         * @param anzahlProdukt {@code anzahlProdukt} Produktanzahl
         */

        public double getAktuellesGuthaben(Produkt produkt, int anzahlProdukt)
        {
            return produkt.getPreis() * anzahlProdukt;
        }

        /**
         * testet ein Array nach der {@code kleinsten Zahl}
         *
         * @param produkts {@code Array} welches getestet werden soll
         * @return {@code kleinste Zahl} des Arrays
         */

        public double getKleinsterPreis()
        {
            double zahl = Double.MAX_VALUE;
            for (Produkt p : this.sortiment) {
                if (p.getPreis() < zahl) {
                    zahl = p.getPreis();
                }
            }
            return zahl;
        }

        /**
         * ueberprueft die Strings beider Objecte auf Gleichheit;
         *
         * @param array {@code Produktname array} des Produkts im Array
         * @param input {@code Produktname input} des Produkts Eingabe
         * @return true wenn {@code Produktname array} gleich
         * {@code Produktname input}
         */

        public Produkt getProdukt(String eingabe)
        {
            for (Produkt produkt : this.sortiment) {
                if (eingabe.trim().equalsIgnoreCase(produkt.getName())) {
                    return produkt;
                }
            }
            return null;
        }

        /**
         * ueberprueft den Inhalt eines Arrays auf ein Namen;
         *
         * @param array {@code Produktarray} welcher geprueft wird
         * @param input {@code Stringeingabe} existiert
         * @return true wenn Uebereinstimmung
         */

        public boolean istProduktExistend(String eingabe)
        {
            for (Produkt array1 : this.sortiment) {
                if (eingabe.trim().equalsIgnoreCase(array1.getName())) {
                    return true;
                }
            }
            return false;
        }

    }
     
  5. tommysenf
    tommysenf Aktives Mitglied
    Sieht doch schon ganz gut aus.
    Ein paar Anmerkungen noch:
    1. Den Gültigkeitsbereich von Variablen solltest du möglichst gering halten. Deklariere sie dort wo sie gebraucht werden und nicht pauschal am Anfang der Methode.
    2. Du musst nicht für jede Eingabe ein neues Scanner Objekt erzeugen, sondern kannst es wiederverwenden
    3.
    Hier vergewaltigst du die Variable Produktname für die Ja/Nein Abfrage. Das erwartet man so nicht. Nutze einen aussagekräftigen Variablennamen. Der leere if-Zweig ist auch unnötig. Du kannst die Bedingung doch einfach umkehren:
    Code (Java):

                    if (!scanner.nextLine().trim().equalsIgnoreCase("Ja")) {
                        break;
                    }
    4. Kommentare sind meist ein Zeichen von schlechtem Code. Der Code sollte durch die Namenswahl selbsterklärend sein.
    5. Nutze do ... while Schleifen wo es angebracht ist.
    6. Nutze deinen eigenen Code, das vermeidet Dopplungen und ist wesentlich wartbarer:
    Code (Java):
    public boolean istProduktExistend(String eingabe)
        {
            return getProdukt(name) != null;
        }
     
     
  6. Javinner
    Javinner Mitglied
    Vielen Dank, hab alles soweit korrigiert. Zugegeben, mir leuchtet es noch nicht ein, wann ich eine do{}while der while(){} Schleife vorziehen muss/soll. Werde ab sofort kreativer den Code gestalten, wobei das mit Kommentaren der Übersicht dienen soll. So nach dem Motto:
    wenn jemand schon Mühen auf sich nimmt, mich zu verbessern, sollte ich min. genau soviel
    Mühe aufbringen, damit es sauber und ordentlich aussieht.
    Das mit istProduktExistend() ist wirklich genial! Habe ich garnicht gesehen. Da muss ich mein Auge darauf schärfen.

    Nochmal Danke, bist wirklich eine große Hilfe!
     
  7. Javinner
    Javinner Mitglied
    Inspiriert durch: https://www.java-forum.org/thema/schlangenspiel-logikfehler.178957/#post-1135510

    Die lustige Sieben
    • Java ist auch eine Insel
    • Kapitel 4 Der Umgang mit Zeichenketten
    • Kapitel 5 Eigene Klassen schreiben
    Main (open)

    Code (Java):
    package lustigesieben;

    import java.util.Scanner;

    /**
    *
    * @author Javinner
    */

    class LustigeSieben
    {

        public static void main(String[] args)
        {
            Spieler spieler = new Spieler(100);
            SpielCasino sc = new SpielCasino();
            Wuerfel wuerfel = new Wuerfel();
            Scanner scanner = new Scanner(System.in);

            int spieleinsazt;

            sc.druckenAnfangBegruessung();
            sc.setWunschzahl(scanner.nextInt());
            if (sc.getWunschzahl() == 0) {
                sc.druckeAbschlussErgebnis(spieler);
                return;
            }
            while (sc.getWunschzahl() != 0 && spieler.getGuthaben() != 0) {
                sc.setAugenZahl(wuerfel.getAugenZahl() + wuerfel.getAugenZahl());
                sc.druckenAufforderungZahlZahlenReihe();
                sc.setWunschzahl(scanner.nextInt());
                if (sc.getWunschzahl() == 0) {
                    sc.druckeAbschlussErgebnis(spieler);
                    return;
                } else {
                    if (sc.istAusserhalbZahlenBereich()) {
                        while (sc.istAusserhalbZahlenBereich() && sc.getWunschzahl() != 0) {
                            sc.druckenAusserZahlenBereich();
                            sc.druckenAufforderungZahlZahlenReihe();
                            sc.setWunschzahl(scanner.nextInt());
                        }
                        if (sc.getWunschzahl() == 0) {
                            sc.druckeAbschlussErgebnis(spieler);
                            return;
                        }
                    }
                    sc.druckenAufforderungSpieleinsatz();
                    spieleinsazt = scanner.nextInt();
                    if (spieleinsazt > spieler.getGuthaben()) {
                        while (spieleinsazt > spieler.getGuthaben() && spieleinsazt != 0) {
                            sc.druckenNichtGenugGeld(spieler.getGuthaben());
                            spieleinsazt = scanner.nextInt();
                        }
                        if (spieleinsazt == 0) {
                            sc.druckeAbschlussErgebnis(spieler);
                            return;
                        }
                    }
                    if (sc.istDreifach()) {
                        spieler.addGewinn(spieleinsazt * SpielCasino.DREIFACH);
                        sc.druckenZwischenStandGewonnen(spieler, spieleinsazt * SpielCasino.DREIFACH);
                    } else if (sc.istDoppelt()) {
                        spieler.addGewinn(spieleinsazt * SpielCasino.DOPPELT);
                        sc.druckenZwischenStandGewonnen(spieler, spieleinsazt * SpielCasino.DOPPELT);
                    } else if (sc.istEinfach()) {
                        spieler.addGewinn(spieleinsazt);
                        sc.druckenZwischenStandGewonnen(spieler, spieleinsazt);
                    } else {
                        spieler.subGewinn(spieleinsazt);
                        sc.druckenZwischenStandVerloren(spieler, spieleinsazt);
                    }
                }
            }
            sc.druckeAbschlussErgebnis(spieler);
        }
    }

    SpielCasino (open)

    Code (Java):
    package lustigesieben;

    import java.util.Arrays;

    /**
    *
    * @author Javinner
    */

    public class SpielCasino
    {

        /**
         * Multiplikator Gewinn;
         */

        public final static int DREIFACH = 3;
        public final static int DOPPELT = 2;

        /**
         * Variable: dreifacher Gewinn
         */

        private final int sieben = 7;
        /**
         * Zahlenbereich: untere und obere Grenze Feld A; {@code aGrenzeKlein} wird
         * von Methode druckenAufforderungZahlZahlenReihe benutzt, so dass eine
         * moegliche Aenderung hier fuer alles gilt;
         */

        private final int aGrenzeKlein = 2;
        private final int aGrenzeGross = 6;

        /**
         * Zahlenbereich: untere und obere Grenze Feld B; {@code bGrenzeGross} wird
         * von Methode druckenAufforderungZahlZahlenReihe benutzt, so dass eine
         * moegliche Aenderung hier fuer alles gilt;
         */

        private final int bGrenzeKlein = 8;
        private final int bGrenzeGross = 12;

        /**
         * Augenzahl Spieler;
         */

        private int augenzahl;
        /**
         * Wunschzahl Spieler
         */

        private int wunschzahl;

        /**
         * verschiedene Textbausteine;
         */

        private final String gebeZahlEin = "Geben Sie eine Wunschzahl zwischen";
        private final String gebeZahlEinZwischenUnd = "und";
        private final String gebeZahlEinZwischenUndEin = "ein";
        private final String spielEinsazt = "Ihr Spieleisatz bitte";
        private final String aktuelleSpielsumme = "Ihr aktuelles Guthaben beträgt";
        private final String gutGeschrieben = "Ihrem Guthaben wurde die Summe";
        private final String gutGeschriebenEnde = "gutgeschrieben. Gratulation!";
        private final String verloren = "Sie haben Ihr Einsatz in Höhe von";
        private final String verlorenEnde = "leider verloren!";
        private final String dankesRede = "Vielen Dank für Ihren Besuch!";
        private final String sieHabenHeute = "Sie haben Heute";
        private final String sieHabenGewonnenEnde = "gewonnen";
        private final String sieHabenVerlorenEnde = "verloren";
        private final String beehrenSieUnsBaldWieder = "Bitte beehren Sie uns bald wieder!";
        private final String nichts = "nichts";
        private final String euro = "EUR";
        private final String ihrMaxiumLiegtBei = "Ihr maxium liegt bei";
        private final String abbruchSpiel = "Sie können das Spiel mit '0' abbrechen";
        private final String ichWillSpielen = "Zum Spielen bitte '1' tippen";
        private final String oder = "oder ";
        private final String ausserZahlenReihe = "Die Zahl";
        private final String ausserZahlenReiheEnde = "ist außerhalb des Zahlenbereiches";
        private final String anfang = "Herzlich Willkommen in unserem Spielcasino";
        private final int arrayLaenge = 45;
        private char[] c;

        /**
         * Eroeffnung des Spiels;
         */

        public void druckenAnfangBegruessung()
        {
            c = new char[arrayLaenge];
            Arrays.fill(c, '*');
            System.out.println(c);
            System.out.println(anfang);//Begruessung
            System.out.println(abbruchSpiel);//Abbruch Angebot
            System.out.println(ichWillSpielen);//Weiter zum Spiel
            System.out.println(c);
        }

        /**
         * Meldung, wenn {@code wunschzahl} ausserhalb des Zahlenbereiches liegt;
         *
         */

        public void druckenAusserZahlenBereich()
        {
            System.out.println(String.format("%s %d %s", ausserZahlenReihe, this.wunschzahl, ausserZahlenReiheEnde));
        }

        /**
         * Meldung Information Spielverlauf; {@code aGrenzeKlein} und
         * {@code bGrenzeGross} stehen fuer Zahlenreihe;
         */

        public void druckenAufforderungZahlZahlenReihe()
        {
            System.out.println(String.format("%s %d %s %d %s", gebeZahlEin, aGrenzeKlein, gebeZahlEinZwischenUnd, bGrenzeGross, gebeZahlEinZwischenUndEin));
            System.out.println(abbruchSpiel);
        }

        /**
         * Meldung Information Spielverlauf;
         */

        public void druckenAufforderungSpieleinsatz()
        {
            System.out.println(spielEinsazt);
        }

        /**
         * Meldung Zwischenstand, wenn gewonnen, Ausgabe gewonnenes Geld, aktuelles
         * Kapital;
         *
         * @param spieler {@code aktueller Spieler}
         * @param spieleinsatz {@code Spieleinsatz aktuell}
         */

        public void druckenZwischenStandGewonnen(Spieler spieler,
                int spieleinsatz)
        {
            System.out.println(String.format("%s %d %s %s %s %d %s", gutGeschrieben, spieleinsatz, euro, gutGeschriebenEnde, aktuelleSpielsumme, spieler.getGuthaben(), euro));
        }

        /**
         * Meldung Zwischenstand, wenn verloren, Ausgabe verlorenes Geld, aktuelles
         * Kapital;
         *
         * @param spieler {@code aktueller Spieler}
         * @param spieleinsatz {@code Spieleinsatz aktuell}
         */

        public void druckenZwischenStandVerloren(Spieler spieler,
                int spieleinsatz)
        {
            System.out.println(String.format("%s %d  %s %s %s %d %s", verloren, spieleinsatz, euro, verlorenEnde, aktuelleSpielsumme, spieler.getGuthaben(), euro));
        }

        /**
         * Meldung bei Spielende; Zusammenfassen des Spiels;
         *
         * @param spieler {@code spieler} Aktueller Spieler
         */

        public void druckeAbschlussErgebnis(Spieler spieler)
        {
            //Wenn gewonnen
            if (spieler.getGuthaben() >= spieler.getMerkeSumme()) {
                int i = spieler.getGuthaben() - spieler.getMerkeSumme();
                //Wenn gleich Null
                if (i == 0) {
                    System.out.println(String.format("%s %s %s %s %s", dankesRede, sieHabenHeute, nichts, sieHabenGewonnenEnde, beehrenSieUnsBaldWieder));

                } else {
                    //Wenn groesser Null
                    System.out.println(String.format("%s %s %d %s %s %s", dankesRede, sieHabenHeute, i, euro, sieHabenGewonnenEnde, beehrenSieUnsBaldWieder));
                }
            } else {
                //Verloren
                int i = spieler.getMerkeSumme() - spieler.getGuthaben();
                System.out.println(String.format("%s %s %d %s %s %s", dankesRede, sieHabenHeute, i, euro, sieHabenVerlorenEnde, beehrenSieUnsBaldWieder));
            }
        }

        /**
         * Meldung, wenn Spieleinsazt die {@code groesstmoegliche Summe}
         * uebersteigt;
         *
         * @param spielsumme {@code groesstmoegliche Summe}
         */

        public void druckenNichtGenugGeld(int spielsumme)
        {
            System.out.println(String.format("%s %d  %s %s %d %s", aktuelleSpielsumme, spielsumme, euro, ihrMaxiumLiegtBei, spielsumme, euro));
            System.out.println(abbruchSpiel);
            System.out.println(oder.concat(spielEinsazt));
        }

        /**
         * Variable {@code augenzahl} wird mit {@code augen} ueberschireben;
         *
         * @param augen {@code neue augenzahl}
         */

        public void setAugenZahl(int augen)
        {
            this.augenzahl = augen;
        }

        /**
         * Variable {@code wunschzahl} wird mit {@code wZahl} ueberschrieben;
         *
         * @param wZahl {@code neue wunschzahl}
         */

        public void setWunschzahl(int wZahl)
        {
            this.wunschzahl = wZahl;
        }

        /**
         * liefert aktuelle {@code wunschzahl} nach aussen;
         *
         * @return {@code wunschzahl}
         */

        public int getWunschzahl()
        {
            return this.wunschzahl;
        }

        /**
         * prueft, ob die {@code wunschzahl} ausserhalb des Zahlenbereiches
         * {@code aGrenzeKlein} und {@code bGrenzeGross} des Spiels liegt;
         *
         * @return true wenn {@code wunschzahl} ausserhalb des Zahlenbereiches liegt
         */

        public boolean istAusserhalbZahlenBereich()
        {
            return this.wunschzahl < aGrenzeKlein || this.wunschzahl > bGrenzeGross;
        }

        /**
         * Bedingung fuer dreifachen Gewinn;
         *
         * @return true wenn Wuerfelzahl und Tippzahl gleich {@code sieben}
         */

        public boolean istDreifach()
        {
            return this.augenzahl == sieben && this.wunschzahl == sieben;

        }

        /**
         * Bedingung fuer doppelten Gewinn;
         *
         * @return true wenn Wuerfelzahl gleich Tippzahl
         */

        public boolean istDoppelt()
        {
            return this.wunschzahl == this.augenzahl;
        }

        /**
         * Bedingung fuer einfachen Gewinn;
         *
         * @return true wenn Wuerfelzahl und Tippzahl im gleichen Feld liegen;
         */

        public boolean istEinfach()
        {
            boolean a = istVonZweiBisSechs();
            boolean b = istVonAchtBisZwoelf();
            return ((a && !b) || (b && !a));
        }

        /**
         * Hilfsmethode;
         *
         * @return true wenn {@code augenzahl} und {@code wunschzahl} im gleichen
         * Feld zwischen {@code aGrenzeKlein} && {@code aGrenzeGross} liegen;
         */

        private boolean istVonZweiBisSechs()
        {
            return ((this.augenzahl >= aGrenzeKlein && this.augenzahl <= aGrenzeGross)
                    && (this.wunschzahl >= aGrenzeKlein && this.wunschzahl <= aGrenzeGross));
        }

        /**
         * Hilfsmethode;
         *
         * @return true wenn {@code augenzahl} und {@code wunschzahl} im gleichen
         * Feld zwischen {@code bGrenzeKlein} && {@code bGrenzeGross} liegen;
         */

        private boolean istVonAchtBisZwoelf()
        {
            return ((this.augenzahl >= bGrenzeKlein && this.augenzahl <= bGrenzeGross)
                    && (this.wunschzahl >= bGrenzeKlein && this.wunschzahl <= bGrenzeGross));
        }

    }

    Spieler (open)

    Code (Java):
    package lustigesieben;

    /**
    *
    * @author Javinner
    */

    public class Spieler
    {

        /**
         * {@code spielsumme} Betrag zum Spielen;
         */

        private int spielsumme;
        /**
         * Merkt die Startsumme; Wird bei der Abschlussrechnung eingesetzt;
         */

        private final int merkeSumme;

        /**
         * parametriesierter Konstruktor; bei Erzeugung {@code spielsumme}
         * Betrageingabe; Betrag wird in der Variable {@code merkeSumme} fuer die
         * Abrechnung festgehalten;
         *
         * @param spielsumme {@code spielsumme}
         */

        public Spieler(int spielsumme)
        {
            this.spielsumme = spielsumme;
            this.merkeSumme = spielsumme;
        }

        /**
         * liefert den Betrag {@code spielsumme} nach aussen;
         *
         * @return {@code aktuelles Guthaben}
         */

        public int getGuthaben()
        {
            return spielsumme;
        }

        /**
         * liefert {@code merkeSumme} fuer die Abrechnung nach aussen;
         *
         * @return {@code merkeSumme}
         */

        public int getMerkeSumme()
        {
            return this.merkeSumme;
        }

        /**
         * subtrahiert den {@code verlust} von {@code spielsumme}
         *
         * @param verlust {@code aktuell verlorenes Geld}
         */

        public void subGewinn(int verlust)
        {
            this.spielsumme -= verlust;
        }

        /**
         * addiert den {@code gewinn} zu der {@code spielsumme}
         *
         * @param gewinn {@code aktuell gewonnenes Geld}
         */

        public void addGewinn(int gewinn)
        {
            this.spielsumme += gewinn;
        }

    }

    Würfel (open)

    Code (Java):
    package lustigesieben;

    /**
    *
    * @author Javinner
    */

    public class Wuerfel
    {

        /**
         * Variable max. Zahl;
         */

        private final int augen = 6;

        /**
         * liefert eine {@code Zufallszahl} nach ausssen;
         *
         * @return {@code Zufallszahl}
         */

        public int getAugenZahl()
        {
            int z = 0;
            while (z == 0) {
                z = (int) (Math.random() * augen);
            }
            return z;
        }
    }
     
Die Seite wird geladen...

Wachsen mit dem Buch "Java ist auch eine Insel" - Ähnliche Themen

Byte Array wachsen lassen
Byte Array wachsen lassen im Forum Java Basics - Anfänger-Themen
FormLayout dynamisch wachsend
FormLayout dynamisch wachsend im Forum AWT, Swing, JavaFX & SWT
Hilfe bei mitwachsenden Textboxen.
Hilfe bei mitwachsenden Textboxen. im Forum Für Verirrte - Fragen zu JavaScript
letzte Zeile aus wachsender Textdatei auslesen
letzte Zeile aus wachsender Textdatei auslesen im Forum Java Basics - Anfänger-Themen
Mitwachsende JTextArea+ JPanel
Mitwachsende JTextArea+ JPanel im Forum AWT, Swing, JavaFX & SWT
Thema: Wachsen mit dem Buch "Java ist auch eine Insel"