/**
 * Eine Klasse zur Darstellung von Brüchen.
 * Ein Bruch besteht aus ganzzahligen Zähler und Nenner.
 *
 * @author Holger Knublauch
 */
public class Bruch 
{
    /**
     * Speichert den aktuellen Nenner
     */
    private int nenner;
    
    /**
     * Speichert den aktuellen Zähler
     */
    private int zaehler;
    

    /**
     * Erzeugt einen neuen Bruch.
     * Dies ist ein Constructor, also eine Methode, die einen Bruch erzeugt.
     * Beispiel: Bruch b = new Bruch(42, 8);
     * @param anfangsZaehler der Anfangswert des Zählers
     * @param anfangsNenner der Anfangswert des Nenners
     */
    public Bruch (int anfangsZaehler, int anfangsNenner) 
    {
        nenner = anfangsNenner;
        zaehler = anfangsZaehler;
    }
    
    
    /**
     * Liefert den aktuellen Wert des Nenners.
     * @return den Nenner
     */
    public int getNenner()
    {
        return nenner;
    }
    
    
    /**
     * Liefert den aktuellen Wert des Zaehlers.
     * @return den Zaehler
     */
    public int getZaehler()
    {
        return zaehler;
    }

    
    /**
     * Multipliziert den Bruch mit einem angegebenen Bruch.
     * Es werden jeweils Zähler und Nenner multipliziert, aber nicht gekürzt.
     * @param b der andere Bruch
     */
    public void multipliziere (Bruch b)
    {
        nenner = nenner * b.getNenner();
        zaehler = zaehler * b.getZaehler();
    }
    
    
    /**
     * Kürzt den Bruch. Hierbei werden sowohl Zähler als auch Nenner durch
     * den größten gemeinsamen Teiler (ggT) dividiert.
     */
    public void kuerze()
    {
        int g = ggT(zaehler, nenner);
        zaehler = zaehler / g;
        nenner = nenner / g;
    }
    
    
    /**
     * Berechnet den größten gemeinsamen Teiler (ggT) von zwei Zahlen a und b.
     * Die Methode arbeitet rekursiv, d.h. sie ruft sich selbst auf.
     * Der ggT wird zum Beispiel beim Kürzen von Brüchen benötigt.
     * @param a die erste Zahl
     * @param b die zweite Zahl
     * @return den ggT von a und b
     */
    private int ggT(int a, int b)
    {
        if(b == 0)
        {
            return a;
        }
        else
        {
            return ggT (b, a % b);
        }
    }
    
    
    /**
     * Berechnet den Wert des Bruches als double-Zahl.
     * Dies ist einfach Zähler / Nenner.
     * @return den Bruch als double-Zahl
     */
    public double toDouble()
    {
        // Hier muss eine Typ-Umwandlung gemacht werden, damit die Division
        // nicht mit int-Zahlen sondern mit double-Zahlen rechnet
        return zaehler / (double) nenner;
    }
    
    
    /**
     * Liefert eine Textfassung der Bruchzahl.
     * @return einen String im Format "zaehler/nenner"
     */
    public String toString()
    {
        return "" + zaehler + "/" + nenner;
    }
}