taschenrechner - Fehler beim Kürzen eines Bruches finden

[kirkikor]

hallo an alle,

ich musste als hausaufgabe ein taschenrechner-programm erstellen. er soll zwei brüche erhalten (zähler sollen ganze zahlen sein, nenner natürliche zahlen außer der null). es funktioniert zwar, aber nur das kürzen des entstandenen bruchs läuft nicht so, wie es soll. es kürzt falsch. komischerweise kürzt es bei der multiplikation und division richtig, aber bei der addition und subtraktion falsch.
könntet ihr mir helfen, den fehler zu korrigieren?


hier mein bytecode:

import java.util.Scanner;


public class taschenrechner {	

  public static void main (String[] argv) {

	Scanner eingabe = new Scanner (System.in);
	
	
	double zaehler1;
	double nenner1;
	double quotient_z;		
	//double gek_zaehler;  //gekürzt
	//double gek_nenner;   //gekürzt
	double zaehler2;
	double nenner2;
	double quotient_n;
	char operation;
	String operation_s;
	double gem_nenner;
	long a = 1;     //anzahl berechnungen
	char key;
	String nextkey;
	double zaehler1_erw, zaehler2_erw, nenner1_erw, nenner2_erw, quotient_z2;
	
	while (a>=1)	{			//für die spätere ja/nein abfrage
	
	

	
	System.out.println("Geben Sie bitte die Zahlen ein.");
	System.out.println("Zaehler vom ersten Quotienten lautet:");
	zaehler1 = eingabe.nextDouble();
	System.out.println("Nenner vom ersten Quotienten lautet:");
	nenner1 = eingabe.nextDouble();
	System.out.println("Zaehler vom zweiten Quotienten lautet:");
	zaehler2 = eingabe.nextDouble();
	System.out.println("Nenner vom zweiten Quotienten lautet:");
	nenner2 = eingabe.nextDouble();
	System.out.println("Welche Operation soll durchgefuehrt werden? +,-,* oder / ?");
	operation_s = eingabe.next();
	operation = operation_s.charAt(0);
	
	gem_nenner = nenner1 * nenner2;   //gemeinsamer Nenner
	
	
	//if (nenner1<0 || nenner2<0)	{		//falls nenner kleiner null
		//System.out.println("Beide Nenner muessen groesser null sein.");
		//a = 0;}   //aus der while-schleife raus
	
	if	(nenner1>0 && nenner2>0)	{			//taschenrechner - haupt
		
		

		
		
		
		if (operation == '+')	{			//addition
				if (nenner1 == nenner2)	{		//gleiche nenner
					quotient_z = zaehler1 + zaehler2; 		//zähler des neuen quotienten
							if (quotient_z == 0)	{				//falls zähler gleich null
								System.out.println("("+zaehler1+"/"+nenner1+") + ("+zaehler2+"/"+nenner2+") = 0/1");}		
							else	{
							
										double gek_zaehler = 0;
										double gek_nenner = 0;
								
								for(int i=1; i<=gem_nenner; i++)	{
									if (quotient_z % i == 0 && gem_nenner % i == 0)	{	//falls teilbar
										
										gek_zaehler = quotient_z / i; 
										gek_nenner = gem_nenner / i;}}
								
								
								System.out.println("("+zaehler1+"/"+nenner1+")"+"+"+"("+zaehler2+"/"+nenner2+")=("+quotient_z+"/"+nenner1+") = ("+gek_zaehler+")/("+gek_nenner+")");}}
							
				else	{								//unterschiedliche nenner
				
				
					if ((zaehler1/nenner1) == ((-zaehler2/nenner2)))	{
						System.out.println("("+zaehler1+"/"+nenner1+" ) +("+zaehler2+"/"+nenner2+") = 0000/1");}
					else	{
						zaehler1_erw = zaehler1*nenner2;	//zahler1 erweitert
						zaehler2_erw = zaehler2*nenner1;		//zahler2 erweitert
						quotient_z=zaehler1_erw + zaehler2_erw;		//zähler des neuen quotienten
							double gek_zaehler = 0;
										double gek_nenner = 0;
								
								for(int i=1; i<=gem_nenner; i++)	{
									if (quotient_z % i == 0 && gem_nenner % i == 0)	{	//falls teilbar
										
										gek_zaehler = quotient_z / i; 
										gek_nenner = gem_nenner / i;}}
						System.out.println("("+zaehler1+"/"+nenner1+") + ("+zaehler2+"/"+nenner2+")=("+quotient_z+"/"+gem_nenner+") = ("+gek_zaehler+")/("+gek_nenner+")");}}}
							
							
		if (operation == '-')	{			//Subtraktion
				if (nenner1 == nenner2)	{		//gleiche nenner
					quotient_z = zaehler1 - zaehler2; 		//zähler des neuen quotienten
							if (quotient_z == 0)	{		//falls zaehler gleich null
								System.out.println("("+zaehler1+"/"+nenner1+") - ("+zaehler2+"/"+nenner2+") = 0/1");}		//falls zähler gleich null
							else	{
								double gek_zaehler = 0;
										double gek_nenner = 0;
								for(int i=1; i<=gem_nenner; i++)	{
									if (quotient_z % i == 0 && gem_nenner % i == 0)	{	//falls teilbar
									
										gek_zaehler = quotient_z / i; 
										gek_nenner = gem_nenner / i;}}
							
							System.out.println("("+zaehler1+"/"+nenner1+") - ("+zaehler2+"/"+nenner2+") = ("+quotient_z+"/"+nenner1+")=("+gek_zaehler+"/"+gek_nenner+")");}}
				else	{						//unterschiedliche nenner
							if ((zaehler1/nenner1)==(zaehler2/nenner2))	{
								System.out.println("("+zaehler1+"/"+nenner1+") - ("+zaehler2+"/"+nenner2+") = 0/1");}
							else	{
							
							
								zaehler1_erw = zaehler1*nenner2;	//zahler1 erweitert
								zaehler2_erw = zaehler2*nenner1;		//zahler2 erweitert
								quotient_z=zaehler1_erw - zaehler2_erw;		//zähler des neuen quotienten
									double gek_zaehler = 0;
										double gek_nenner = 0;
										
								for(int i=1; i<=gem_nenner; i++)	{
									if (quotient_z % i == 0 && gem_nenner % i == 0)	{	//falls teilbar
										
										gek_zaehler = quotient_z / i; 
										gek_nenner = gem_nenner / i;}}
								System.out.println("("+zaehler1+"/"+nenner1+") - ("+zaehler2+"/"+nenner2+") = ("+quotient_z+"/"+gem_nenner+")=("+gek_zaehler+")/("+gek_nenner+")");}}}
							
							
		if (operation == '*')	{			//multiplikation
				quotient_z = zaehler1 * zaehler2;		//zaehler des neuen quotienten
				
						if (quotient_z == 0)	{		
							System.out.println("("+zaehler1+"/"+nenner1+") * ("+zaehler2+"/"+nenner2+") = 0/1");}		//falls zähler gleich null
						else	{
							double gek_zaehler = 0;
										double gek_nenner = 0;
										
							for(int i=1; i<=gem_nenner; i++)	{
								if (quotient_z % i == 0 && gem_nenner % i == 0)	{	//falls teilbar
									
									gek_zaehler = quotient_z / i; 
									gek_nenner = gem_nenner / i;}}
							System.out.println("("+zaehler1+"/"+nenner1+") * ("+zaehler2+"/"+nenner2+") = ("+quotient_z+"/"+gem_nenner+")=("+gek_zaehler+")/("+gek_nenner+")");}}
							
							
		if (operation =='/')	{				//division
				if (zaehler2 == 0)	{
					System.out.println("Man darf nicht durch null teilen.");
					a = 0;}		//aus der while-schleife raus
				else	{
					quotient_z = zaehler1*nenner2;			//zaehler des neuen quotienten
					nenner2_erw = zaehler2*nenner1;			//nenner des neuen quotienten
						double gek_zaehler = 0;
										double gek_nenner = 0;
										
					for(int i=1; i<=gem_nenner; i++)	{
						if (quotient_z % i == 0 && nenner2_erw % i == 0)	{	//falls teilbar
					
							gek_zaehler = quotient_z / i; 
							gek_nenner = nenner2_erw / i;}}
					System.out.println("("+zaehler1+"/"+nenner1+") / ("+zaehler2+"/"+nenner2+") = ("+quotient_z+"/"+nenner2_erw+")=("+gek_zaehler+")/("+gek_nenner+")");}}
					
					
					
			}		//taschenrechner - haupt
			
	else	{
		
		System.out.println("Beide Nenner muessen echt groesser null sein.");
		a=3;		//damit die ja/nein frage überschprungen wird
			}

	if (a!=3)	{			//falls true, dann frage nach einer weiteren berechnung
		
		System.out.println("Wollen Sie eine weitere Berechnung durchfuehren?(j/n)");
		nextkey = eingabe.next();
		key = nextkey.charAt(0);

	
		if (key == 'n' || key == 'N')	{
		a = 0;}}			//aus der while-schleife raus
		
					
		}			//while
						
				
  } // main
	
} // class taschenrechner

 

[Robokopp]

import java.util.Scanner;

public class taschenrechner {

	public static void main(String[] argv) {

		Scanner eingabe = new Scanner(System.in);

		double zaehler1;
		double nenner1;
		double quotient_z;
		// double gek_zaehler; //gekürzt
		// double gek_nenner; //gekürzt
		double zaehler2;
		double nenner2;
		double quotient_n;
		char operation;
		String operation_s;
		double gem_nenner;
		long a = 1; // anzahl berechnungen
		char key;
		String nextkey;
		double zaehler1_erw, zaehler2_erw, nenner1_erw, nenner2_erw, quotient_z2;

		while (a >= 1) { // für die spätere ja/nein abfrage

			System.out.println("Geben Sie bitte die Zahlen ein.");
			System.out.println("Zaehler vom ersten Quotienten lautet:");
			zaehler1 = eingabe.nextDouble();
			System.out.println("Nenner vom ersten Quotienten lautet:");
			nenner1 = eingabe.nextDouble();
			System.out.println("Zaehler vom zweiten Quotienten lautet:");
			zaehler2 = eingabe.nextDouble();
			System.out.println("Nenner vom zweiten Quotienten lautet:");
			nenner2 = eingabe.nextDouble();
			System.out
					.println("Welche Operation soll durchgefuehrt werden? +,-,* oder / ?");
			operation_s = eingabe.next();
			operation = operation_s.charAt(0);

			gem_nenner = nenner1 * nenner2; // gemeinsamer Nenner

			// if (nenner1<0 || nenner2<0) { //falls nenner kleiner null
			// System.out.println("Beide Nenner muessen groesser null sein.");
			// a = 0;} //aus der while-schleife raus

			if (nenner1 > 0 && nenner2 > 0) { // taschenrechner - haupt

				if (operation == '+') { // addition
					if (nenner1 == nenner2) { // gleiche nenner
						quotient_z = zaehler1 + zaehler2; // zähler des neuen
															// quotienten
						if (quotient_z == 0) { // falls zähler gleich null
							System.out.println("(" + zaehler1 + "/" + nenner1
									+ ") + (" + zaehler2 + "/" + nenner2
									+ ") = 0/1");
						} else {

							double gek_zaehler = 0;
							double gek_nenner = 0;

							for (int i = 1; i <= gem_nenner; i++) {
								if (quotient_z % i == 0 && gem_nenner % i == 0) { // falls
																					// teilbar

									gek_zaehler = quotient_z / i;
									gek_nenner = gem_nenner / i;
								}
							}

							System.out.println("(" + zaehler1 + "/" + nenner1
									+ ")" + "+" + "(" + zaehler2 + "/"
									+ nenner2 + ")=(" + quotient_z + "/"
									+ nenner1 + ") = (" + gek_zaehler + ")/("
									+ gek_nenner + ")");
						}
					}

					else { // unterschiedliche nenner

						if ((zaehler1 / nenner1) == ((-zaehler2 / nenner2))) {
							System.out.println("(" + zaehler1 + "/" + nenner1
									+ " ) +(" + zaehler2 + "/" + nenner2
									+ ") = 0000/1");
						} else {
							zaehler1_erw = zaehler1 * nenner2; // zahler1
																// erweitert
							zaehler2_erw = zaehler2 * nenner1; // zahler2
																// erweitert
							quotient_z = zaehler1_erw + zaehler2_erw; // zähler
																		// des
																		// neuen
																		// quotienten
							double gek_zaehler = 0;
							double gek_nenner = 0;

							for (int i = 1; i <= gem_nenner; i++) {
								if (quotient_z % i == 0 && gem_nenner % i == 0) { // falls
																					// teilbar

									gek_zaehler = quotient_z / i;
									gek_nenner = gem_nenner / i;
								}
							}
							System.out.println("(" + zaehler1 + "/" + nenner1
									+ ") + (" + zaehler2 + "/" + nenner2
									+ ")=(" + quotient_z + "/" + gem_nenner
									+ ") = (" + gek_zaehler + ")/("
									+ gek_nenner + ")");
						}
					}
				}

				if (operation == '-') { // Subtraktion
					if (nenner1 == nenner2) { // gleiche nenner
						quotient_z = zaehler1 - zaehler2; // zähler des neuen
															// quotienten
						if (quotient_z == 0) { // falls zaehler gleich null
							System.out.println("(" + zaehler1 + "/" + nenner1
									+ ") - (" + zaehler2 + "/" + nenner2
									+ ") = 0/1");
						} // falls zähler gleich null
						else {
							double gek_zaehler = 0;
							double gek_nenner = 0;
							for (int i = 1; i <= gem_nenner; i++) {
								if (quotient_z % i == 0 && gem_nenner % i == 0) { // falls
																					// teilbar

									gek_zaehler = quotient_z / i;
									gek_nenner = gem_nenner / i;
								}
							}

							System.out.println("(" + zaehler1 + "/" + nenner1
									+ ") - (" + zaehler2 + "/" + nenner2
									+ ") = (" + quotient_z + "/" + nenner1
									+ ")=(" + gek_zaehler + "/" + gek_nenner
									+ ")");
						}
					} else { // unterschiedliche nenner
						if ((zaehler1 / nenner1) == (zaehler2 / nenner2)) {
							System.out.println("(" + zaehler1 + "/" + nenner1
									+ ") - (" + zaehler2 + "/" + nenner2
									+ ") = 0/1");
						} else {

							zaehler1_erw = zaehler1 * nenner2; // zahler1
																// erweitert
							zaehler2_erw = zaehler2 * nenner1; // zahler2
																// erweitert
							quotient_z = zaehler1_erw - zaehler2_erw; // zähler
																		// des
																		// neuen
																		// quotienten
							double gek_zaehler = 0;
							double gek_nenner = 0;

							for (int i = 1; i <= gem_nenner; i++) {
								if (quotient_z % i == 0 && gem_nenner % i == 0) { // falls
																					// teilbar

									gek_zaehler = quotient_z / i;
									gek_nenner = gem_nenner / i;
								}
							}
							System.out.println("(" + zaehler1 + "/" + nenner1
									+ ") - (" + zaehler2 + "/" + nenner2
									+ ") = (" + quotient_z + "/" + gem_nenner
									+ ")=(" + gek_zaehler + ")/(" + gek_nenner
									+ ")");
						}
					}
				}

				if (operation == '*') { // multiplikation
					quotient_z = zaehler1 * zaehler2; // zaehler des neuen
														// quotienten

					if (quotient_z == 0) {
						System.out.println("(" + zaehler1 + "/" + nenner1
								+ ") * (" + zaehler2 + "/" + nenner2
								+ ") = 0/1");
					} // falls zähler gleich null
					else {
						double gek_zaehler = 0;
						double gek_nenner = 0;

						for (int i = 1; i <= gem_nenner; i++) {
							if (quotient_z % i == 0 && gem_nenner % i == 0) { // falls
																				// teilbar

								gek_zaehler = quotient_z / i;
								gek_nenner = gem_nenner / i;
							}
						}
						System.out.println("(" + zaehler1 + "/" + nenner1
								+ ") * (" + zaehler2 + "/" + nenner2 + ") = ("
								+ quotient_z + "/" + gem_nenner + ")=("
								+ gek_zaehler + ")/(" + gek_nenner + ")");
					}
				}

				if (operation == '/') { // division
					if (zaehler2 == 0) {
						System.out.println("Man darf nicht durch null teilen.");
						a = 0;
					} // aus der while-schleife raus
					else {
						quotient_z = zaehler1 * nenner2; // zaehler des neuen
															// quotienten
						nenner2_erw = zaehler2 * nenner1; // nenner des neuen
															// quotienten
						double gek_zaehler = 0;
						double gek_nenner = 0;

						for (int i = 1; i <= gem_nenner; i++) {
							if (quotient_z % i == 0 && nenner2_erw % i == 0) { // falls
																				// teilbar

								gek_zaehler = quotient_z / i;
								gek_nenner = nenner2_erw / i;
							}
						}
						System.out.println("(" + zaehler1 + "/" + nenner1
								+ ") / (" + zaehler2 + "/" + nenner2 + ") = ("
								+ quotient_z + "/" + nenner2_erw + ")=("
								+ gek_zaehler + ")/(" + gek_nenner + ")");
					}
				}

			} // taschenrechner - haupt

			else {

				System.out
						.println("Beide Nenner muessen echt groesser null sein.");
				a = 3; // damit die ja/nein frage überschprungen wird
			}

			if (a != 3) { // falls true, dann frage nach einer weiteren
							// berechnung

				System.out
						.println("Wollen Sie eine weitere Berechnung durchfuehren?(j/n)");
				nextkey = eingabe.next();
				key = nextkey.charAt(0);

				if (key == 'n' || key == 'N') {
					a = 0;
				}
			} // aus der while-schleife raus

		} // while

	} // main

} // class taschenrechner

 

[Camill]

Ich schlage dir mal vor das ganze in mehrere Methoden zu unterteilen - erleichtert sowohl dir als auch uns die Fehlersuche.

 

[kirkikor]

tut mir leid, aber ich kann noch nicht mit methoden umgehen.

hier aber die zeilen, die für das kürzen zuständig sind:


das ist für die addition zuständig.

zaehler1_erw = zaehler1*nenner2;	//zahler1 erweitert
zaehler2_erw = zaehler2*nenner1;		//zahler2 erweitert
quotient_z=zaehler1_erw + zaehler2_erw;		//zähler des neuen quotienten

double gek_zaehler = 0;
double gek_nenner = 0;
								
for(int i=1; i<=gem_nenner; i++)	{
	if (quotient_z % i == 0 && gem_nenner % i == 0)	{	//falls teilbar
										
		gek_zaehler = quotient_z / i; 
		gek_nenner = gem_nenner / i;}}

System.out.println("("+zaehler1+"/"+nenner1+") + ("+zaehler2+"/"+nenner2+")=("+quotient_z+"/"+gem_nenner+") = ("+gek_zaehler+")/("+gek_nenner+")");}

[EDIT][noparse]

hier den Java Code einfügen

[/noparse]
sollte doch kein Problem darstellen, oder?[/EDIT]

 

[Final_Striker]

Wenn du denn Bruch zunächst kürzt und danach die Berechnung durchführst, brauchst du nicht das gleiche 4x zu schreiben.

 

[kirkikor]

ich weiß, aber die aufgabe will es so. zuerst zwei brüche eingeben, dann ausrechnen, dann das ergebnis kürzen.

 

[Final_Striker]

ich weiß, aber die aufgabe will es so. zuerst zwei brüche eingeben, dann ausrechnen, dann das ergebnis kürzen.

Ist das Gleiche nur in grün.

Bei dir erfolgt die Ausgabe nach jeder Berechnung und nicht erst am Ende. Wenn du das änderst, vermeidest du 4x Kürzen und 4x Ausgabe.

 

[kirkikor]

ok. ich verstehe. ich werde es dann am ende umändern. jedoch funktioniert mein "kürz-programm" nicht ordnungsgemäß. wenn ich zB (1/2)+(3/2) eintippe, gibt er mir zwar (4/2) heraus, aber sobald das kürzen beginnt, kommt (1/1) heraus. das selbe kürzproblem bekomme ich bei der subtraktion; bei der division und multiplikation nicht.
kannst du meinen fehler aufdecken?

 

[pappawinni]

also.. hm.. aeh..
Deine Kürzmethode scheint mir so einige Probleme zu haben.
Es könnte ja z.B. sein, dass mehrfach mit der gleichen Zahl gekürzt werden kann.
In deinem Code ist es aber eher so so, denk ich, dass
gek_zaehler = quotient_z / i;
gek_nenner = gem_nenner / i;
nur ein einziges mal kürzt, weil sich zwar i ändert, aber quotient_z und gem_nenner in der for-Schleife ja immer den gleichen Wert haben. Damit wird, wenn ich das recht habe, nur einmal mit der grössten Zahl gekürzt.
Meiner Meinung nach sollte in der Schleife nur
gek_zaehler = gek_zaehler / i;
gek_nenner = gek_nenner / i;
stehen. Dazu müsste natürlich vor der Schleife
gek_zaehler = quotient_z ;
gek_nenner = gem_nenner ;
stehen.
Hm.. und das if wäre vielleicht besser ein While..

Ach nee, is ja quark.. grösster gemeinsamer Teiler sollte es ja tun...

 

[kirkikor]

danke für deine antwort.
ich habe es gerade eben ausprobiert, aber es klappt immernoch nicht. nun kommt als ergebnis (0.5/0.5) heraus. ich finde es auch sehr seltsam, dass es bei der multi. und division klappt, obwohl die zeilen identisch sind.
hast du vllt noch ideen?

 

[pappawinni]

hast hoffentlich mitbekommen, dass ich Quark geschreiben habe, denn der größte gemeinsame Teiler tut es ja.
Ich würd jetzt mal n paar klammern setzten, oder zumindest mal schauen, ob das ohne Klammern richtig interpretiert wird:
if ((quotient_z % i == 0) && (gem_nenner % i == 0))

 

[Final_Striker]

ich habe es gerade eben ausprobiert, aber es klappt immernoch nicht. nun kommt als ergebnis (0.5/0.5) heraus. ich finde es auch sehr seltsam, dass es bei der multi. und division klappt, obwohl die zeilen identisch sind.

Wenn du logisch überlegst, dann stellst du fest, dass so etwas nicht sein kann. Beim Kürzen wird ein Bruch in einen anderen Bruch überführt. Ob der Eingabe-Bruch durch Subtraktion, Division oder wie auch immer entstanden ist, ist dabei völlig egal.

Bei der Addition: (1/2)+(3/2) -> (4/2) -> (kürzen) -> (2/1)

muss das gleiche rauskommen wie bei der

Multiplikation: (1/1)*(4/2) -> (4/2) -> (kürzen) -> (2/1)

Wenn da trotzdem unterschiedliche Ergebnisse rauskommen, muss an dem zu kürzenden Bruch was nicht stimmen.

 

[kirkikor]

habe gerade deinen vorschlag ausprobiert, aber ohne erfolg.
ich bin etwas verzweifelt.

 

[AquaBall]

Genau das ist der Grund, warum du daraus eine Methode machen solltest.
Leg das HauptProjekt im Augenblick zur Seite,
lies dich bei "Methoden" (was du noch nicht verstehst) ein, und mach dann weiter.
(Das Problem sind dabei weniger die Methoden, als dass du BruchObjekte dazu einführen solltest.)

Du hast dann 3 Methoden:
bruchAddition (macht ja auch Subtraktion)
bruchMultiplikation (macht ja auch Division)
und bruchKürzen

Du wirst erstaunt sein, wie kurz dann das Programm ist, und wie schnell du Fehler findest.

 

[pappawinni]

richtig AquaBall,
so wie das Ding jetzt aussieht ist die Fehlersuche reichlich schwierig.

Was sicherlich nicht sein kann ist, dass beim Kürzen ein und des selben Bruches zwei verschiedene Ergebnisse herauskommen.

 

[AquaBall]

Das ist so ziemlich das KOMPLETTE Programm (bis auf Kleinigkeiten)!!!!
(Korrekturlesen und Ergänzen bitte selbst!)

class Bruch {
  int zähler, nenner;
  Bruch(int newZähler, int newNenner){
    this.zähler = newZähler;
    this.nenner= newNenner;
  }
  int getZähler()  { return zähler; }
  int getNenner()  { return nenner; }
  String toString(){ return zähler +"/"+ nenner; }

  Bruch addiere(Bruch summand) {
    zähler  = this.zähler*summand.getNenner() + nenner()*summand.getZähler();
    nenner *= summand.getNenner();
    return this;
  }
  Bruch multipliziere(Bruch faktor) {
    zähler  *= faktor.getZähler();
    nenner *= faktor.getNenner();
    return this;
  }
  Bruch kürzen() {
    // Das machst du selbst!!!
    return this;
  }
}

main()
  Bruch erster= new Bruch(1,2);
  Bruch zweiter= new Bruch(3,4);
  System.out("Addition: " +erster + " + "+ zweiter +" = "+ erster.addiere(zweiter));
  System.out("Gekürzt => " +erster.kürzen());
 
  erster= new Bruch(1,2);
  zweiter= new Bruch(3,4);
  System.out("Multiplikation: " +erster + " * "+ zweiter +" = "+ erster.multipliziere(zweiter));
  System.out("Gekürzt => " +erster.kürzen());
}

[TIPP]Wenn du ein Programm für Brüche scheibst, sollte eigentlich NIRGENDS ein anderer Typ als "int" auftauchen![/TIPP]

 

[kirkikor]

vielen dank an euch beiden.

habe es gerade versucht zu kompelieren, aber es spuckt viele fehler aus(den code zu verstehe vertage ich auf morgen, da es nun sehr spät geworden ist). da ich methoden noch nicht hatte, könntet ihr mir das fehlerfrei schicken??

 

[AquaBall]

Na meinetwegen, grad weils mich halt reizt.
Schau in ner Stunde vorbei!
-------------
Edit: Hab mir doch gleich die Zeit genommen, hat gar nicht viel gefehlt:

package my.Package;
import my.Package.Bruch;

public class BruchRechner {
	public static void main(String[] args) {
		  Bruch erster = new Bruch(1,2);
		  Bruch zweiter= new Bruch(3,4);
		  System.out.println("");
		  
		  System.out.println("Addition: " +erster + " + "+ zweiter +" = "+ erster.addiere(zweiter));
		  System.out.println("Gekürzt => " +erster.kürzen());
		 
		  erster= new Bruch(15,2);
		  zweiter= new Bruch(3,5);
		  System.out.println("Multiplikation: " +erster + " * "+ zweiter +" = "+ erster.multipliziere(zweiter));
		  System.out.println("Gekürzt => " +erster.kürzen());
	}
}

package my.Package;

	 class Bruch {
		  int zähler, nenner;
		  Bruch(int newZähler, int newNenner){
		    this.zähler = newZähler;
		    this.nenner= newNenner;
		  }
		  public int getZähler()  { return zähler; }
		  public int getNenner()  { return nenner; }
		  public String toString(){ return zähler +"/"+ nenner; }
		 
		  public Bruch addiere(Bruch summand) {
		    zähler  = zähler*summand.getNenner() + nenner*summand.getZähler();
		    nenner *= summand.getNenner();
		    return this;
		  }
		  public Bruch multipliziere(Bruch faktor) {
		    zähler *= faktor.getZähler();
		    nenner *= faktor.getNenner();
		    return this;
		  }
		  public Bruch kürzen() {
			  int z1=nenner;
			  int z2=zähler;
			  while (z2 != 0) {
				  if (z1 > z2) {
					  z1 = z1 - z2;
				  } else {
					  z2 = z2 - z1;
				  }
			  }
			  nenner /=	z1;   
			  zähler /=	z1;   
			  return this;
		  }
	 }

Test:
Addition: 1/2 + 3/4 = 10/8
Gekürzt => 5/4
Multiplikation: 15/2 * 3/5 = 45/10
Gekürzt => 9/2

 

[kirkikor]

danke sehr.
habe aber heute morgen meinen fehler erkannt.
das kürzen an sich funktionierte nur bei addition und subtraktion mit gleichem nenner nicht.
und nach genauerem hinsehen fand ich heraus, dass ich ständig mit dem gemeinsamen nenner gerechnet hab (also nenner1 mal nenner2). korrigiert habe ich es, indem ich einfach aus dem gem_nenner ein nenner1 gemacht habe.
vielen dank für euer bemühen.

 

[cmrudolph]

@AquaBall: wenn man jetzt noch die Rechenoperationen auslagert, ein Interface dafür erzeugt und pro Rechenoperation eine Klasse erstellt, dann ist man bei OOP angekommen.

 

[AquaBall]

Hast ja recht, aber ich geh davon aus, dass kirkikor schon mit den Classen nicht ganz klar kommt. Da werden ihn Interfaces noch mehr verwirren.