Eine Art Taschenrechner entwickeln?

[manuu]

Hallo,
wir müssen in der Schule mit Java eine Art Taschenrechner entwickeln. Er muss "nur" mit Brüchen rechnen können.

Aufgabe:

Entwickle einen abstrakten Datentyp "Bruch"

Der Datentyp soll dazu benutzt werden simple Aufgaben der Bruchrechnung durchzuführen. D.h Addieren, Multiplizieren und kürzen. Beispiel:

Bruch a;
Bruch b;

a = new Bruch(1,2);
b = new Bruch(3,4);

System.out.println(a.multiplizieremit(b));
----
Ausgabe: 3/8

Und jetzt weiß ich leider nicht wie ich das realisieren soll. Unser Lehrer ist in so einer Hinsicht sehr eigen...er hilft einem bei Problemen nicht wirklich gut bzw. hat keine Lust dazu. Deswegen wende ich mich an euch ^^ Ich hoffe ihr könnt mir dabei helfen.

mfg manuu

 

[Anmeldeboykottierer]

Hi manuu,
natürlich kann dir hier geholfen werden!

Sieh das als meine ganze Antwort an, denn mehr Informationen stecken in deinem Thread nicht drin.
Wenn du eine Lösung möchtest, dann solltest du zu schreiben, wie viel du dafür bezahlen möchtest, ansonsten wirst du kaum ein Forum finden, in dem jmd. dein HAs für dich löst.
Nebenbei bemerkt, spar dir das Geld, spätestens in einer Klausur oder Ähnlichem würdest du ein Problem haben.

Wenn du also Hilfe möchtest, dann solltest du schon etwas mehr schreiben. Was du machen sollst ist grob klar, aber wie weit komsmt du? Was genau ist dein Problem? Was ist deine Idee?
Da wäre erstmal das mit dem abstrakten Datentypen, was weißt du denn über einen ADT? Und wenn du jetzt nichts sagst, dann ist google dein Freund (google weiß alles!)
Dann geht es weiter, wie lautet dein Ansatz? Muss ja nicht Java sein, aber sag was genau du wie machen würdest und erklär möglichst auch warum. Sag dann noch wo du nicht weiterkommst und man kann dir helfen!

Gruß Der Anmeldeboykottierer

 

[LoN_Nemesis]

public class Bruch {
	
	private int zaehler, nenner;
	
	public int getZaehler() {return zaehler;}
	public int getNenner() {return nenner;}
	
	public Bruch multipliziereMit(Bruch b) {
		return new Bruch(zaehler*b.getZaehler(), nenner*b.getNenner());
	}
	
	public Bruch (int zaehler, int nenner) {
		this.zaehler = zaehler;
		this.nenner = nenner;
	}

}

sowas in der Art? Falls die Brüche noch gekürzt sein müssen, musst du noch eine 'kürze' Methode einbauen und diese dann beispielsweise nach jeder Multiplikation etc aufrufen.

Und wenn das genau so sein soll wie in den Beispiel, dann müsste die 'multipliziereMit' Methode einen String zurückgeben, was aber sehr unpraktisch wäre, da man die Aufrufe dann nicht mehr schachteln könnte.

 

[Gast]

das musste ich vor 2 jahren noch in c++ schreiben.

is an sich kein grosses ding, wie man sieht, aber halt ne simple einfache sache um ein bisschen oo zu lernen

 

[manuu]

Uff...den quelltext versteh ich nicht ganz und krieg ihn auch irgendwie nicht zum laufen.

Mein erstes Problem ist schon den abstrakten Datentyp "Bruch" zu entwickeln. Ich kann mir dabei irgendwie nichts vorstellen, wie er aussehen muss oder so. Muss sowas mit nem String gemacht werden oder wie?

 

[SlaterB]

'nicht ganz' und 'irgendwie' sind genau die Ausdrücke, bei denen dir niemand genau weiterhelfen kann,


'dein erstes Problem' ist doch schon als fertiger Quelltext verraten?
das IST der Datentyp 'Bruch', mehr braucht es nicht dafür
bzw. es fehlen natürlich noch addieren usw., aber zum Teil schon recht fertig


wenn du in Mathe zwei Brüche multiplizierst, dann schreibst du doch auch nur Zahlen und Striche oder?
was sollte also ein String dort zu suchen haben?
gut, bei der Ergebnisausgabe '3/8' kann er sicher helfen, aber wenn man soweit ist, ist das meiste doch schon geschafft

 

[manuu]

Ich glaube ich habe vorher vergessen zu erwähnen, dass wir vorher mit so Stapel gearbeitet haben. Und darauf aufbauen soll nun unser Bruchrechner.

//AnzeigeStapel
 import sum.kern.*;

 public class AnzeigeStapel {
	
	int hoehe=0;
	String array[] = new String[10];
	int var[] = new int[10];
	double zH;
	double zV;
	Buntstift s;
	
	public AnzeigeStapel(double pH, double pV) 
	{
		s = new Buntstift();
		
		zH = pH;
		zV = pV;
		
		array[1] = "Stelle 1";
		array[2] = "Stelle 2";
		array[3] = "Stelle 3";
		
		
		s.bewegeBis(zH,zV);
	}
	
	
	public void push(String ps)
	{
		hoehe++;
		array[hoehe] = ps;		
	}

	
	public void pop()
	{
		hoehe--;
	}
	
	
	public String top()
	{
		return array[hoehe];
	}
	
	
	public boolean isempty()
	{
		return (hoehe==0);
	}
...

 

[SlaterB]

es steht dir frei, fünf Brüche und dazwischen vier Rechenarten auf einen Stack zu tun,
um sie dann nacheinander auszurechnen,

das ist oftmals ein recht schlaues Prinzip,
aber davon war bisher wirklich noch gar nicht die Rede,
hat mit Bruch selber auch wenig zu tun,

hast du nun irgendeine Frage dazu?

 

[manuu]

ja...ich weiß nicht wie ich einen abstrakten Datentyp erstellen soll. Ich weiß nicht wie ich das in Java realisieren soll.

 

[LoN_Nemesis]

Mit 'abstrakter Datentyp' meint euer Lehrer sicherlich einfach eine Klasse. Du sollst quasi ein Konstrukt entwickeln, welches einen Bruch repräsentiert. Wenn man sich überlegt, was ein Bruch ist, dann wird man zum Ergebnis kommen, dass ein Bruch eben aus Zähler und Nenner besteht. Deswegen muss ein Datentyp welcher Brüche darstellt in der Lage sein Zähler und Nenner zu speichern und zur Verfügung zu stellen (durch die get Methoden).

Verstehst du es nun?

 

[manuu]

Ja ok..das ist einleuchtend Sollen zaehler und nenner dann als array gespeichert werden oder wie soll man das am besten lösen?

 

[LoN_Nemesis]

Nein wieso als Array? Jeder Bruch hat genau einen Zähler und einen Nenner, einfach ein int (oder long wenn du grosse Brüche haben möchtest). Ich hab dir doch einen Ansatz zur Lösung als Quelltext gepostet, da siehst du es doch.

 

[manuu]

public class Hp {
/**
* @param args
*/
public static void main(String[] args) {

Bruch derBruch;

derBruch = new Bruch(10,5);

derBruch.Bruch(10,5);
}

}

Hab ne neue Klasse "HP" Erstellt, wodrüber der Rechner gesteuert werden soll..aber die unterstrichenen Sachen werden als Falsch angezeigt?! Warum...

 

[LoN_Nemesis]

 derBruch.Bruch(10,5);

Was soll das bewirken? Das erste sollte richtig sein, wenn die Klasse Bruch gefunden wird.

 

[manuu]

das soll bewirken, dass die beiden Zahlen ausgegeben werden.

 

[LoN_Nemesis]

Naja das geht so aber nicht. Dazu musst du der 'Bruch' Klasse schon eine Ausgabe Methode spendieren.


Sowas in der Art:

public void zeigeBruch() {
     System.out.println(zaehler+"/"+nenner);
}

 

[manuu]

hm das wird aber immernoch rot angezeigt... "The constructor "Bruch()" is undefinied"

:/ ich krieg voll zu viel hier ich guck mir doch schon die Video2Brain Java DVD an...

 

[Guest]

hm das wird aber immernoch rot angezeigt... "The constructor "Bruch()" is undefinied"

:/ ich krieg voll zu viel hier ich guck mir doch schon die Video2Brain Java DVD an...

Ich will dir hier echt nicht zu nahe treten, aber du hast hier schon Problem mit den Grundsätzlichen Sachen in Java. Wie erstelle ich eine eigene Klasse. Wie muss ich die Klassen dann aufrufen / initialisieren. Wie kann ich auf Werte in der Klasse von außen zugreifen. Das sind alles Dinge die dir hier sicher schon um einiges weiter helfen würden, wenn du das verstehen würdest.

Wie gesagt ich will dir nicht zu nahe treten oder so, nur solltest vielleicht mal weiter zurück gehen und das grundsätzliche nochmal durchlesen, dann verstehst du vielleicht auch einfacher warum einiges so wie du es anschreibst nicht funktioniert.

 

[manuu]

Ja deswegen guck ich mir ja schon die dvd an und ich so wie ich es versucht habe auf eine Klasse zuzugreifen, so haben wir das in der schule auch immer gemacht. Aber hier scheint das irgendwie nicht zu funtzen. :/

 

[padde479]

Kleines Beispiel, welches ich auf die schnelle bei Google finden konnte. Übernehme aber keine Garantie. Müsste auch noch angepasst bzw. erweitert werden.

public class Bruch {
	/* Zähler-Variable vom Typ int */
        private int zaehler;
	/* Nenner-Variable vom Typ int */
        private int nenner;

	/**
	 * Default-Konstruktor ohne Parameter.
	 */
         public Bruch() {
		 zaehler = 0;
		 nenner  = 1;
	 }
	 
	 /**
	  * Konstruktor. Initialisierung des Zähler mit 1
	  *
	  * @param zaehler Der Zähler des Bruchs
	  */
	  public Bruch(int zaehler) {
		  this.zaehler = zaehler;
		  nenner = 1;
	  }
	  
	  /**
	   * Konstruktor. Initialisierung des Bruches mit den
	   * übergebenen Parametern.
	   *
	   * @param zaehler Der Zähler des neuen Bruches
	   * @param nenner Der Nenner des neuen Bruches 
	   */
	   public Bruch(int zaehler, int nenner) {
		   this.zaehler = zaehler;
		   this.nenner = nenner;
		   
		   if (nenner == 0) {
			   System.err.println("Der Nenner eines Bruches " +
			   	"darf nicht null werden!!!");
			   System.exit(1);
		   }
		   
		   kuerzen();
	   }
	   
	   /**
	    * Copy-Konstruktor zur Initialisierung mit einem Bruch.
	    *
	    * @param bruch Der zu übernehmende Bruch 
	    */
	   public Bruch(Bruch bruch) {
		   zaehler = bruch.zaehler;
		   nenner  = bruch.nenner;
	   }
	   
	   /**
	    * Methode zur Addition eines Bruches
	    *
	    * @param bruch Der zu addierende Bruch
	    */
	   public void add(Bruch bruch) {
		   zaehler = zaehler * bruch.nenner + bruch.zaehler * nenner;
		   nenner = nenner * bruch.nenner;
		   kuerzen();
	   }
	   
	   /**
	    * Methode zur Subtraktion eines Bruches
	    *
	    * @param bruch Der zu subtrahierende Bruch
	    */
	    public void sub(Bruch bruch) {
		    zaehler =  zaehler * bruch.nenner - bruch.zaehler * nenner;
		    nenner = nenner * bruch.nenner;
		    kuerzen();
	    }
	    
	    /**
	     * Methode zur Multiplikation eines Bruches
	     *
	     * @param bruch Der zu multiplizierende Bruch
	     */
	    public void mul(Bruch bruch) {
		    zaehler = zaehler * bruch.zaehler;
		    nenner = nenner * bruch.nenner;
		    kuerzen();
	    }
	    
	    /**
	     * Methode zur Division eines Bruches
	     *
	     * @param bruch Der zu dividierende Bruch
	     */
	     public void div(Bruch bruch) {
		     zaehler = zaehler * bruch.nenner;
		     nenner = nenner * bruch.zaehler;

		     if (bruch.zaehler == 0) {
			     System.err.println("Operation nicht ausgeführt");
			     System.exit(1);
		     }
		     
		     kuerzen();
	     }
	     
	     /**
	      * Methode zur Ermittlung des Zählers des Bruches
	      *
	      * @return den Zähler des Bruches
	      */
	      public int getZaehler() {
		      return zaehler;
	      }
	      
	      /**
	       * Methode zur Ermittlung des Nenners des Bruches
	       *
	       * @return den Nenner des Bruches
	       */
	       public int getNenner() {
		       return nenner;
	       }
	       
	       /**
	        * Methode zur Ausgabe des Bruches.
		* 
		* 


		* Wandelt den Bruch in einen String mit dem Format
		* Zähler/Nenner um. Falls der Nenner null ist, wird
		* eine Fehlermeldung ausgegeben.
		*/
	       public String toString() {
			if (nenner != 0)
				return (zaehler+"/"+nenner);
			else
				return ("Kein Bruch");
	       }
	       
	       /**
	        * Methode die den Bruch mit Hilfe des grössten gemeinsamen
		* Teilers kürzt 
		*/
	       private void kuerzen() {
		       int ggteiler = ggt();
		       nenner = nenner / ggteiler;
		       zaehler = zaehler / ggteiler;
	       }
	       
	       /**
	        * Methode die den grössten gemeinsamen Teiler ermittelt
		*/
	       public int ggt() {
		       int a = zaehler;
		       int b = nenner;
		       int rest;
		       
		       while (b != 0) {
			       rest = a % b;
			       a = b;
			       b = rest;
		       }
		       return a;
	       }
}

Gruß
Padde

 

[manuu]

public class Bruch {
	
	private int zaehler, nenner;
	
	public int getZaehler() {return zaehler;}
	public int getNenner() {return nenner;}
	
	public Bruch multipliziereMit(Bruch b) {
		return new Bruch(zaehler*b.getZaehler(), nenner*b.getNenner());
	}
	
	public Bruch (int zaehler, int nenner) {
		this.zaehler = zaehler;
		this.nenner = nenner;
	}

}

Um nochmal hierdrauf zurückzukommen.

http://manuu.net/eclipse_fehler.jpg
Ich versteh ich nicht warum in deinem Code einmal public class Bruch und dann noch 2x public Bruch steht?!



EDIT: hat sich erledigt. Das lag an der anderen Klasse "Bruch" in dem Prejekt.

import sum.kern.*;
import sum.kern.Bildschirm.*;

public class Hp {
	/**
	 * @param args
	 */
	public static void main(String[] args) {

		Bruch Bruch1 = new Bruch();
		Bruch Bruch2 = new Bruch();
		Bruch1.setBruch(10, 5);
		Bruch2.setBruch(1, 10);
		Bruch1.zeigeBruch();
		Bruch2.zeigeBruch();
		

	}

}

class Bruch {

	int zaehler, nenner;

	int getZaehler() {
		return zaehler;
	}

	int getNenner() {
		return nenner;
	}

	/*
	 * public Bruch multipliziereMit(Bruch b) { return new
	 * Bruch(zaehler*b.getZaehler(), nenner*b.getNenner()); }
	 */

	void setBruch(int zaehler, int nenner) {
		this.zaehler = zaehler;
		this.nenner = nenner;
	}
	
	void zeigeBruch() {
	     System.out.println(zaehler+"/"+nenner);
	}
	
	void multipliziereBruch()
	{
		
	}

}

Jetzt habe ich 2 Brüche gesetzt und mir mal testweise beide ausgeben lassen. Wie muss ich jetzt am besten weiter machen, um die rechen operationen zu erstellen?

 

[LoN_Nemesis]

Dazu musst du einfach nur wissen, wie man mit Brüchen rechnet. Bei dem Beispiel Multiplikation siehst du ja: Zähler1*Zähler2 und Nenner1*Nenner2. Addieren geht nun etwas anders. Dazu musst du die Brüche zuerst auf einen gemeinsamen Nenner bringen. Am einfachsten ist es, du nimmst einfach immer das Produkt der beiden Nenner als gemeinsamen Nenner.

 

[manuu]

Jojo wie man Brüche rechnet weiß ich ja..nur ich weiß nicht welche Variable oder so ich nehmen muss, ob ich vorher noch irgendwas deklarieren muss oder so. Wär nett wenn du es mir an meinem jetzigen quelltext mal zeigen würdest, mit welchen Variablen ich da arbeiten muss und / oder ob ich noch was neues deklarieren muss.

mfg

 

[LoN_Nemesis]

Ich poste nochmal das Multiplizieren Beispiel, ein wenig ausführlicher:

public Bruch multipliziereMit(Bruch b) {
		int ergebnisZaehler = zaehler*b.getZaehler();
		int ergebnisNenner =  nenner*b.getNenner();
		return new Bruch(ergebnisZaehler, ergebnisNenner);
	}

Nehmen wir ein Beispiel: Du möchtest den Bruch 3/5 mit dem Bruch 1/4 multiplizieren.

Also hast du folgenden Code:

Bruch a = new Bruch(3, 5);
Bruch b = new Bruch(1,4);

Bruch c = a.multipliziereMit(b);

Was passiert nun? Du rufst die Methode multipliziereMit von Bruch a auf. Die Variable "zaehler" ist nun also mit 3 belegt, "nenner" mit 5. Zusätzlich bekommst du Bruch b übergeben, auf dessen Zähler und Nenner kannst du mit den public get..() Methoden zugreifen.


Nun überleg dir doch mal wie das Addieren gehen könnte. Du musst dazu nichts deklarieren (ausser evtl. Hilfsvariablen in der Addieren Methode).


Das Grundgerüst der Addieren Methode ist also identisch wie das der Multiplizieren Methode:

public Bruch addiereMit(Bruch b) {
		
	}

 

[manuu]

public Bruch multipliziereMit(Bruch b) {

Sowas hab ich noch nie gesehen. Deswegen versteh ich das glaube ich nicht :/ heißt das nicht irgendwie Bruch.mulitipliziereMit (Bruch b) ?!

"Bruch" is klar, das ist die Klasse und multipliziereMit ist dann die methode fürs mulitiplizieren und was ist das in den Klammern? ne deklaration?`Ich seh da irgendwie kein zusammenhang. Ist das irgendwie nur eine verkürzte schreibweise oder wie?!

 

[LoN_Nemesis]

"Bruch" ist einfach der Rückgabe Typ und "Bruch b" ist ein Übergabe Parameter.

Das bedeutet, wenn du die Zeile

public Bruch multipliziereMit(Bruch b) {

siehst, dann weisst du: Aha, ich übergebe der Methode einen beliebigen Bruch und sie macht dann irgendwas damit und gibt mir als Rückgabewert wieder einen Bruch.

Wenn eine Methode beispielsweise so aussieht:

public int addiereZahlen (int a, int b) {

dann weisst du, dass du der Methode zwei Zahlen a und b übergeben musst und sie gibt dir dann als Rückgabewert wieder eine Zahl. Oben ist es genauso, nur dass der Rückgabewert eben kein primitiver Datentyp wie "int" ist sondern eine Klasse "Bruch".

 

[manuu]

ahhhso ok...aber wenn ich deinen code jetzt benutze kommt bei mir immer ein fehler.

Muss ich der Klasse bruch noch diese beiden Parameter mitgeben?? ergebnisZaehler, ergebnisNenner ?

 

[LoN_Nemesis]

Du kannst natürlich auch deine .setBruch Methode benutzen, dann sieht es eben so aus:

public Bruch multipliziereMit(Bruch b) {
		int ergebnisZaehler = zaehler*b.getZaehler();
		int ergebnisNenner =  nenner*b.getNenner();
		Bruch ergebnisBruch = new Bruch();
		ergebnisBruch.setBruch(ergebnisZaehler, ergebnisNenner);
		return ergebnisBruch;
	}

Aber in dem Fall fände ich es angebrachter, einen Konstruktor zu schreiben wie ich ihn verwendet habe:

public Bruch (int zaehler, int nenner) {
		this.zaehler = zaehler;
		this.nenner = nenner;
	}

Dann akzeptiert er auch den Aufruf new Bruch(irgendeinZähler, irgendeinNenner);

 

[manuu]

Jetzt kommt der Fehler oO



Kann ich das

public Bruch (int zaehler, int nenner) {
      this.zaehler = zaehler;
      this.nenner = nenner;
   }

nicht schon vorher irgendwo bei mir deklarieren?! Also irgendwo oben in der Mainmethode oder so?!

 

[LoN_Nemesis]

Du musst dir mal klarmachen, was ein Konstruktor ist. Kurz und laienhaft legt ein Konstruktor fest, mit welchen Parametern man ein neues Objekt instanziiert. Einen Konstruktor erkennt man daran, dass er immer genauso heisst wie die Klasse selbst.

Wenn du nun folgenden Konstruktor hast

public Bruch (int zaehler, int nenner) {
      this.zaehler = zaehler;
      this.nenner = nenner;
   }

dann bedeutet das: Wenn du einen neuen Bruch erstellen willst, dann musst du seinen Zähler und Nenner bei der Erstellung mit angeben.

Also müssen deine Anweisungen in der Main Methode wie folgt aussehen:

Bruch Bruch1 = new Bruch(10, 5);
Bruch Bruch2 = new Bruch(1, 10);

Wenn du der Meinung bist, dass man beim Erstellen eines Bruches noch nicht unbedingt seinen Zähler und Nenner wissen kann/muss, dann kannst du dir einen leeren Konstruktor schreiben:

public Bruch () {
      this.zaehler = 1;
      this.nenner = 1;
   }

beispielsweise. Dann wird jeder Bruch zunächst mit 1/1 initialisiert, und du kannst später seine Werte über setBruch verändern. Übrigens kannst du auch mehrere Konstruktoren haben, so dass du einen Bruch sowohl mit Angabe des Zählers und Nenners erstellen kannst, als auch ohne.

 

[manuu]

public Bruch multipliziereMit(Bruch b) {
      int ergebnisZaehler = zaehler*b.getZaehler();
      int ergebnisNenner =  nenner*b.getNenner();
      Bruch ergebnisBruch = new Bruch();
      ergebnisBruch.setBruch(ergebnisZaehler, ergebnisNenner);
      return ergebnisBruch;
   }

Und wie ruf ich das ergebnis jetzt auf? Bei new Bruch() hab ich jetzt 2 Parameter eingetragen. ergebnisBruch kann ich irgendwie nicht aufrufen

 

[LoN_Nemesis]

Das Ergebnis liefert die Methode zurück!

Wenn du schreibst:

Bruch c = a.multipliziereMit(b);

Dann ist in c das Ergebnis, welches du mit c.zeigeBruch() ausgeben kannst, falls du die Methode noch hast.