Scanner Ausgabe

[Loveprogramming]

Hallo allseits,

diesmal habe ich reine Ausgaben-Probleme. Die Methoden der Klasse funktionieren einwandfrei habe diese auch einzeln getestet. Also hier ist die EBNF-Beschreibung:

<Eingabe> ::= <Bruch>{<Operator><Bruch>} .
<Bruch> ::= <Zahl><Zahl>
<Zahl> ::= ganze Zahl in Dezimaldarstellung
<Operator> ::= +|-|*|/

Der Benutzer kann n beliebige Brüche eingeben. Es wird ein Bruch eingegeben, dann kommt der Operator und zum Schluss noch ein Bruch. Das ganze kann n beliebig mal wiederholt werden.

Eine Bespiel-Eingabe für zwei Brüche wäre:

1 2     --> Bruch 1
+       --> Operator
2 4     --> Bruch 2

1/1     --> Ergebnis

Eine Bespiel-Eingabe für drei Brüche wäre:

1 2     --> Bruch 1
+       --> Operator
2 4     --> Bruch 2
-       --> Operator
4 −3    --> Bruch 3

7/3    --> Ergebnis

Ich habe es nicht so gut hinbekommen, da ich selten mit Scanner arbeite. Nicht zu vergessen ist, dass die Methoden funktionieren. Ich muss das ganze nur noch ausgeben, denen ein Eingabesyntax vorgeschrieben wird. Ich freue mich schon auf die Rückmeldungen.

EDİT:
Die Brüche werden in einem Objekt der Klasse Rational gespeichert:

Rational bruch = new Rational(zaehler, nenner);

Mathematische Funktionen werden wie folgt aufgerufen:

bruch.add(bruch2);
bruch.sub(bruch2);
bruch.mul(bruch2);
bruch.div(bruch2);

 

[Javinner]

Wenn ich dich richtig verstanden habe:
Es soll eine individuelle Eingabe von Brüchen statt finden, deren Anzahl variiert, jedoch diese durch Operationszeichen getrennt sind. Dann soll die Eingabe ausgewertet werden, die Brüche eingelesen und je nach Funktion ausgegeben werden.
Beispiel: 1/3 + 2/3 + 1/2
Ausgabe: 3,5

Ist es so korrekt?

 

[Loveprogramming]

Wenn ich dich richtig verstanden habe:
Es soll eine individuelle Eingabe von Brüchen statt finden, deren Anzahl variiert, jedoch diese durch Operationszeichen getrennt sind. Dann soll die Eingabe ausgewertet werden, die Brüche eingelesen und je nach Funktion ausgegeben werden.
Beispiel: 1/3 + 2/3 + 1/2
Ausgabe: 3,5

Ist es so korrekt?

Genau so meine ich es.

 

[fhoffmann]

Ist wirklich die Ausgabe das Problem?

class Rational {
  int zaehler;
  int nenner;
  // diverser Code
  public void ausgabe() {
     System.out.println(zaehler + "/" + nenner);
  }
}

 

[Loveprogramming]

Ist wirklich die Ausgabe das Problem?

class Rational {
  int zaehler;
  int nenner;
  // diverser Code
  public void ausgabe() {
     System.out.println(zaehler + "/" + nenner);
  }
}

Ich glaube du hast mich komplett missverstanden. Es geht nicht um die Ausgabe von Zaehler und Nenner. Dafür habe ich schon eine überschriebene toString Methode. Wie kann ich es so programmieren, dass ich n beliebige Brüche eingeben kann, diese dann in einem Objekt der Klasse Ratioanl speichere. Nach jeder Brucheingabe erfolgt auch ein Operator sprich, der User gibt Beispielsweise:

1 2
+
2 4
-
4 -3

ein, dann sollen die Zahlen erstmal in einem Objekt gespeichert werden (einzeln):

Rational bruch_1 = new Rational(1, 2);
Rational bruch_2 = new Rational(2, 4);
Rational bruch_3 = new Rational(4, -3);

Es wurde erstmal  + Operator verwendet:
bruch_1.add(bruch_2);
Rational zwischenErgebnis = bruch_1.add(bruch_2);

Danach wurde minus verwendet:
zwischenErgebnis.sub(bruch_3);

So wie ich es geschrieben habe ist es ja manuell. Ich möchte es so umstellen, dass das ganze n beliebig wiederholt werden kann.

 

[fhoffmann]

diesmal habe ich reine Ausgaben-Probleme

Es geht nicht um die Ausgabe

Das widerspricht sich doch.

 

[truesoul]

Hallo.

Ich blicke nicht ganz durch bei deiner Beschreibung und ich hoffe, dass ich dich richtig verstanden habe.

Das klappt schon, ja?

Rational bruch_1 = new Rational(1, 2);
Rational bruch_2 = new Rational(2, 4);
Rational bruch_3 = new Rational(4, -3);

Jetzt möchtest du alle Eingegebene Brüche den richtigen Operationen (add, sub, div, mul) ausführen lassen, und wenn du damit fertig bist. Willst du das Ergebnis z. B:

Beispiel: 1/3 + 2/3 + 1/2
Ausgabe: 3,5

ausgeben lassen?

Grüße

 

[Javinner]

Wie kann ich es so programmieren, dass ich n beliebige Brüche eingeben kann, diese dann in einem Objekt der Klasse Ratioanl speichere

Eingabe als String, welcher dann zerlegt und ausgelesen wird:
http://openbook.rheinwerk-verlag.de/javainsel/javainsel_04_009.html
Ist kein leichtes Thema, denn wenn die Eingabe so aussieht:
1/5 - 5/6 * 3/4 + 1/2 / 2/7
wird es interessant. Da muss eine Logik eingebaut werden, welche die Vorrangigkeit testet und unter Beachtung dieser die Formel richtig auflöst.

 

[Loveprogramming]

Eingabe als String, welcher dann zerlegt und ausgelesen wird:
http://openbook.rheinwerk-verlag.de/javainsel/javainsel_04_009.html
Ist kein leichtes Thema, denn wenn die Eingabe so aussieht:
1/5 - 5/6 * 3/4 + 1/2 / 2/7
wird es interessant. Da muss eine Logik eingebaut werden, welche die Vorrangigkeit testet und unter Beachtung dieser die Formel richtig auflöst.

Genau das ist mein Problem, nur dass ich das ganze nicht zusammen schreibe sondern getrennt. Also zuerst ein Bruch 1/5, naechste Zeile mit Operator, naechste Zeile noch ein Bruch usw..

 

[Loveprogramming]

Das widerspricht sich doch.

Waere echt super wenn du es zu ende lesen würdest. " Es geht nicht um die Ausgabe von Zaehler und Nenner". Das was der User eingibt soll ausgegeben werden, welches n beliebig wiederholt werden kann.

 

[Xyz1]

<Bruch> ::= <Zahl><Zahl>
<Zahl> ::= ganze Zahl in Dezimaldarstellung

Wie soll das denn gehen????

1010 ist jetzt 1 und 10, 10 und 10 Oder 101 und 0????

Die ganze Mächtigkeit der EBNF darf gern....
----
Geht es jetzt nur um sich wiederholende Haupteingaben?

 

[mrBrown]

Waere echt super wenn du es zu ende lesen würdest. " Es geht nicht um die Ausgabe von Zaehler und Nenner". Das was der User eingibt soll ausgegeben werden, welches n beliebig wiederholt werden kann.

Das ist dann aber eher ein Eingabe-(oder Verarbeitungs-)Problem (zumindest dreht sich alles um die Eingabe und Verarbeitung, Ausgabe funktioniert ja wie du selbst sagst...).

 

[mrBrown]

Gilt Punkt vor Strich?

 

[Loveprogramming]

Wie soll das denn gehen????

So lautet die Aufgabenstellung und die Eingabe sieht dann so aus:
Zahl1 LEERZEICHEN Zahl2

Geht es jetzt nur um sich wiederholende Haupteingaben?

Der User kann n beliebige Brüche und Operatoren eingeben. Es wird ein Objekt der Klasse Rational erzeugt und die eingegebene Brüche werden in das Objekt gespeichert. Je nach Operator werden die Mathematische Methoden aufgerufen. Das ganze wird n beliebig wiederholt und die eingaben werden ausgegeben-

 

[Loveprogramming]

Gilt Punkt vor Strich?

Davon steht nichts..

 

[mrBrown]

Also im wesentlichen:

1. Bruch einlesen und als Zwischenergebnis speichern
2. wenn noch weitere Eingabe:
3. Operator einlesen
4. Bruch einlesen
5. Operator auf beide Zwischenergebnis und Bruch anwenden und als Zwischenergebnis speichern
6. wieder zu 2.
7 sonst: Ergebnis ausgeben

Wo hapert's denn dabei?

 

[Loveprogramming]

Also im wesentlichen:

1. Bruch einlesen und als Zwischenergebnis speichern
2. wenn noch weitere Eingabe:
3. Operator einlesen
4. Bruch einlesen
5. Operator auf beide Zwischenergebnis und Bruch anwenden und als Zwischenergebnis speichern
6. wieder zu 2.
7 sonst: Ergebnis ausgeben

Wo hapert's denn dabei?

Das ich das ganze nicht n beliebig darstellen kann. Ich kann zwei Brüche und ein Operator eingeben, welches auch einwandfrei funktioniert. Mir fehlt die Logik das ganze n beliebig darzustellen. Aber genau wie du es gelistet hast sollte es dargestellt werden.

 

[mrBrown]

Du hast dabei immer nur zwei Brüche, das bisherige Zwischenergebnis und den neu eingelesenen.

Woran scheitert die Umsetzung denn?
Daran, dass ganze in einer Schleife ablaufen zu lassen?

 

[Loveprogramming]

Du hast dabei immer nur zwei Brüche, das bisherige Zwischenergebnis und den neu eingelesenen.

Woran scheitert die Umsetzung denn?
Daran, dass ganze in einer Schleife ablaufen zu lassen?

Genau das ist ja das Problem.

Pseudocode:

User Input:

Zahl1 Zahl2      --> Bruch1
Operator (+)    
Zahl1 Zahl2       -->Bruch2

Ergebnis Ausgabe oder weiter:
Operator (+)
Zahl1 Zahl2       -->Bruch3

Ergebnis Ausgabe oder weiter:
Operator (*)
Zahl1 Zahl2       -->Bruch4

USW..
Das ganze wird dann n beliebig wiederholt

 

[Javinner]

Ich lege dir ans Herz, die Form deiner Anfrage zu optimieren, in dem du:

• die Aufgabenstellung
• die Problembeschreibung
• bisherigen Versuche in Form von Code

kurz und verständlich postest. Ich schließe mich den anderen Forumsteilnehmer an, wenn es darum geht, Schwierigkeiten beim Verstehen der Problembeschreibung gehabt zu haben. Ich hoffe, ich liege mit meiner Antwort hier richtig

Das ich das ganze nicht n beliebig darstellen kann.

...

while(!bruch.istRechnungsEnde(input))
{
    //Abfrage Bruch A
    //Abfrage Bruch B
    //Operator - Wenn "=" Programmende
}
/** Jede Rechnung hat ihr Ende mit "=" Zeichen, so baue doch eine Wahrheitsbedingung ein. */
protected boolean istRechnungsEnde(String string)
{
    return string.trim().equals("=");
}

 

[Loveprogramming]

Die Aufgabenstellung:

[...] Schreiben Sie schließlich eine Klasse mit einer main-Methode, die die Klasse testet. In main soll über die Tastatur zur Laufzeit Brüche und Operationssymbole eingegeben werden. Die erlaubte Eingabesyntax wird durch die folgende EBNF-Beschreibung angegeben:

<Eingabe> ::  <Bruch>{<Operator><Bruch>}
<Bruch> :: <Zahl><Zahl>
<Zahl> :: ganze Zahl in Dezimaldarstellung
<Operator> :: +|-|*|/

Beispiel 1 für eine Eingabe:
1 2
+
2 4
erzeugt als Ausgabe
1/1

Beispiel 2 für eine Eingabe:
1 2
+
2 4
-
4 −3

erzeugt als Ausgabe
7/3

Die Problembeschreibung:
All die mathematische Methoden funktionieren und dabei gibt es erstmal keinerlei Probleme. Die fertig geschriebene Klasse soll nun eingesetzt werden, um die Brüche auszugeben. Die Eingaben können n beliebig wiederholt werden und am ende der Eingabe werden jeweils die Ergebnisse angezeigt. Der Nutzer gibt in der ersten Zeile zwei Zahlen ein dies stellt ein Bruch dar. Beispielsweise wird: 1 (LEERZEİCHEN) 2 eingegeben. In der zweiten Zeile wird der Operator angegeben. Je nach dem werden danach die Mathematische Methoden aufgerufen. In der dritten Zeile wird noch ein Bruch eingegeben. Nun wird das Ergebnis angezeigt ODER der Nutzer gibt weitere Brüche und Operatoren ein.

Bisherigen Versuche in Form von Code:

public static void main(String[] args) {
     
        Scanner sf = new Scanner(System.in);
        Rational[] bruch = null;
        int zaehler, nenner = 0;
        String operator = "";
     
        while(sf.hasNextInt()){
            zaehler = sf.nextInt();
            nenner = sf.nextInt();
            operator = sf.next();
         
            bruch = new Rational[]{new Rational(zaehler, nenner)};         
        }
     
        for(int i = 0; i < bruch.length; i++){
         
            switch (operator){
            case "+":  System.out.println(bruch[i].add(bruch[i+1]));
                       break;
            case "-":  System.out.println(bruch[i].add(bruch[i+1]));
                          break;     
            case "*":  System.out.println(bruch[i].add(bruch[i+1]));
                             break;
            case "/":  System.out.println(bruch[i].add(bruch[i+1]));
                             break; 
               default:    System.out.println("Es sind nur +|-|*|/ als Operatoren erlaubt!");
        }

 

[Javinner]

@Loveprogramming
Für den Fall, dass du die Klasse nicht verändern darfst:

boolean istRechnungsende = false;
while(!istRechnungsende)
{
    //Dein Code
    //Wenn Programmende gewuenscht:
    istRechnungsende = true;
}

Wenn doch, dann nimm die while-Schleife und führe die Abfrage am Ende durch:
Ja, weitere Eingabe, Nein Programmende

 

[Loveprogramming]

@Loveprogramming
Für den Fall, dass du die Klasse nicht verändern darfst:

boolean istRechnungsende = false;
while(!istRechnungsende)
{
    //Dein Code
    //Wenn Programmende gewuenscht:
    istRechnungsende = true;
}

Wenn doch, dann nimm die while-Schleife und führe die Abfrage am Ende durch:
Ja, weitere Eingabe, Nein Programmende

Hab es jetzt etwas erweitert aber es funktioniert immer noch nicht richtig. Die Idee dabei ist, dass wenn ein Punk (.) eingegeben wird, wird das ganze abgebrochen und ausgegeben, ansonsten geht es weiter. Code:

Scanner sf = new Scanner(System.in);
        Rational[] bruch = null;
        int zaehler, nenner = 0;
        String operator = "";

        while(sf.hasNextInt()){
                   
            if(sf.next().equals(".")){
                for(int i = 0; i < bruch.length; i++){
                    switch (operator){
                        case "+":  System.out.println(bruch[i].add(bruch[i+1]).toString());
                                   break;
                        case "-":  System.out.println(bruch[i].add(bruch[i+1]).toString());
                                      break;       
                        case "*":  System.out.println(bruch[i].add(bruch[i+1]).toString());
                                         break;
                        case "/":  System.out.println(bruch[i].add(bruch[i+1]).toString());
                                         break;   
                        default:    System.out.println("Es sind nur +|-|*|/ als Operatoren erlaubt!");
                        }//Switch
                    }//For
            }
            else{

                zaehler = sf.nextInt();
                nenner = sf.nextInt();
                operator = sf.next();
               
                bruch = new Rational[]{new Rational(zaehler, nenner)};   
            }
           
        }//While

Bekomme eine Fehlermeldung:

Exception in thread "main" java.util.InputMismatchException
    at java.util.Scanner.throwFor(Unknown Source)
    at java.util.Scanner.next(Unknown Source)
    at java.util.Scanner.nextInt(Unknown Source)
    at java.util.Scanner.nextInt(Unknown Source)
    at RationalTest.main(RationalTest.java:46)

 

[truesoul]

Hallo.

Die Exception tritt auf weil du kein Zahl eingegeben hast sondern ein Zeichen. Das geht natürlich nicht.

Grüße

 

[Javinner]

public class Loveprogramming
{

    public static void main(String[] args)
    {
        String input = "";
        /**
         * Erste Handlung: erster Bruch
         */
        Bruch bruch = new Bruch(1, 2);

        /**
         * Solange die Bedingung nicht eintrifft, fuehre fort
         */
        while (!bruch.istEnde(input)) {
            /**
             * Erzeuge neuen Bruch
             */
            Bruch b = bruch.getNeuerBruch();
            /**
             * Abfrage Operator Dabei ist es auch wichtig, eine Falscheingabe
             * abzufangen und richtig darauf zu reagieren, jedenfalls was einem
             * dabei Richtig erscheinen mag.
             */
            input = bruch.getOperator();
            /**
             * Fange Abfrage Hier begrenzte ich es auf die Addition, wobei
             * anzumerken ist, dass ich die Mehtode nicht komplet
             * ausprogrammiert habe, sprich, der Bruch wird nicht gekuerzt. Dies
             * fuehrt natuerlich zu grossen Zahlen. Da muss man auf jeden noch
             * eine oder andere Zeile Code schreiben.
             */
            switch (input) {
                case "+":
                    bruch.add(b);
                    break;
                default:
                    System.out.println("Falsche Eingabe");
            }
            /**
             * Aktueller Bruchwert + Info zu der Anzahl aller Brueche der
             * Rechnung
             */
            System.out.println("Aktueller Stand ".concat(bruch.toString() + ", Anzahl bisheriger Brüche: " + Bruch.anzahlBrueche));
            /**
             * Abfrage Gabelung: Weiter oder Ende
             */
            input = bruch.gabelung();
        }
        /**
         * Endergebnis Bruchwert + Info zur Anzahl aller Brueche der Rechnung
         */
        System.out.println("Endlage: ".concat(bruch.toString() + ", Anzahl aller Brüche der Rechnung: " + Bruch.anzahlBrueche));
    }
}

/** Konsolenausgabe */
Eingabe Zaehler
1
Eingabe Nenner
15
Eingabe Operation
+
Aktueller Stand 17/30, Anzahl bisheriger Brüche: 2
**********************Weiteres Vorgehen
Rechnungsende: e
Nächste Operation: n
n
Eingabe Zaehler
1
Eingabe Nenner
8
Eingabe Operation
++                        /** <<< Falsche Eingabe */
Falsche Eingabe: Operator
+
Aktueller Stand 166/240, Anzahl bisheriger Brüche: 3
**********************Weiteres Vorgehen
Rechnungsende: e
Nächste Operation: n
n
Eingabe Zaehler
1
Eingabe Nenner
2
Eingabe Operation
+
Aktueller Stand 572/480, Anzahl bisheriger Brüche: 4
**********************Weiteres Vorgehen
Rechnungsende: e
Nächste Operation: n
e
Endlage: 572/480, Anzahl aller Brüche der Rechnung: 4

 

[Loveprogramming]

Mich würde es wirklich interessieren, was die folgenden Methoden beinhalten:

bruch.istEnde(input)
Bruch b = bruch.getNeuerBruch();
bruch.getOperator();
bruch.gabelung();
Bruch.anzahlBrueche

Außerdem ist die Aufgabe laut Aufgabenstellung immer noch nicht richtig. Die Eingabe darf nicht so wie oben aussehen:

Eingabe Zaehler
1
Eingabe Nenner
15
Eingabe Operation
+
Aktueller Stand 17/30, Anzahl bisheriger Brüche: 2

Sondern:

Eingabe Zaehler     Eingabe Nenner
      1                   15
Eingabe Operation
+

Zaehler und Nenner müssen in der selben Reihe geschrieben werden laut der EBNF Beschreibung.

 

[Loveprogramming]

Hallo.

Die Exception tritt auf weil du kein Zahl eingegeben hast sondern ein Zeichen. Das geht natürlich nicht.

Grüße

Wie kann ich denn ansonsten zwei Zahlen in einer Reihe eingeben und diese als zwei verschiedene Werte speichern?

zaehler = sf.nextInt(); --> Soll den ersten eingegebenen Zahl darstellen z.B 1
nenner = sf.nextInt(); --> Soll den zweiten Zahl darstellen z.B 2  --> Exception
operator = sf.next();   --> Eingabe von Operator

Ich gebe
1 2
+
ein

Nun weiß ich zumindest warum ich eine Fehlermeldung bekomme:

zaehler = sf.nextInt(); --> beinhaltet 1 2
nenner = sf.nextInt(); --> Operator --> break/Exception

Wie kann ich das denn wie oben beschrieben darstellen? Ich brauche zwei Zahlen die in einer Zeile geschrieben werden. Es sind aber zwei verschiedene Zahlen und sollten auch in zwei verschiedene Variablen gespeichert werden.

 

[Javinner]

bruch.istEnde(input)

Testet, ob die Abbruchbedingung erfühlt ist. In diesem Fall wird String input mit dem String abbruchbedingung verglichen und bei einer Übereinstimmung wird das Programm beendet.

Bruch b = bruch.getNeuerBruch();

Ich habe die Erschaffung eines neuen Bruches in die Klasse Bruch ausgelagert.

Eingabe Zaehler
1
Eingabe Nenner
2

Dann wird der Erstellte Bruch dem Bruch b zugewiesen und..

bruch.getOperator();

Eingabe Operation
+

... anhand einer ebenso in die Klasse Bruch ausgelagerten Methode getOperator() mit dem aktuellen Bruch bruch verrechnet.

bruch.gabelung();

**********************Weiteres Vorgehen
Rechnungsende: e
Nächste Operation: n

Was soll nun geschehen?

Bruch.anzahlBrueche

Variable anzahlBrueche ist eine statische Variable der Klasse Bruch, welche zu den Zweck ins Leben gerufen wurde, die Anzahl aller Brüche der aktuellen Rechnung zu zählen. Rein informativ.
Die Tatsache, dass du danach fragst, verleitet mich dazu, dir nahezulegen, die Grundlagen der imperativen und objektorientierten Programmierung zu verinnerlichen, bevor du weiter machst.
Ist in deinem Sinn!

Ich komme aus einem Grund nicht mit dem Code raus:
- es bringt dich nicht weiter, weil eben der besagte Code nun wirklich kein Beinbruch ist und ich dich nicht des Gefühls berauben möchte, die Aufgabe von sich selbst gemeistert zu haben.

 

[mrBrown]

Ich habe die Erschaffung eines neuen Bruches in die Klasse Bruch ausgelagert.

... anhand einer ebenso in die Klasse Bruch ausgelagerten Methode getOperator() mit dem aktuellen Bruch bruch verrechnet.

Die beiden wären aber außerhalb der Bruch-Klasse besser aufgehoben

Wie kann ich denn ansonsten zwei Zahlen in einer Reihe eingeben und diese als zwei verschiedene Werte speichern?

scanner.nextInt gibt dir den ersten int zurück.
Nochmal scanner.nextInt gibt dir den zweiten int zurück.
Danach ein scanner.nextLine, damit der Zeichenumbruch gelesen wird und nicht stört.

 

[Javinner]

Ich habe mal vor kurzen wo ein Codeprogramm gelesen und es hat mir, was die Übersichtlichkeit anbetrifft, sehr gefallen. Was mir gefiel war die Tatsache, dass beinahe alles in Klassen realisiert wurde, so dass der Code sich sehr geschmeidig lesen lies und logisch und durchdacht aussah. Man hat keine Kommentare oder Anmerkungen gebraucht, um verstehen zu können, was der Code macht.

Zudem kommt etwas, was ich nicht nachvollziehen kann:
Codestück A:

Spoiler: Realisiert in der Klasse

public class Loveprogramming
{

    public static void main(String[] args)
    {
        String input = "";
        /**
         * Erste Handlung: erster Bruch
         */
        Bruch bruch = new Bruch(1, 2);

        /**
         * Solange die Bedingung nicht eintrifft, fuehre fort
         */
        while (!bruch.istEnde(input)) {
            /**
             * Erzeuge neuen Bruch
             */
            Bruch b = bruch.getNeuerBruch();
            /**
             * Abfrage Operator Dabei ist es auch wichtig, eine Falscheingabe
             * abzufangen und richtig darauf zu reagieren, jedenfalls was einem
             * dabei Richtig erscheinen mag.
             */
            input = bruch.getOperator();
            /**
             * Fange Abfrage Hier begrenzte ich es auf die Addition, wobei
             * anzumerken ist, dass ich die Mehtode nicht komplet
             * ausprogrammiert habe, sprich, der Bruch wird nicht gekuerzt. Dies
             * fuehrt natuerlich zu grossen Zahlen. Da muss man auf jeden noch
             * eine oder andere Zeile Code schreiben.
             */
            switch (input) {
                case "+":
                    bruch.add(b);
                    break;
                default:
                    System.out.println("Falsche Eingabe");
            }
            /**
             * Aktueller Bruchwert + Info zu der Anzahl aller Brueche der
             * Rechnung
             */
            System.out.println("Aktueller Stand ".concat(bruch.toString() + ", Anzahl bisheriger Brüche: " + Bruch.anzahlBrueche));
            /**
             * Abfrage Gabelung: Weiter oder Ende
             */
            input = bruch.gabelung();
        }
        /**
         * Endergebnis Bruchwert + Info zur Anzahl aller Brueche der Rechnung
         */
        System.out.println("Endlage: ".concat(bruch.toString() + ", Anzahl aller Brüche der Rechnung: " + Bruch.anzahlBrueche));
    }
}

/** Konsolenausgabe */
Eingabe Zaehler
1
Eingabe Nenner
15
Eingabe Operation
+
Aktueller Stand 17/30, Anzahl bisheriger Brüche: 2
**********************Weiteres Vorgehen
Rechnungsende: e
Nächste Operation: n
n
Eingabe Zaehler
1
Eingabe Nenner
8
Eingabe Operation
++                        /** <<< Falsche Eingabe */
Falsche Eingabe: Operator
+
Aktueller Stand 166/240, Anzahl bisheriger Brüche: 3
**********************Weiteres Vorgehen
Rechnungsende: e
Nächste Operation: n
n
Eingabe Zaehler
1
Eingabe Nenner
2
Eingabe Operation
+
Aktueller Stand 572/480, Anzahl bisheriger Brüche: 4
**********************Weiteres Vorgehen
Rechnungsende: e
Nächste Operation: n
e
Endlage: 572/480, Anzahl aller Brüche der Rechnung: 4

Codestück B:

Spoiler: Realisiert in Main

public class Loveprogramming
{

    public static void main(String[] args)
    {
        Scanner scanner = new Scanner(System.in);
        String input = "";
        Bruch bruch = new Bruch(1, 2);

        while (!bruch.istEnde(input)) {
            System.out.println("Eingabe Zähler");
            int zaehler = scanner.nextInt();
            System.out.println("Eingabe Nenner");
            int nenner = scanner.nextInt();
            Bruch b = new Bruch(zaehler, nenner);
            System.out.println("Eingabe Operator");
            input = scanner.nextLine();
          
          
            switch (input) {
                case "+":
                    bruch.add(b);
                    break;
                default:
                    System.out.println("Falsche Eingabe");
            }
          
            System.out.println("Aktueller Stand ".concat(bruch.toString() + ", Anzahl bisheriger Brüche: " + Bruch.anzahlBrueche));
          
            input = bruch.gabelung();
        }
      
        System.out.println("Endlage: ".concat(bruch.toString() + ", Anzahl aller Brüche der Rechnung: " + Bruch.anzahlBrueche));
    }
}
/** Konsolenausgabe */
Eingabe Zähler
1
Eingabe Nenner
2
Eingabe Operator
Falsche Eingabe
Aktueller Stand 1/2, Anzahl bisheriger Brüche: 2
**********************Weiteres Vorgehen
Rechnungsende: e
Nächste Operation: n

In Codestück B wird die Eingabe des Operators übersprungen.
Warum es so ist, leuchtet mir nicht ein. Eventuell kannst du mir die Machete für mein intellektuelles Dickicht leihen

 

[mrBrown]

In Codestück B wird die Eingabe des Operators übersprungen.
Warum es so ist, leuchtet mir nicht ein. Eventuell kannst du mir die Machete für mein intellektuelles Dickicht leihen

Nach nextInt() enthält die Zeile noch den Zeilenumbruch, der dann it nextLine gelesen wird, der Operator würde erst bei dem nächsten nextLine einlesen werden.

Ich habe mal vor kurzen wo ein Codeprogramm gelesen und es hat mir, was die Übersichtlichkeit anbetrifft, sehr gefallen. Was mir gefiel war die Tatsache, dass beinahe alles in Klassen realisiert wurde, so dass der Code sich sehr geschmeidig lesen lies und logisch und durchdacht aussah. Man hat keine Kommentare oder Anmerkungen gebraucht, um verstehen zu können, was der Code macht.

Lesbaren Code bekommt man auch hin, wenn man die Eingabe nicht zwanghaft in der Bruch-Klasse unterbringt

Es gibt absolut keinen logischen und durchdachten Grund, warum ein Bruch wissen soll, wie ein anderer, neuer Bruch einzulesen lesen ist.
Es wird deutlich lesbarer und übersichtlicher, wenn der Bruch das macht, was ein Bruch eben macht (eben einen Bruch darstellen und Rechenoperationen für diesen anbieten), und eine Klasse für die Eingabe kümmert sich um die Eingabe.
Genau das gleiche für Operatoren - warum sollte ein Bruch die Operatoren einlesen? Liest der die dann auch für komplexe Zahlen ein? Oder haben komplexe Zahlen die gleiche Methode?

 

[Loveprogramming]

Erstmal vielen dank für die tolle und informative Tipps. Dank eure Hilfe bin ich schon sehr weit gekommen aber ich habe halt das Problem, die ganzen Tipps umzusetzen. Zwar habe ich jetzt verstanden warum ich die Fehlermeldung bekomme und was ich ändern muss aber, ich kann es nicht in meinem Code umsetzen. Ich habe die eigentliche Aufgabe schon hinter mir (Die Rational Klasse). Nun muss ich das ganze nur noch ausgeben.

while(Eine weitere Zahl){
      if(Überprüfen ob ein PUNKT(.) eingegeben worden ist){
           Wenn ja: Rechenoperationen und dann break
      }else{
            Ansonsten weitere eingaben
            zaehler = sf.nextInt();
            nenner = sf.nextInt();   --> Exception
            operator = sf.nextLine();
      }
}

Ich sitze jetzt schon seit drei Tagen daran. Tut mir leid wenn ich euch damit nerve aber ich bin halt so, dass ich nicht direkt alles verstehen kann, obwohl mir man es erklärt. Die Code Snippets von @Javinner haben mir beispielsweise sehr geholfen und damit verstehe ich es auch besser.

 

[Javinner]

Nach nextInt() enthält die Zeile noch den Zeilenumbruch, der dann it nextLine gelesen wird, der Operator würde erst bei dem nächsten nextLine einlesen werden

Da komm ich irgendwie nicht dahinter. Auch nach einem Test nicht:

Scanner scanner = new Scanner(System.in);
System.out.println("Integer A");
int a = scanner.nextInt();
System.out.println("Integer B");
int b = scanner.nextInt();
System.out.println("A: " + a + ", B: " + b);
/** Konsolenausgabe */
Integer A
4
Integer B
5
A: 4, B: 5

Scanner scanner = new Scanner(System.in);
System.out.println("Integer A");
int a = scanner.nextInt();
System.out.println("String B");
String b = scanner.nextLine();
System.out.println("A: " + a + ", B: ".concat(b));
/** Konsolenausgabe */
Integer A
5
String B /** Wird uebersprungen */
A: 5, B:

Auch das Einfügen leerer Zeilen mit System.out.println(); brachte mich nicht weiter.

Die Code Snippets von @Javinner haben mir beispielsweise sehr geholfen und damit verstehe ich es auch besser.

Das liegt daran, dass ich selbst ein Anfänger bin und noch weiß, wie man als Anfänger denkt und handelt. Auch mache ich hier und da eine Entdeckung über längst gelesenes, so dass der Wissensstand zu manch einem Thema noch lange nicht komplett ist, wie gerade eben mit dem Einlesen

 

[Loveprogramming]

Nun habe ich es etwas erweitert und es klappt nicht so richtig. Wenigstens sind die Fehlermeldungen beseitigt worden:

public static void main(String[] args) {
       
        Scanner sf = new Scanner(System.in);
        int zaehler = 0;
        int nenner = 0;
        String operator = "";
       
        while(sf.hasNextInt()){
           
            String z = Integer.toString(zaehler);
            String n = Integer.toString(nenner);
           
            if(z.equals(".") || n.equals(".") || operator.equals(".")){
                break;
            }else{
               
                int zI = Integer.parseInt(z);
                int nI = Integer.parseInt(n);
               
                zI = sf.nextInt();
                nI = sf.nextInt();
                operator = sf.next();
            }
                       
        }
       
        sf.close();
    }

Output:

1 2
+
3 4
-
2 1
.  --> Nach einer Eingabe von Punkt sollte das Programm direkt abgebrochen werden.
1 --> Ich muss danach noch irgendetwas tippen, damit es abgebrochen wird.

 

[Javinner]

Tut mir leid wenn ich euch damit nerve aber ich bin halt so, dass ich nicht direkt alles verstehen kann, obwohl mir man es erklärt

Lieber Freund, Morgen bist du hier zwei Jahre Mitglied. Ohne dir nahe treten zu wollen, solltest du mir erklären können/sollen, wie dies und das funktioniert Ich denke, ohne ein bestimmten Grad an Verbissenheit und Interesse wird man nicht weit kommen.

 

[Javinner]

@Loveprogramming
Da ich in festlicher Stimmung bin und Weihnachten anstehen:
Frohe Weihnachten, alles Gute!

Spoiler: Klasse Bruch

class Bruch
{

    static int anzahlBrueche = 0;
    private int zaehler;
    private int nenner;
    private final String add = "+";
    private final String equal = "=";

    Bruch(int zaehler, int nenner)
    {
        this.zaehler = zaehler;
        this.nenner = nenner;
        anzahlBrueche++;
    }

    protected void add(Bruch bruch)
    {
        int z = (this.zaehler * bruch.nenner) + (bruch.zaehler * this.nenner);
        int n = this.nenner * bruch.nenner;
        this.zaehler = z;
        this.nenner = n;
    }

    protected boolean istEnde(String string)
    {
        return string.equals(equal);
    }

    protected boolean addition(String string)
    {
        return string.equals(add);
    }

    protected Bruch getNeuerBruch()
    {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Eingabe Zähler");
        int z = scanner.nextInt();
        System.out.println("Eingabe Nenner");
        int n = scanner.nextInt();
        Bruch b = new Bruch(z, n);
        return b;
    }

    protected String getOperator()
    {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Eingabe Operation");
        String s = scanner.nextLine();
        if (s.length() >= 2) {
            while (s.length() >= 2) {
                System.out.println("Falsche Eingabe: Operator");
                s = scanner.nextLine();
            }
        }
        return s;
    }

    protected String gabelung()
    {
        String input;
        input = "**********************Weiteres Vorgehen";
        input += "\nRechnungsende: e";
        input += "\nNächste Operation: n";
        System.out.println(input);
        Scanner scanner = new Scanner(System.in);
        input = scanner.nextLine();
        switch (input) {
            case "e":
                input = "=";
                break;
            case "n":
                input = "";
                break;
            default:
                System.out.println("Falsche Eingabe: Gabelung");
                input = "";

        }
        return input;
    }

    @Override
    public String toString()
    {
        StringBuilder sb = new StringBuilder();
        sb.append(Integer.toString(this.zaehler));
        sb.append("/");
        sb.append(Integer.toString(this.nenner));
        return sb.toString();
    }

}

 

[Loveprogramming]

Lieber Freund, Morgen bist du hier zwei Jahre Mitglied. Ohne dir nahe treten zu wollen, solltest du mir erklären können/sollen, wie dies und das funktioniert Ich denke, ohne ein bestimmten Grad an Verbissenheit und Interesse wird man nicht weit kommen.

Nein, zwar ist es zwei Jahre her aber ich habe mich damals registriert um eine Frage zu stellen. Danach habe ich nicht mehr programmiert. Nun habe ich wieder angefangen. Vielen dank für deinen Code ist echt super von dir. Ich werde es aber nicht benutzen. Die mathematische Methoden und die Klasse ist schon fertig programmiert. Das ganze muss ich laut der Eingabesyntax noch ausgeben. Die Aufgabenstellung kennt Ihr ja schon bereits. Auch wenn ich deine Lösung nehmen würde, wäre die Ausgabe laut der Aufgabenstellung falsch.

Dennoch vielen dank!

 

[mrBrown]

Da komm ich irgendwie nicht dahinter. Auch nach einem Test nicht:
Auch das Einfügen leerer Zeilen mit System.out.println(); brachte mich nicht weiter.

Dabei machst du ja auch was völlig anderes als in dem Beispiel vorher...

In deinem zweiten Codestück liest du mit nextLine den Zeilenumbruch ein, ergo "siehst" du b nicht.
Würdest du den Zeilenumbruch erst mit nextLine lesen, und dann direkt noch mal mit nextLine das eingegeben Lesen, würdest du es auch sehen

Nun habe ich es etwas erweitert und es klappt nicht so richtig. Wenigstens sind die Fehlermeldungen beseitigt worden:

Guck dir doch mal an was du da machst:

du initialisierst zaehler mit 0.
Dann formatierst du Zähler als String, den du direkt danach wieder in eine Zahl umwandelst (was dann die 0 ist, die du weiter oben zugewiesen hast) und zI zuweist.
Direkt danach weist du zI einen neuen Wert von der Kommandozeile zu, den du dann einfach ignorierst.

Versuch doch erstmal nur, einen einzelnen Bruch einzulesen (so wie in #29 beschrieben), und wenn du das geschafft hast, machst du den Rest.