Bruch

// Die imports werden nur für die main-Methode gebraucht, in der einige Tests gemacht werden.
// Die eigentliche Klasse Bruch sollte keine main-Methode haben und braucht daher auch nicht diese imports
import java.util.Arrays;
import java.util.Random;

public class Bruch extends Number implements Comparable<Number> {
    // 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 static void main(String[] args) {
        Bruch z1 = new Bruch(1, 2);
        Bruch z2 = new Bruch(2, 3);
        System.out.println(z1 + " + " + z2 + " = " + z1.addiere(z2)); // 1/2 + 2/3 = 7/6
        System.out.println(z1 + " + " + z2 + " = " + z1.addiere(z2).toMixedString()); // 1/2 + 2/3 = 1 1/6
        System.out.println(z1 + " - " + z2 + " = " + z1.subtrahiere(z2)); // 1/2 - 2/3 = -1/6
        System.out.println(z1 + " * " + z2 + " = " + z1.multipliziere(z2)); // 1/2 * 2/3 = 1/3
        System.out.println(z1 + " / " + z2 + " = " + z1.dividiere(z2)); // 1/2 / 2/3 = 3/4

        // vergleich mit Bruch
        System.out.println(new Bruch(1,2).equals(new Bruch(2,4))); // true
        System.out.println(new Bruch(1,2).equals(new Bruch(1,4))); // false

        // vergleich mit int
        System.out.println(new Bruch(1,2).equals(1)); // false
        System.out.println(new Bruch(1).equals(1)); // true

        // vergleich mit double
        System.out.println(new Bruch(1,2).equals(0.5)); // true
        System.out.println(new Bruch(1,2).equals(0.6)); // false

        // Sortiertest (compareTo)
        Bruch[] brueche = new Bruch[10];
        Random random = new Random();
        for (int i = 0; i<10; i++) {
            brueche[i] = new Bruch(random.nextInt(10), random.nextInt(9)+1);
        }
        System.out.println("Gemischte Brüche: " + Arrays.toString(brueche));
        Arrays.sort(brueche);
        System.out.println("Sortierte Brüche: " + Arrays.toString(brueche));
    }

    public Bruch(int zaehler, int nenner) {
        // Konstruktor für einen echten Bruch (z.B. 7/6)
        if (nenner == 0) throw new IllegalArgumentException("Der Nenner darf nicht 0 sein.");
        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(new Bruch(zaehler, nenner).addiere(ganze));
    }

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

    public Bruch(Bruch original) {
        // Konstruktor für Kopien von anderen Brüchen
        this(original.zaehler, original.nenner);
    }

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

    private static int ggT(int a, int b) {
        // Größten gemeinsamen Teiler mit der euklidischen Methode berechnen. Wird gebraucht zum kürzen.
        return b==0?a:ggT(b,a%b);
    }

    public Bruch kuerze() {
        int ggT = ggT(this.zaehler, this.nenner); // ggT berechnen
        Bruch ergebnis = new Bruch(this.zaehler/ggT, this.nenner/ggT); // Zähler und Nenner durch ggT teilen
        if (ergebnis.nenner < 0) {
            // falls der Nenner negativ ist, beide Vorzeichen umkehren.
            ergebnis = new Bruch(-ergebnis.zaehler, -ergebnis.nenner);
        }
        return ergebnis;
    }

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

    public int getZaehler() {
        return this.zaehler;
    }

    public int getNenner() {
        return this.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 multipliziert 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) {
        // Hier wird einfach das Vorzeichen des subtrahenten umgedreht und dann addiert.
        return this.addiere(subtrahend.multipliziere(-1));
    }

    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 this.multipliziere(new Bruch(divisor.nenner, divisor.zaehler));
    }

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

    // Ende Grundrechenarten

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

    @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 Number) {
            // Wenn das andere Objekt ein sonstiger Zahlentyp ist, rechne den Bruch in ein double um und vergleiche
            return this.doubleValue() == ((Number) obj).doubleValue();
        } else {
            // Ansonsten wird immer falsch ausgegeben. (Eigentlich müsste man noch vergleiche mit allen anderen Zahlenarten einbauen)
            return false;
        }
    }

    @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;
        }
    }

    // Methoden der übergeordneten Klasse Number (müssen implementiert werden, da sie in Number nur abstrakt sind)

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

    @Override
    public float floatValue() {
        // Bruch in Kommazahl umrechnen
        return (float) this.doubleValue();
    }

    @Override
    public int intValue() {
        // Bruch in Ganzzahl umrechnen (Achtung, beim Ergebnis werden mögliche Kommazahlen abgeschnitten)
        return (int) this.doubleValue();
    }

    @Override
    public long longValue() {
        return (long) this.doubleValue();
    }
}