# Die Bruch-Klasse



## Cloud1993 (19. Okt 2010)

Hallo Liebe Community
Ich muss als Hausaufgabe aus dem folgenden UML-Diagramm eine Bruch-Klasse erzeugen:
- Das Diagramm ist fest vorgegeben (unser Lehrer ist zudem recht intolerant was innovative Optionen angeht). Sprich alles in dem UML muss exakt so auch im Code implementiert werden :autsch:

-------------------------------------------------
Bruch
-------------------------------------------------
-m_Zaehler : long = 0
-m_Nenner : long = 0
-------------------------------------------------
+Bruch(p_Zaehler : long, p_Nenner : long)
+getQuotient() : double
+add(p_Zahl : long) : void
+add(p_Zaehler : long, p_Nenner : long) : void
+add(p_Bruch : Bruch) : void
+getZaehler() : long
+getNenner() : long
-------------------------------------------------

Zur Erklärung:
Bruch: m_Zaehler und m_Nenner werden initialisiert
getQuotient: Gibt den Bruch als gebrochene Zahl zurück
add(p_Zahl): Addiert eine Ganzzahl zum Bruch
add(p_Zaehler, ...): Addiert einen Bruch mit Angabe von Zähler und Nenner hinzu
add(p_Bruch): Addiert ein weiteres Bruchobjekt hinzu
get-Teil: liefert Zähler bzw. Nenner zurück

Der Code sieht aktuell so aus:

```
public class Bruch 
{	
	long m_Zaehler = 0;
	long m_Nenner = 0;
	
	public Bruch(long p_Zaehler, long p_Nenner)
	{
	  m_Zaehler = p_Zaehler;
	  m_Nenner = p_Nenner;
	}
	

	double getQuotient()
	{
	  if ((int)m_Nenner == 0) {
		return 0.0;
	  }
	  else{
		return (float)m_Zaehler/(float)m_Nenner; 
	  }	  
	}
	

	void add(long p_Zahl)
	{
		m_Zaehler = m_Zaehler + p_Zahl * m_Nenner;
	}
	

	void add(long p_Zaehler, long p_Nenner)
	{  
	  m_Zaehler = m_Zaehler * p_Nenner;
	  p_Zaehler = p_Zaehler * m_Nenner;
	  
	  m_Zaehler = m_Zaehler + p_Zaehler;
	  m_Nenner = m_Nenner * p_Nenner;  
	}
	

	void add(Bruch p_Bruch)
	{
		
	}
	

	long getZaehler()
	{
		return m_Zaehler;
	}
	
	
	long getNenner()
	{
		return m_Nenner;
	}
	
	
	public static void main(String[] args) 
	{
		Bruch ersterBruch = new Bruch(1,0);
		//ersterBruch.add(1,4);
		//ersterBruch.add(3,5);
	
		System.out.println(ersterBruch.getQuotient());
	}

}
```


So, nun zu meiner Frage:
Wie stell ich den Teil mit 'add(p_Bruch)' dar? Ich weiss einfach nicht wie ich das im Main programmieren soll bzw. wie übergeben und dann ausrechnen.

Wenn mir da jemand helfen kann wär ich sehr dankbar. Auch über eventuelle Fehler die ich nicht seh 

Danke schon mal im Voraus
Cloud


----------



## Sempah (19. Okt 2010)

Obwohl deine bisherige Lösung nicht die optimale ist, kannst du die add(Bruch)-Methode ganz einfach unter Verwendung deiner anderen add-Methode implementieren. -> Bedenke jedoch noch das Kürzen - Stichhwort: KGV


```
void add(Bruch p_Bruch) {
  add(p_Bruch.getZaehler(), p_Bruch.getNenner());
}

public String toString() {
  return "[Bruch: " + getZaehler() + "/" + getNenner() + "]";
}
```


```
Bruch a = new Bruch(1, 3);
Bruch b = new Bruch(2, 3);
a.add(b);
System.out.println(a);
```

Ausgabe: [Bruch: 9/9]

---------

Des Weiteren verwendet man in Java keine Unterstriche: pBruch anstelle von p_Bruch. Methodenparameter zu überschreiben ist auch unschön (p_Zaehler = p_Zaehler * m_Nenner


// Edit:
Achja du könntest dir mal die Class Rational von M. Odersky anschauen. Auch wenn diese in Scala implementiert ist, zeigt sie, wie deine Bruch Klasse elegant aussehen könnte.
-> http://www.scala-lang.org/docu/files/ScalaByExample.pdf - Seite 31


----------



## Cloud1993 (19. Okt 2010)

Sempah hat gesagt.:


> Obwohl deine bisherige Lösung nicht die optimale ist, kannst du die add(Bruch)-Methode ganz einfach unter Verwendung deiner anderen add-Methode implementieren. -> Bedenke jedoch noch das Kürzen - Stichhwort: KGV
> 
> 
> ```
> ...



Zu dem Teil: 'Bruch@3e25a5' ist meine Ausgabe  Das toString "darf" ich nicht implementieren, da unser Lehrer strikt diese Lösung fordert (sprich keine Änderungen; Alles MUSS wie das UML-Diagramm sein ansonsten gibts Abzug und er kackt dich 10mins zusammen wieso du das so gemacht hast ???:L (Unsere Schule leider -.-)



Sempah hat gesagt.:


> Des Weiteren verwendet man in Java keine Unterstriche: pBruch anstelle von p_Bruch. Methodenparameter zu überschreiben ist auch unschön (p_Zaehler = p_Zaehler * m_Nenner



Wie oben genannt: Unser Lehrer für dieses Modul hat 0 Toleranz. Alles was von seiner Lösung abweicht ist falsch (Was willst du da als Schüler schon machen, zumal schon seit 3 Jahren Briefe bei denen eingehen, dass es die Lehrer nicht bringen).
Hab vorhin den Phasenpost durchgelesen und ich hoffe du stempelst meine Antwort nicht als Ausrede ein. 
Mir macht das Programmieren Spass und ich will es auch können.

Und danke noch für die Hilfe 
lg
Cloud


----------



## Landei (19. Okt 2010)

Bezüglich toString() ist das aber totaler Blödsinn, weil das schon in Object implementiert ist, du also keine neue Methode hinzufügst, sondern nur eine schon vorhandene geeignet überschreibst.

Sempah's Lösung für addBruch ist natürlich korrekt (auch wenn kein toString da ist, um es ordentlich anzuzeigen). Kürzen solltest du trotzdem nach jeder Operation: GGT mit dem Euklidischen Algorithmus ermitteln, und Zähler und Nenner dadurch teilen.


----------



## Sempah (19. Okt 2010)

genau, zeigs ihm


----------



## Cloud1993 (19. Okt 2010)

Hab ja auch nie was anderes behauptet 
Hab eben nur das Problem, dass es mir beim System.out.println(a) nicht die Fliesskommazahl oder den Bruch anzeigt sondern "Bruch@3e25a5"
Bin leider kein JAVA-Experte (deshalb auch der Post ) aber ich denke das liegt an 
- add(Bruch p_Bruch)

Nachvollziehen kann ich das alles leider gerade nicht, da für mich die Lösung von Sempah logisch erscheint... wie gesagt: Hab absolut keinen Schimmer woran das liegt vl. könnt ihr mich da unterstützen (natürlich kein muss )


----------



## Sempah (19. Okt 2010)

Nein das liegt daran, dass du die toString() Methode nicht implementiert hast. 
Bei dir wird dann die Standard toString() Methode ausgeführt, welches dir die Speicheradresse liefert.

// die toString() Methode wird implizit aufgerufen, wenn du System.out.println(bruchobjekt) aufrufst -> System.out.println(bruchobjekt.toString()).

Du könntest auch sowas wie System.out.println(bruchobjekt.getZaehler() + "/" + bruchobjekt.getNenner()) schreiben, um den Bruch auszugeben.


----------



## Cloud1993 (19. Okt 2010)

Stimmt hast Recht (Ich Depp). Hätte auch einfach von a aus die getQuotient-Methode aufrufen können <.<

Dann Besten Dank für deine Hilfe  
lg
Cloud


----------

