# Bruchrechner stürzt bei eingabe negativer Zahlen ab



## Cayton (29. Jan 2013)

Hallo liebes Forum! 

Ich lerne derzeit im Informatikunterricht in der 11. Klasse wie man mit Java Programme schreibt. Dazu verwenden wir die SuM Bibliotheken und BlueJ als IDE. 

Derzeit programmiere ich einen einfachen Bruchrechner. Er ist auch quasi fertig, nur kommt er nicht mit negativen Zahlen zurecht. Gebe ich im Zähler oder Nenner eines Bruches eine Negative Zahl ein und drücke einen der Buttons (siehe Screenshot), freezed die Programmoberfläche und ich kann nichts tun, ausser den Java-Prozess zu beenden.

Wo könnte nun der Fehler liegen? Der Sourcecode sowie eine ausführbare Version hänge ich an meinen Beitrag an. Die Archive enthalten jeweils die *.jar-Dateien die benötigt werden, sowie ein Startscript für das jeweilige Betriebssystem.

OS: Linux Mint 13
Compiler: Der originale von Oracle (Java SDK 1.7.0_11)
IDE: BlueJ

Vielen Dank für die Hilfe!


~Cayton




P.S.: Es handelt sich nicht um eine Hausaufgabe, sondern um ein eigenständiges Projekt, weil der Unterricht einfach nur derbe langweilig ist.

Screenshot:








Sourcecode:

SuMProgramm


```
public class SuMProgramm
{
    public static void main(String args[])
    {
        GUI hatSuMAnwendung = new GUI();
        hatSuMAnwendung.fuehreAus();
    }
}
```


GUI


```
/**
 * @author Fabian Kinzer
 * @version 0.1a
 */
import sum.komponenten.*;
import sum.werkzeuge.*;
import sum.ereignis.*;

public class GUI extends EBAnwendung
{
    private Knopf hatKnopfBeenden;
    private Textfeld hatZaehlerBruch1;
    private Textfeld hatNennerBruch1;
    private Etikett hatEtikettBruchstrich1;
    private Textfeld hatZaehlerBruch2;
    private Textfeld hatNennerBruch2;
    private Etikett hatEtikettBruchstrich2;
    private Knopf hatKnopfPlus;
    private Knopf hatKnopfMinus;
    private Knopf hatKnopfMal;
    private Knopf hatKnopfGeteilt;
    private Bruch bruch1;
    private Bruch bruch2;
    private Rechner hatRechner;
    private Etikett hatEtikettBruchstrichErgebnis;
    private Etikett hatEtikettGleich;
    private Etikett hatEtikettZaehlerErgebnis;
    private Etikett hatEtikettNennerErgebnis;
    private Bruch ergebnis;
    private Etikett hatEtikettFehlermeldung;
    // Globale Variablen

    private char operator;
    public GUI()
    {
        //Initialisierung der Oberklasse
        super(600, 250); 

        hatKnopfBeenden = new Knopf(25, 225, 100, 25, "Beenden");
        hatKnopfBeenden.setzeBearbeiterGeklickt("hatKnopfBeendenGeklickt");
        
        hatZaehlerBruch1 = new Textfeld(25, 26, 100, 25, "");
        hatZaehlerBruch1.setzeAusrichtung(Ausrichtung.LINKS);
        // 
        hatNennerBruch1 = new Textfeld(25, 96, 100, 25, "");
        hatNennerBruch1.setzeAusrichtung(Ausrichtung.LINKS);
        //
        hatEtikettBruchstrich1 = new Etikett(25, 61, 100, 25, "-------------------");
        hatEtikettBruchstrich1.setzeAusrichtung(Ausrichtung.MITTE);
        //
        hatZaehlerBruch2 = new Textfeld(225, 26, 100, 25, "");        
        hatZaehlerBruch2.setzeAusrichtung(Ausrichtung.LINKS);
        //
        hatNennerBruch2 = new Textfeld(225, 96, 100, 25, "");
        hatNennerBruch2.setzeAusrichtung(Ausrichtung.LINKS);
        //
        hatEtikettBruchstrich2 = new Etikett(225, 61, 100, 25, "-------------------");
        hatEtikettBruchstrich2.setzeAusrichtung(Ausrichtung.MITTE);
        // Es sind doch Deklarationen einzufügen
        hatEtikettGleich = new Etikett(350, 63, 25, 25, "=");
        hatEtikettGleich.setzeAusrichtung(Ausrichtung.MITTE);
        //
        hatEtikettBruchstrichErgebnis = new Etikett(375, 63, 100, 25, "-------------------");
        hatEtikettBruchstrichErgebnis.setzeAusrichtung(Ausrichtung.MITTE);
        //
        hatEtikettZaehlerErgebnis = new Etikett(375, 26, 100, 25, 0);
        hatEtikettZaehlerErgebnis.setzeAusrichtung(Ausrichtung.MITTE);
        //
        hatEtikettNennerErgebnis = new Etikett(375, 96, 100, 25, 0);
        hatEtikettNennerErgebnis.setzeAusrichtung(Ausrichtung.MITTE);
        //
        hatEtikettFehlermeldung = new Etikett(150, 225, 400, 25, "");
        hatEtikettFehlermeldung.setzeAusrichtung(Ausrichtung.MITTE);
        
        
        hatKnopfPlus = new Knopf(150, 12, 50, 25, "+");
        hatKnopfPlus.setzeBearbeiterGeklickt("hatKnopfPlusGeklickt");
        hatKnopfMinus = new Knopf(150, 47, 50, 25, "-");
        hatKnopfMinus.setzeBearbeiterGeklickt("hatKnopfMinusGeklickt");
        hatKnopfMal = new Knopf(150, 82, 50, 25, "*");
        hatKnopfMal.setzeBearbeiterGeklickt("hatKnopfMalGeklickt");
        hatKnopfGeteilt = new Knopf(150, 117, 50, 25, "/");
        hatKnopfGeteilt.setzeBearbeiterGeklickt("hatKnopfGeteiltGeklickt");
        
        hatRechner = new Rechner();
        
    }
    public void hatKnopfBeendenGeklickt()
    {
        System.exit(0);
    }
    public void hatKnopfPlusGeklickt()
    {
        hatEtikettFehlermeldung.setzeInhalt("");
        if (this.erzeugeBrueche())
        {
            operator = '+';
            ergebnis = this.berechne();
            this.zeigeErgebnisAn();

        }
    }
    public void hatKnopfMinusGeklickt()
    {
        hatEtikettFehlermeldung.setzeInhalt("");
        if (this.erzeugeBrueche())
        {
            operator = '-';
            ergebnis = this.berechne();
            this.zeigeErgebnisAn();
        }
    }
    public void hatKnopfMalGeklickt()
    {
        hatEtikettFehlermeldung.setzeInhalt("");
        if (this.erzeugeBrueche())
        {
            operator = '*';
            ergebnis = this.berechne();
            this.zeigeErgebnisAn();
        }
    }
    public void hatKnopfGeteiltGeklickt()
    {
        hatEtikettFehlermeldung.setzeInhalt("");
        if (this.erzeugeBrueche())
        {
            operator = '/';
            ergebnis = this.berechne();
            this.zeigeErgebnisAn();
        }
    }
    private boolean erzeugeBrueche()
    {
        if(hatNennerBruch1.inhaltAlsLangeGanzeZahl() != 0 && hatNennerBruch2.inhaltAlsLangeGanzeZahl() != 0 && hatNennerBruch1.inhaltAlsLangeGanzeZahl() > 0 && hatNennerBruch2.inhaltAlsLangeGanzeZahl() > 0)
        {
            try
            {
                bruch1 = new Bruch(hatZaehlerBruch1.inhaltAlsLangeGanzeZahl(), hatNennerBruch1.inhaltAlsLangeGanzeZahl());
            }
            catch(ArithmeticException e)
            {
                hatEtikettFehlermeldung.setzeInhalt("Es dürfen nur ganze Zahlen eingegeben werden!");
                return false;
            }
            try
            {
                bruch2 = new Bruch(hatZaehlerBruch2.inhaltAlsLangeGanzeZahl(), hatNennerBruch2.inhaltAlsLangeGanzeZahl());
            }
            catch(ArithmeticException e)
            {
                hatEtikettFehlermeldung.setzeInhalt("Es dürfen nur ganze Zahlen eingegeben werden!");
                this.stop();
                return false;
            }
            return true;
        }
        else
        {
            hatEtikettFehlermeldung.setzeInhalt("Kein Nenner darf 0 oder negativ sein!");
            return false;
        }
        
        
    }
    private void zeigeErgebnisAn()
    {
        if(ergebnis.getZaehler() == 0)
        {
            hatEtikettZaehlerErgebnis.setzeInhalt(0);
            hatEtikettNennerErgebnis.setzeInhalt(0);
        }
        else
        {
            hatEtikettZaehlerErgebnis.setzeInhalt(ergebnis.getZaehler());
            hatEtikettNennerErgebnis.setzeInhalt(ergebnis.getNenner());
        }
    }
    private Bruch berechne()
    {
        if(operator == '+')
        {
            return hatRechner.addiere(bruch1, bruch2);
        }
        else if(operator == '-')
        {
            return hatRechner.subtrahiere(bruch1, bruch2);
        }
        else if(operator == '*')
        {
            return hatRechner.multipliziere(bruch1, bruch2);
        }
        else if(operator == '/')
        {
            return hatRechner.dividiere(bruch1, bruch2);
        }
        else
        {
            return new Bruch(0,0);
        }
    }
    private void stop()
    {}
}
```


Bruch


```
/**
 * @author Fabian Kinzer
 * @version 0.1a
 */
public class Bruch
{
    long zaehler;
    long nenner;
    public Bruch(long pZaehler, long pNenner)
    {
        zaehler = pZaehler;
        nenner = pNenner;
    }
    public void kuerze()
    {
        if(zaehler != 0 && nenner != 0)
        {
           long ggt = this.ggt();
            zaehler = zaehler/ggt;
            nenner = nenner/ggt;
        }
    }
    public long getZaehler()
    {
        return zaehler;
    }
    public long getNenner()
    {
        return nenner;
    }
    public long ggt() // Quelle: [url=http://www.qslnet.de/member/dg1xpz/programm/java/euklid.html]DG1XPZ - JAVA-Programmierung, Der Euklidische Algorithmus[/url] | Auf meine Zwecke angepasst | Euklidischer Algorhithmus zur Ermittlung des gGT
    {
        long m = zaehler;
        long n = nenner;
        long r; 

            do 
            {
            if (m<n) 
            {
                r=m; m=n; n=r;
            }
            r = m % n;
            if (r!=0) 
            {
                m=n; n=r;
            }
        } while ( r!=0 );
        return n;
    }
}
```
[/spoiler]

Rechner:


```
/**
 * @author Fabian Kinzer
 * @version 0.1a
 */
public class Rechner
{
    long ergebnisZaehler;
    long ergebnisNenner;
    Bruch ergebnisBruch;
    public Rechner()
    {

    }
        public Bruch addiere(Bruch pBruch1, Bruch pBruch2)
    {
        if(pBruch1.getNenner() == pBruch2.getNenner())
        {
            ergebnisZaehler = pBruch1.getZaehler() + pBruch2.getZaehler();
            ergebnisBruch = new Bruch(ergebnisZaehler, pBruch1.getNenner());
            ergebnisBruch.kuerze();
        }
        else
        {
            ergebnisNenner = pBruch1.getNenner() * pBruch2.getNenner();
            ergebnisZaehler = pBruch2.getNenner() * pBruch1.getZaehler() + pBruch1.getNenner() * pBruch2.getZaehler();
            ergebnisBruch = new Bruch(ergebnisZaehler, ergebnisNenner);
            ergebnisBruch.kuerze();
        }
        return ergebnisBruch;
    }
    public Bruch subtrahiere(Bruch pBruch1, Bruch pBruch2)
    {
        if(pBruch1.getNenner() == pBruch2.getNenner())
        {
            ergebnisZaehler = pBruch1.getZaehler() - pBruch2.getZaehler();
            ergebnisBruch = new Bruch(ergebnisZaehler, pBruch1.getNenner());
            ergebnisBruch.kuerze();
        }
        else
        {
            ergebnisNenner = pBruch1.getNenner() * pBruch2.getNenner();
            ergebnisZaehler = pBruch2.getNenner() * pBruch1.getZaehler() - pBruch1.getNenner() * pBruch2.getZaehler();
            ergebnisBruch = new Bruch(ergebnisZaehler, ergebnisNenner);
            ergebnisBruch.kuerze();

        }
        return ergebnisBruch;
    } 
    public Bruch multipliziere(Bruch pBruch1, Bruch pBruch2)
    {
        ergebnisZaehler = pBruch1.getZaehler() * pBruch2.getZaehler();
        ergebnisNenner = pBruch1.getNenner() * pBruch2.getNenner();
        ergebnisBruch = new Bruch(ergebnisZaehler, ergebnisNenner);
        ergebnisBruch.kuerze();
        
        return ergebnisBruch;
    }
    public Bruch dividiere(Bruch pBruch1, Bruch pBruch2)
    {
        ergebnisZaehler = pBruch1.getZaehler() * pBruch2.getNenner();
        ergebnisNenner = pBruch1.getNenner() * pBruch2.getZaehler();
        ergebnisBruch = new Bruch(ergebnisZaehler, ergebnisNenner);
        ergebnisBruch.kuerze();
        
        return ergebnisBruch;
    }
}
```


----------



## Runtime (29. Jan 2013)

Gibt es eine Fehlermeldung? So auf die schnelle sage ich mal, dass der Fehler evtl in der ggT-Methode liegt. Versuchs mal nur mit
den absoluten Werten.


----------



## timbeau (29. Jan 2013)

An ALLE, nicht auf Bluej rumhacken!
Cayton, lass das Programm mal in der Konsole laufen mit festen Werten. Da siehts du wo es hakt.


----------



## nillehammer (29. Jan 2013)

Ja, es ist die ggt-Methode. Ursache ist die Verwendung des Modulo-Operators mit negativen Zahlen. Dadurch wird die Abbruchbedingung der do-while-Schleife nicht true und sie läuft endlos. Baue ein paar System.out.printlns in die Schleife ein, um zu sehen, wo es genau hakt.


----------



## Cayton (29. Jan 2013)

Danke! Hab mir schon irgendwie gedacht, dass es da hängt. Jetzt muss ich nur noch ne Idee finden, wie ich den ggT auch bei negativen Zahlen ermitteln kann. 

Danke an alle, die geholfen haben 

(Und wegen BlueJ.... Hab mir heute die Erlaubnis geholt mit eclipse zu arbeiten.)

EDIT: Funktioniert jetzt. Lösung: Math.abs()


----------

