# [HILFE] Brüche addieren, multiplizieren, kürzen



## schina (8. Nov 2009)

hey leute!
ich hab mir ein projekt mit brüchen vorgenommen und will nun diesen traum in erfüllung bringen xD also los:

ich will also mit brüchen rechnen(addieren, multiplizieren und dann soll der bruch gekürzt werden(laut EUKLIDscher rythmus))
des weiteren hab ich vor, dass alles in der console (dos) anzeigen zu lassen.

da ich noch nich viel mit brüchen geschweige rechnen in java benutzt habe, brauch ich eure hilfe!
als erstes brauch ich hilfe für die methode "addiereBruch"
ich hab keinen plan wie ich das das beschreiben soll

quelltext:

```
import java.awt.*;
/**
  *
  * Klasse zur Beschreibung eines Bruches, mit welchem gerechnet werden kann.
  * Man soll mit ihm addieren und multiplizieren können.
  * Unteranderem soll er sich kürzen lassen.
  * Natürlich sind Zähler und Nenner darstell- und einstellbar.
  *
  * @version 1.0 vom 05.11.2009
  * @Fabian Mielke
  */

public class Bruch {
  // Anfang Attribute
  // Dekleration der Variablen, welche in der ganzen Klasse bekannt sind.
  public int Zaehler           = 1;
  public int Nenner            = 1;
  Bruch Wert1                  = new Bruch(1,2);
  Bruch Wert2                  = new Bruch(3,4);
  Bruch Wert3                  = new Bruch();

  // Ende Attribute



  public Bruch() {
    // Ausgeben der Daten in DOS

    // Anfang Komponenten
    // Ende Komponenten
  }

  /** Konstruktormethode zur Erzeugung eines Bruches.
  @param Zaehler die obenstehende Zahl im Bruch
  @param Nenner die untenstehende Zahl im Bruch
  */
  public Bruch(int Zaehler, int Nenner) {
    this.Zaehler = Zaehler;
    this.Nenner  = Nenner;
  }
  
  
  // Anfang Methoden
  
  /**
  Methode, welche den Zaehler wiedergibt.
  @return obenstehende Zahl im Bruch
  */
  public int getZaehler() {
    return Zaehler;
  }

  /**
  Methode, welche den Zaehler festlegt.
  @param Zaehler neue obenstehende Zahl im Bruch
  */
  public void setZaehler(int Zaehler) {
    this.Zaehler = Zaehler;
  }

  /**
  Methode, welche den Nenner wiedergibt.
  @return untenstehende Zahl im Bruch
  */
  public int getNenner() {
    return Nenner;
  }


  /**
  Methode, welche den Nenner festlegt.
  @param Nenner neue untenstehende Zahl im Bruch
  */
  public void setNenner(int Nenner) {
    this.Nenner = Nenner;
  }


  /**
  Methode, welche einen Bruch addiert.
  @return gibt Summe der addierten Brüche wieder
  @param Wert stellt Objekt vom Typ Bruch dar
  */
  public Bruch addiereBruch(Bruch Wert) {
    return Wert;
  }

  /**
  Methode, welche einen Bruch multipliziert.
  @return gibt Produkt der multiplizierten Brüche wieder
  @param Wert stellt Objekt vom Typ Bruch dar
  */
  public Bruch multiBruch(Bruch Wert) {
    return Wert;
  }

  /**
  Methode, welche einen Bruch kürzt.
  @return gibt gekürzten Bruch als Typ Bruch wieder
  @param Wert stellt Objekt vom Typ Bruch dar
  */
  public Bruch kuerzeBruch(Bruch Wert) {
    return Wert;
  }
    // Ende Methoden

}
```


----------



## Final_Striker (8. Nov 2009)

>ich hab keinen plan wie ich das das beschreiben soll

ja, halt genau so wie du es auch auf dem papier machen würdest


----------



## schina (8. Nov 2009)

ja so einfach ist das ja nicht!
man muss ja erstmal das kleinste gemeinsame vielfache vom nenner finden(wenn nenner nicht gleich)
und dann muss der zähler erweitert werden und erst dann kann man mit dem bruch rechnen...
wie soll ich das in die methode schreiben?


----------



## eRaaaa (8. Nov 2009)

gemeinsamen nenner finden gibt es einfache möglichkeiten..google sollte da weiterhelfen, oder auch mal hier vorbeischauen: Wie addiert oder subtrahiert man Brche? Erklrungen bei Mathepower.com


----------



## schina (8. Nov 2009)

danke für die schnelle antwort, aber das hilft mir leider nicht weiter, da ich nicht weiß wie ich das in java schreiben soll...


----------



## Final_Striker (8. Nov 2009)

es ist ja dein traum, also bringt es nichts wenn ich dir einfach die lösung sagen. 
aber ein tipp: nimm doch einfach nicht den kleinsten gemeinsamen nennen sondern einen der immer passt ;-)


----------



## schina (8. Nov 2009)

Final_Striker hat gesagt.:


> nimm doch einfach nicht den kleinsten gemeinsamen nennen sondern einen der immer passt ;-)



welcher nenner passt denn IMMER???


----------



## Creativ (8. Nov 2009)

Wenn du die Nenner miteinander multiplizierst hast du einen der immer passt


----------



## schina (8. Nov 2009)

das weiß ich auch...ich dachte jetz es gibt so eine spezielle zahl -.-


----------



## Final_Striker (8. Nov 2009)

also, wieso sich dann noch den kopf zerbrechen, du musst es ja nicht ausrechnen


----------



## schina (8. Nov 2009)

ich glaube ich mach erstmal etwas wo ich ein wenig erfolg sehe...

ich hab jetz eine neue datei als console erstellt:


```
public class Bruch_dos {

  public static void main(String[] args) {
    System.out.println("Zähler : " + Bruch.getZaehler());
  }
}
```

jetzt zeigt der mir aber den fehler:


```
Bruch_dos.java:12:43: non-static method getZaehler() cannot be referenced from a static context
    System.out.println("Zähler : " + Bruch.getZaehler());
```


----------



## Final_Striker (8. Nov 2009)

```
public class Bruch_dos {

  public static void main(String[] args) {
     Bruch bruch =  new Bruch();
    System.out.println("Zähler : " + bruch.getZaehler());
  }
}
```


----------



## schina (8. Nov 2009)

fehler: 
	
	
	
	





```
Exception in thread "main" java.lang.StackOverflowError
	at Bruch.<init>(Bruch.java:18)
```

zeile 18 in Bruch.java:
	
	
	
	





```
Bruch Wert1                  = new Bruch(1,2);
```
wenn ich zeile 18 auskommentiere funzt es, aber ich brauche "Bruch Wert1" ja zum rechnen später.


----------



## Landei (8. Nov 2009)

Kleine Tipps: 
- derartige Klassen werden aus gutem Grund unveränderlich gemacht (Integer, String...), also lass die Setter weg
- mach das Kürzen im Konstruktor, dann brauchst du dich bei den anderen Operationen nicht drum zu kümmern
- Überlege dir, wie du negative Brüche darstellen willst. wäer ja dumm, wenn (-3)/4 bei dir etwas anderes wären als 3/(-4)
- Lass den leeren Konstruktor weg, das verwirrt bloß
- schreibe eine equals-, hashCode-, toString und compareTo-Methode (dazu Comparable<Bruch> implementieren)


----------



## schina (8. Nov 2009)

okay ich versteh alles, außer das letzte '


----------



## Landei (8. Nov 2009)

schina hat gesagt.:


> okay ich versteh alles, außer das letzte '



Mit equals kannst du sehen, ob zwei Brüche gleich sind.
hashCode wird z.B. benötigt, wenn deine Brüche in HahsSets oder HashMaps gespeichert werden sollem
toString für die vernünftige Ausgabe
compareTo, damit sie miteinander verglichen werden können, z.B. damit Sortieralgorithmen funktionieren. Für letzeres musst du aber das Comparable-Interface implementieren, also class Bruch implements Comparable<Bruch> ...


----------



## schina (8. Nov 2009)

okay danke für deine hilfe, ich guck mir das mal an!

hat einer was hierzu:





schina hat gesagt.:


> fehler:
> 
> 
> 
> ...


----------



## Illuvatar (8. Nov 2009)

Wofür brauchst du denn diese Wert1 Wert2 und Wert3? Ich wäre für weglassen, vllt solltest du sie aber auch statisch machen oder so - jenachdem wofür sie gut sind.
Ich kann dir aber erklären, warum der Fehler passiert: Du sagst, dass *jedes* Bruch-Objekt so eine Wert1-Variable besitzen muss (und dass die für jeden Bruch neu erstellt wird). Insbesondere muss auch der Wert1-Bruch so eine Variable besitzen. Und während der Wert1-Bruch für den Wert1-Bruch erstellt wird, muss da schon wieder so ein Wert1-Bruch erstellt werden. Etc.


----------

