Bruch

import java.math.BigInteger;

public class Bruch implements Comparable<Bruch> {
    // Mit dem Interface Comparable<Bruch> gibt man an,
    // dass der Bruch mit anderen Brüchen verglichen werden kann.
    // Z.B. für Sortieralgorithmen.

    private final int zaehler;  // Die Attribute kennzeichne ich sicherheitshalber mit "final" damit ich sie nicht versehentlich verändere.
    private final int nenner;   // Bei jeder Rechnung wird also ein neuer Bruch zurückgegeben

    public Bruch(int zaehler, int nenner) {
        // Konstruktor für einen echten Bruch (z.B. 7/6)
        this.zaehler = zaehler;
        this.nenner = nenner;
    }

    public Bruch(int ganze, int zaehler, int nenner) {
        // Konstruktor für einen gemischten Bruch (z.B. 1 1/6)
        this((ganze*nenner)+zaehler, nenner);
    }

    public Bruch(int ganze) {
        // Konstruktor für Ganzzahlen (z.B. 5/1)
        this(ganze, 1);
    }

    public Bruch erweitere(int faktor) {
        // sollte klar sein
        return new Bruch(this.zaehler*faktor, this.nenner*faktor);
    }

    public Bruch kuerze() { // hier mache ich es mir einfach, weil es in der Klasse BigInteger schon eine Funktion für den größten gemeinsamen Teiler gibt.
        int ggT = BigInteger.valueOf(this.zaehler).gcd(BigInteger.valueOf(this.nenner)).intValue(); // ggT berechnen
        return new Bruch(this.zaehler/ggT, this.nenner/ggT); // Zähler und Nenner durch ggT teilen
    }

    // Getter (da die Attribute final sind, gibt es keine Setter)

    public int getZaehler() {
        return zaehler;
    }

    public int getNenner() {
        return nenner;
    }


    // Grundrechenarten

    public Bruch addiere(Bruch summand) {
        // Zum addieren werden einfach beide Zähler mit dem Nenner des jeweils anderen Summanden erweitert und dann zusammenaddiert.
        // Die Nenner der beiden Summanden werden addiert und ergeben zusammen den Nenner des Ergebnisses. Am Ende wird die Zahl gekürzt.
        // (1/2) + (2/3) = (3/6) + (4/6) = (7/6)
        return new Bruch((this.zaehler*summand.nenner) + (summand.zaehler*this.nenner), this.nenner * summand.nenner).kuerze();
    }

    public Bruch addiere(int summand) {
        // Nicht zwingend nötig, aber bestimmt hilfreich, wenn man einen Bruch auch einfach mit einem int addieren kann
        return this.addiere(new Bruch(summand));
    }

    public Bruch subtrahiere(Bruch subtrahend) {
        // Das Gleiche wie bei der Addition, nur dass die erweiterten Zähler voneinander subtrahiert werden
        return new Bruch((this.zaehler*subtrahend.nenner) - (subtrahend.zaehler*this.nenner), this.nenner * subtrahend.nenner).kuerze();
    }

    public Bruch subtrahiere(int subtrahend) {
        // Hier auch nochmal als Subtraktion mit einem int.
        return this.subtrahiere(new Bruch(subtrahend));
    }

    public Bruch multipliziere(Bruch faktor) {
        // Die Multiplikation ist einfacher als die Addition. Einfach beide Zähler und beide Nenner multiplizieren und am Ende kürzen
        return new Bruch(this.zaehler * faktor.zaehler, this.nenner * faktor.nenner).kuerze();
    }

    public Bruch multipliziere(int faktor) {
        return this.multipliziere(new Bruch(faktor));
    }

    public Bruch dividiere(Bruch divisor) {
        // Das Gleiche wie bei der Multiplikation, nur dass Zähler und Nenner vom Divisor vertauscht werden.
        return new Bruch(this.zaehler * divisor.nenner, this.nenner * divisor.zaehler);
    }

    public Bruch dividiere(int divisor) {
        return this.dividiere(new Bruch(divisor));
    }

    // Ende Grundrechenarten

    @Override
    public int compareTo(Bruch other) {
        // Da wir das Interface Comparable<Bruch> implementiert haben, müssen wir natürlich auch noch angeben, wie der Computer zwei Brüche vergleichen soll
        // Der Einfachheit halber werden die Brücke einfach in Kommazahlen umgerechnet und mit der integrierten Methode verglichen
        return Double.compare(this.toDouble(), other.toDouble());
    }

    @Override
    public boolean equals(Object obj) {
        // Equals sollte man bei jeder Klasse überschreiben, um prüfen zu können, ob zwei Objekte gleich sind
        if (obj instanceof Bruch) {
            // Wenn das andere Objekt ein Bruch ist, kürze beide und vergleiche Zähler und Nenner
            Bruch z1 = this.kuerze();
            Bruch z2 = ((Bruch) obj).kuerze();
            if (z1.zaehler == z2.zaehler && z1.nenner == z2.nenner) {
                return true;
            } else {
                return false;
            }
        } else if (obj instanceof Integer) {
            // Wenn das andere Objekt ein Integer ist, mache aus dem Integer einen Bruch und vergleiche
            return this.equals(new Bruch(((Integer) obj).intValue()));
        } else if (obj instanceof Double) {
            // Wenn es ein Double ist, rechne den Bruch in ein double um und vergleiche
            return this.toDouble() == ((Double) obj);
        } else {
            // Ansonsten wird immer falsch ausgegeben. (Eigentlich müsste man noch vergleiche mit allen anderen Zahlenarten einbauen)
            return false;
        }
    }

    public double toDouble() {
        // Bruch in Kommazahl umrechnen
        return (double) this.zaehler / this.nenner;
    }

    @Override
    public String toString() {
        // Die Methode toString sollte in allen Klassen überschrieben werden. Hier wird einfach eine String-Repräsentation des Bruches ausgegeben.
        // Dadurch kannst du einfach einen Bruch in einen String reinschreiben, ohne Zähler und Nenner aus dem Bruch zu holen.
        return this.zaehler + "/" + this.nenner;
    }

    public String toMixedString() {
        // Falls man den Bruch als gemischten Bruch haben will, ist hier noch die toMixedString Methode.
        if (zaehler / nenner == 0) {
            return this.toString();
        } else {
            return (zaehler / nenner) + " " + Math.abs(zaehler % nenner) + "/" + nenner;
        }
    }
}