# Aufgabe mit Brüchen



## Chip0991 (19. Jul 2016)

Servus,
folgende Aufgabe wollte ich gerade lösen und bin mir unsicher was überhaupt gewollt ist: 
a) Schreiben Sie eine Klasse Bruch, die aus einem ganzzahligen Zähler und ganzzahligem Nenner besteht. 

Ich habe das folgendermaßen gelöst:

```
package bruchTest;

public class Bruch {

    long zaehler;
    long nenner;

    public Bruch(long zaehler, long nenner) {

        this.zaehler = zaehler;
        this.nenner = nenner;
    }
```

Wäre das schon ausreichend? Kommt mir etwas wenig vor.

b) Ergänzen Sie die Klasse Bruch um eine statische Methode multipliziereBrueche, die zwei Brüche entgegennimmt, multipliziert und das Ergebnis in einem neuen Bruch zurückgibt.

Ich habe es jetzt soweit gelöst, leider ist mir gerade erst aufgefallen dass eine statische Methode gefordert wird  und da fängt mein Dilemma an.

```
}

    public Bruch multipliziereBrueche(Bruch b) {
        long zaehler = this.zaehler * b.zaehler;
        long nenner = this.nenner * b.nenner;
        return new Bruch(zaehler, nenner);
    }
```

Ohne statische Methode funktioniert auch soweit alles. Hier noch die Main

```
package bruchTest;

public class BruchMain {
    public static void main(String[] args) {

        Bruch bruch1 = new Bruch(2, 2);
        Bruch bruch2 = new Bruch(5, 2);

        System.out.println(bruch1.multipliziereBrueche(bruch2));

    }

}
```

Jetzt bin ich am rätseln was überhaupt von mir bei der b gewollt wird. Wenn ich die Methode in static änder, kann ich ja nicht mehr mit this. arbeiten und habe es dann folgendermaßen geändert:

```
public static Bruch multipliziereBrueche(Bruch bruch1, Bruch bruch2) {
        long zaehler = bruch1.zaehler * bruch2.zaehler;
        long nenner = bruch1.nenner * bruch2.nenner;
        return new Bruch(zaehler, nenner);
```

Jetzt bekomme ich aber auf der Main keine Ausgabe mehr hin bzw. weiß ich gar nicht was ich in die syso eingeben soll. Aber ich glaube die ist auch gar nicht gefragt, möchte es aber trotzdem hinbekommen weil ich den Hintergrund wissen will.



Spoiler: noch die toString





```
}

    public String toString() {
        return this.zaehler + "/" + this.nenner;
   
    }
```




Würde mich über Hilfestellungen freuen.


----------



## Cromewell (19. Jul 2016)

Chip0991 hat gesagt.:


> *public* *static* Bruch multipliziereBrueche(Bruch bruch1, Bruch bruch2) {
> *long* zaehler = bruch1.zaehler * bruch2.zaehler;
> *long* nenner = bruch1.nenner * bruch2.nenner;
> *return* *new* Bruch(zaehler, nenner);


Das ist auf jeden Fall schon mal richtig zu b) , aber ich glaube int würde auch reichen, als Typ 


Chip0991 hat gesagt.:


> Jetzt bekomme ich aber auf der Main keine Ausgabe mehr hin bzw. weiß ich gar nicht was ich in die syso eingeben soll.




```
System.out.println(Bruch.multipliziereBrueche(bruchEins, bruchZwei));
```


----------



## Cromewell (19. Jul 2016)

Edit: und das ganze noch #toString(),
        sprich .multipl(b1, b2).toString()


----------



## mrBrown (19. Jul 2016)

Cromewell hat gesagt.:


> aber ich glaube int würde auch reichen, als Typ


Wie soll int reichen, wenn zwei Brüche miteinander multipliziert werden sollen?



Cromewell hat gesagt.:


> Edit: und das ganze noch #toString(),
> sprich .multipl(b1, b2).toString()


Wird implizit sowieso gemacht


----------



## Cromewell (19. Jul 2016)

mrBrown hat gesagt.:


> Wie soll int reichen, wenn zwei Brüche miteinander multipliziert werden sollen?


Ich weiß ja nicht, mit was für Brüchen hantiert werden soll, aber -2.147.483.648 ... 2.147.483.647 scheint mir groß genug 



mrBrown hat gesagt.:


> Wird implizit sowieso gemacht


Stimmt


----------



## Xyz1 (19. Jul 2016)

Die Musterlösung sollte so ausschauen:

```
/**
 * @author DW on 07/19/16
 */
public class BruchMain {

    private long zaehler;
    private long nenner;

    public BruchMain(long zaehler, long nenner) {
        this.zaehler = zaehler;
        this.nenner = nenner;
    }

    public static BruchMain multiply(BruchMain a, BruchMain b) {
        BruchMain c = new BruchMain(a.zaehler * b.zaehler, a.nenner * b.nenner);
        long u = c.zaehler;
        long v = c.nenner;
        long tempo;
        while (u > 0) {
            tempo = u;
            u = v % u;
            v = tempo;
        }
        c.zaehler /= v;
        c.nenner /= v;
        return c;
    }

    @Override
    public String toString() {
        return "(" + zaehler + " / " + nenner + ")";
    }

    public static void main(String[] args) {
        System.out.println(multiply(new BruchMain(4, 2), new BruchMain(4, 2)));

        BruchMain bm = new BruchMain(1, 1);
        for (int i = 1; i < 10; i++) {
            bm = multiply(bm, new BruchMain(1, i));
        }
        System.out.println(bm + " = " + ((double) bm.zaehler / bm.nenner));
        System.out.println("               " + Math.E);
    }
}
```


```
(4 / 1)
(1 / 362880) = 2.7557319223985893E-6
               2.718281828459045
```

Kommt nahe an die E-Zahl ran, hat aber damit tatsächlich Nullkommanix zu tun. 

a) Du hast nicht gekürzt.
b) Du hast keine Ausgabe drinne.
c) Du rechnest nicht reellen Wert um.
d) Du berechnest Brüche nicht schön in Schleife.

e) long ist natürlich richtig bei solchen Anwendungen...


----------



## Chip0991 (19. Jul 2016)

Erstmal dickes Dankeschön an alle.
@DerWissende kürzen ist nicht nötig, das habe ich leider vergessen zu erwähnen.
Ist eine Ausgabe überhaupt erfordert, bezogen auf die Aufgabenstellung?

Die Aufgabe beinhaltet auch noch eine:
c) Wie sähe die Berechnung im Methodenrumpf für eine statische Methode addiereBrueche aus, die zwei übergebene Brüche addiert?

```
public static Bruch addiereBrueche(Bruch bruch1, Bruch bruch2) {

        long z1 = bruch1.zaehler * bruch2.nenner;
        long z2 = bruch1.nenner * bruch2.zaehler;
        long n = bruch1.nenner * bruch2.nenner;

        return new Bruch(z1 + z2, n);
```
und
d) Ergänzen Sie die Klasse Bruch, um eine nicht-statische Methode multipliziereMitBruch, die einen Bruch übergeben bekommt und diesen mit dem aktuellen Bruch-Objekt multipliziert. Das Ergebnis der Multiplikation soll im aktuellen Bruch-Objekt gespeichert werden.

Hier bin ich mir nicht sicher was es sich mit dem aktuellen Bruch-Objekt auf sich hat. Die Zahlen werden doch trotzdem von der main zugewiesen oder?


```
public Bruch multipliziereMitBruch(Bruch b) {
        long zaehler = this.zaehler * b.zaehler;
        long nenner = this.nenner * b.nenner;
        return new Bruch(zaehler, nenner);
```

Hier auch mal die Punkteverteilung der jeweiligen Aufgaben (3 + 6 + 6 + 5 = 20 Punkte)


----------



## InfectedBytes (19. Jul 2016)

Bei Aufgabe d sollst du eben keinen neuen Bruch erzeugen, sondern den zähler bzw. nenner des aktuellen Objekts (this) neu zuweisen, also z.b.: zaehler *= b.zaehler


----------



## Xyz1 (19. Jul 2016)

Also ich finde die Aufgaben gut beschrieben. Aber wieso gibt es denn nur 20 Punkte, das meiste, was ich bisher sah, hatte so 100 Punkte.

Also: Einfach mit dem eigenen Bruch multiplizieren/addieren (weiß es jetzt schon nicht mehr genau11^^) und nix zurückgeben.

Wenn du bei den anderen Aufgaben Hilfe brauchst, einfach nochmal nachfragen. Greetz.


----------



## Chip0991 (20. Jul 2016)

Das war eine ehemalige Klausuraufgabe und die musste schriftlich auf ein Blatt Papier gebracht werden und die Aufgabe brachte 20 von 90 möglichen Punkten.

@DerWissende du erwähnst bei deinem ersten Post, dass ich keine Ausgabe habe, aber in der Main gebe ich doch das Ergebnis aus oder wie meinst du das? Zu dem verstehe ich nicht wieso die E-Zahl in der Ausgabe hast (Umrechnung in reellen Wert?).

Bei d) steige ich immer noch nicht durch. Ich soll einen Bruch mal den Bruch nehmen, aber woher kommt dieser Bruch bzw. welchen Bruch soll ich dafür nehmen?

Wie ihr merkt bin ich noch sehr laienhaft^^


----------



## Cromewell (20. Jul 2016)

Chip0991 hat gesagt.:


> Bei d) steige ich immer noch nicht durch. Ich soll einen Bruch mal den Bruch nehmen, aber woher kommt dieser Bruch bzw. welchen Bruch soll ich dafür nehmen?


Du sollst den Bruch, der der Funktion übergeben wird mit dem multiplizieren, der gerade von der Instanz gehalten wird.

```
Bruch a = new Bruch(2, 4);
a.multiply(new Bruch(3, 4));
```
Wäre demnach (2/4)*(3/4)


----------



## Xyz1 (20. Jul 2016)

Ja, für eine Klausur, 90 Min., 1/5 der Punkte  , ist das doch vollkommen okay...

Ich weiß jetzt gerade nicht, ob man beim Addieren auch kürzen muss, aber ansonsten:

```
/**
* @author DW on 07/19/16
*/
public class BruchMain {

    private long zaehler;
    private long nenner;

    public BruchMain(long zaehler, long nenner) {
        this.zaehler = zaehler;
        this.nenner = nenner;
    }

    public static BruchMain multiply(BruchMain a, BruchMain b) {
        BruchMain c = new BruchMain(a.zaehler * b.zaehler, a.nenner * b.nenner);
        long u = c.zaehler;
        long v = c.nenner;
        long temp;
        while (u > 0) {
            temp = u;
            u = v % u;
            v = temp;
        }
        c.zaehler /= v;
        c.nenner /= v;
        return c;
    }

    public void multiply(BruchMain a) {
        zaehler *= a.zaehler;
        nenner *= a.nenner;
        long u = zaehler;
        long v = nenner;
        long temp;
        while (u > 0) {
            temp = u;
            u = v % u;
            v = temp;
        }
        zaehler /= v;
        nenner /= v;
    }

    public static BruchMain add(BruchMain a, BruchMain b) {
        BruchMain c = new BruchMain(a.zaehler * b.nenner + b.zaehler * a.nenner, a.nenner * b.nenner);
        long u = c.zaehler;
        long v = c.nenner;
        long temp;
        while (u > 0) {
            temp = u;
            u = v % u;
            v = temp;
        }
        c.zaehler /= v;
        c.nenner /= v;
        return c;
    }

    public void add(BruchMain a) {
        zaehler = zaehler * a.nenner + a.zaehler * nenner;
        nenner *= a.nenner;
        long u = zaehler;
        long v = nenner;
        long temp;
        while (u > 0) {
            temp = u;
            u = v % u;
            v = temp;
        }
        zaehler /= v;
        nenner /= v;
    }

    @Override
    public String toString() {
        return "(" + zaehler + " / " + nenner + " = " + (double) zaehler / nenner + ")"; // unnoetig
    }

    public static void main(String[] args) { // unnoetig
        System.out.println(add(new BruchMain(5, 18), new BruchMain(3, 5)));
        System.out.println(add(new BruchMain(3, 5), new BruchMain(5, 18)));
        BruchMain bm1 = new BruchMain(5, 18);
        BruchMain bm2 = new BruchMain(5, 18);
        BruchMain bm3 = new BruchMain(3, 5);
        BruchMain bm4 = new BruchMain(3, 5);
        bm1.add(bm3);
        bm4.add(bm2);
        System.out.println(bm1);
        System.out.println(bm4);

        System.out.println("");

        System.out.println(multiply(new BruchMain(17, 24), new BruchMain(44, 51)));
        System.out.println(multiply(new BruchMain(44, 51), new BruchMain(17, 24)));
        BruchMain bm5 = new BruchMain(17, 24);
        BruchMain bm6 = new BruchMain(17, 24);
        BruchMain bm7 = new BruchMain(44, 51);
        BruchMain bm8 = new BruchMain(44, 51);
        bm5.multiply(bm7);
        bm8.multiply(bm6);
        System.out.println(bm5);
        System.out.println(bm8);
    }
}
```

Die Aufgaben sind von hier: http://www.mathe-trainer.de/Klasse6/Bruchrechnung/Aufgabensammlung.htm

Eigentlich ist es nicht schlau von mir, diese Aufgabe der Klausur komplett für dich zu bearbeiten, aber dann sind halt alle sauer auf mich. 

Du solltest dringendst nochmal nachlesen, was das Schlüsselwort `this.` bedeutet. Und Klassen. Und Objekte. Und Methoden. Und Variablen. Und Funktionsrückgabetypen. Und und und...


----------

