Diverse Rechenoperatoren als Programm schreiben

Java-Forum Java-Grundlagen
1

Hallo byte-welt,
also ich habe folgendes Problem: Ich muss als Aufgabe ein Programm schreiben welches verschiedene Rechenaufgaben (es geht hauptsächlich um Brüche) ausführt, diese müssen selbst als Methoden geschrieben sein.
Hier mal ein Beispiel der Aufgaben:

-mul
Das zurückgelieferte Ergebnis soll eine neue gekürzte Instanz von Bruchzahl sein, deren Zähler und Nenner den Produkten der Zähler bzw. Nenner der Parameter entsprechen.

Das Problem ist, dass bei der Ausgabe immer nur das zuletzt erstellte Objekt (hier „neu1“) beim Rechnen beachtet wird. Bei der Multiplikation (mul(neu, neu1); ) wird z.B nur das letzte Objekt mit sich selbst Multipliziert.

Hier einmal mein Hauptcode, relevant sind nur die Methoden im markierten Bereich (mit -------------- vom Rest getrennt).

{

	static int a, b;
	static int x;
	static int y;
	static int ergebnis;
	
	public static int ggt(int a, int b)
	{
		
		
		if (a==0)
		{
			ergebnis = b;
		}
		
		if (b==0)
		{
			ergebnis = a;
		}
	
		x = Math.abs(a);
		y = Math.abs(b);
		
		while(x != y)
		{
			if (x > y)
			{
				x -= y;
				ergebnis = x;
			}
			else 
			{
				y -= x;
				ergebnis = y;
			}
			
		}
		
		return ergebnis;
	}

	static void einlesen(Bruchzahl zaehlerundNenner)
	{
		zaehler = IOTools.readInteger("Bitte geben Sie einen Zaehler ein: 
");
		nenner = IOTools.readInteger("Bitte geben Sie einen Nenner ein (nicht 0): 
");
	}

	static void ausgeben(Bruchzahl ausgabe)
	{
		System.out.println("Der eingegebene Bruch ist: " + ausgabe.zaehler + " / " + ausgabe.nenner);
	}

	public static double wert(Bruchzahl ausrechnen)
	{
		double bruch = ((double)zaehler / (double)nenner);
	
		return bruch;
	}

	static int kehrwert(Bruchzahl neuerKehrwert) //Test
	{
		int kehrwertErgebnis = zaehler + nenner;
		return kehrwertErgebnis;
	}

	static int neg(Bruchzahl negiert) //Falsch
	{
		zaehler = -(zaehler);
		nenner = -(nenner);
		return zaehler; 
	}

	static void kuerzen(Bruchzahl zuKuerzen)
	{
		ggt(zaehler, nenner);
		zaehler = (zaehler / ergebnis);		
		nenner = (nenner / ergebnis);
		
		if(zaehler < 0)
			if(nenner < 0)
			{	
				zaehler = (zaehler * (-1));
				nenner = (nenner * (-1));
			}
		
		System.out.println("Es wird versucht den Bruch zu kuerzen...");
	}
//------------------------------------------------------------------------------------------------------------------------------------------
	static void mul(Bruchzahl a, Bruchzahl b)  		//Falsch, rechnet nur mit den Zahlen von "b"
	{
		zaehler = (a.zaehler * b.zaehler);
		nenner = (a.nenner * b.nenner);
		System.out.println("(" + a.zaehler + "/" + a.nenner + ") * (" + b.zaehler + "/" + b.nenner + ")" + " = " + zaehler + "/" + nenner);
	}

	static void div(Bruchzahl a, Bruchzahl b)
	{

		
	}

	static void add(Bruchzahl a, Bruchzahl b)		//Falsch, rechnet nur mit den Zahlen von "b"
	{
		Bruchzahl x = new Bruchzahl();
		x.zaehler = ((a.zaehler * b.nenner) + (b.zaehler * a.nenner));		
		x.nenner = (a.nenner * b.nenner);
		System.out.println("(" + a.zaehler + "/" + a.nenner + ") + (" + b.zaehler + "/" + b.nenner + ")" + " = " + zaehler + "/" + nenner);
		kuerzen(x);
		ausgeben(x);	
	}	
	
	static void sub(Bruchzahl a, Bruchzahl b)
	{

		
	}
//--------------------------------------------------------------------------------------------------------------------------------------------
	public static void main (String [] args)
	{
		Bruchzahl neu = new Bruchzahl();
		einlesen(neu);
		ausgeben(neu);
		//kuerzen(neu);
		//ausgeben(neu);
		//System.out.println("Das Ergebnis der Bruchzahl ist: " + wert(neu));
		
		Bruchzahl neu1 = new Bruchzahl();
		einlesen(neu1);
		ausgeben(neu1);
		//kuerzen(neu1);
		//ausgeben(neu1);
		//System.out.println("Das Ergebnis der Bruchzahl ist: " + wert(neu1));
		
		
		add(neu, neu1);
		mul(neu, neu1);
	
	}
}```

Und der Bruchzahl Code:
```public class Bruchzahl
{
	public static int zaehler;
	public static int nenner;
}```

Ich hoffe ich kontne das Problem erklären, am besten Programm mal ausführen und falls es nicht klar ist versuch ich es nochmal genauer zu erklären wo das Problem liegt. 

Edit: Um es etwas klarer zu machen, bei der Methode mul(neu, neu1);   zb haben die variablen a.zaehler, b.zaehler und zaehler stets den selben Wert.
2

Wenn du die beiden Member-Variablen von Bruchzahl static machst, gibt es sie in der ganzen Klasse auch nur einmal. Du möchstest aber, dass jede Bruchzahl-Instanz seine eigenen Werte enthält. Also muss das static hier weg.

Nebenbei gesagt ist es nicht besonders objektorientiert, eine Klasse Bruchzahl zu haben und dann deren ganzen Operation von einer anderen Klasse ausführen zu lassen. Dass Rechnen von Bruchzahl erbt (extends) ist völlig unnötig, denn hier liegt keine Vererbung vor (Frage: “**Ist **ein Vogel ein Tier?” -> ja -> Vererbung, aber “**Ist **ein ‘Rechnen’ eine ‘Bruchzahl’?” -> nein -> keine Vererbung).

Normalerweise willst du, dass Bruchzahl selbst seinen Kehrwert ausgeben kann, oder einen Wert dazuaddieren. Kann aber sein, dass solche Überlegungen jetzt deinem Lehrplan vorgreifen (da gibt es ja die seltsamsten Ansätze, wie ich im Forum mitbekommen habe).

Ich würde Rechnen ganz wegwerfen (oder nur für Hilfsfunktionen wie ggt verwenden). Bruchzahl könne so aussehen (unveränderlicher Stil, Rechnungen verändern bestehende Instanzen nicht, sondern liefern neue, genau wie bei String, Integer u.s.w.):

public class Bruch {
   private final int zaehler;
   private final int nenner;

   public Bruch(int z, int n) {
       if (n == 0) throw new IllegalArgumentException("Division durch null, oh Gott, oh Gott!");
       int d = ggt(z,n);
       zaehler = z / d;
       nenner = n / d;
   }

   public int getZaehler() {
      return zaehler;
   }
   
   public int getNenner() {
      return nenner;
   }


   public Bruch plus(Bruch summand) {
      return new Bruch(zaehler*summand.nenner + summand.zaehler*nenner, nenner*summand.nenner);
   }

   public Bruch kehrwert() { 
        return new Bruch(nenner, zaehler);
   }

   ...
}
3

Danke für die schnelle Antwort, werde es gleich mal Testen. Wegen der Vererbung etc… ja, ich habe mich das auch schon gefragt aber so ist es in der Aufgabe vorgegeben.

4

Gerade wollte ich abschicken, da sehe ich, dass schon jemand gepostet hat. :stuck_out_tongue:

Ich würde das Kürzen des Bruches auch in den Konstruktor packen, genauso wie eine Überprüfung der Konsistenzbedingung ‚nenner != 0‘.
Falls das nur Teil von etwas Größerem sein soll würde ich auch BigInteger statt int nehmen, der Nenner wird schnell groß, wenn man ein paar Brüche addiert, die Primzahlen als Nenner haben.

5

Oje… Wenn ich das static weg mache, zeigt mir das Terminal erstmal 30 Fehlermeldungen an :frowning: Nun darf ich im Editor alle fehler zusammensuchen :confused:

6

Logisch, nehmen wir mal…

   static void mul(Bruchzahl a, Bruchzahl b)       //Falsch, rechnet nur mit den Zahlen von "b"
    {
        zaehler = (a.zaehler * b.zaehler);
        nenner = (a.nenner * b.nenner);
        System.out.println("(" + a.zaehler + "/" + a.nenner + ") * (" + b.zaehler + "/" + b.nenner + ")" + " = " + zaehler + "/" + nenner);
    }

Das zaehler und nenner hast du hier ja nur, weil Rechnen fälschlicherweise von Bruchzahl erbt, und sie dort fälschlicherweise static sind. Wenn du die jetzige Struktur so beibehältst, und nur das extends und die beiden statics wegmachst, sollte das so funktionieren:

   static Bruchzahl mul(Bruchzahl a, Bruchzahl b)    
    {
        Bruchzahl ergebnis = new Bruchzahl(); 
        ergebnis.zaehler = (a.zaehler * b.zaehler);
        ergebnis.nenner = (a.nenner * b.nenner);
        return ergebnis;
    }

Natürlich brauchst du dann noch eine Methode, die dir eine Bruchzahl ausgibt.

7

[QUOTE=Trayel]Wegen der Vererbung etc… ja, ich habe mich das auch schon gefragt aber so ist es in der Aufgabe vorgegeben.[/QUOTE]Lade doch mal Deinen Lehrer dazu ein, seine Aufgaben hier mit uns zu diskutieren… ;o)

bye
TT