Programmieren eines Bruchrechners

[Aliena]

Hey,

Im Informatik-Unterricht müssen wir einen Bruchrechner realisieren. Da wir aber bis jetzt nur Grafische-Programme erstellt haben, bin ich mit der Aufgabe etwas überfordert. Zudem kommt, dass der Lehrer nicht gerade die große Leuchte ist... : ). Deshalb frage ich hier nach ein paar Tipps für dieses Programm. Vielleicht sollte ich erwähnen das wir mit dem Java-Editor programieren.

Das UML-Klassendiagramm lautet:

Bruch
----------
Zähler
Nenner
----------
! init
! setzeZähler
! setzeNenner
? zähler
? nenner
! KürzeUm
! erweitereUm
! kürzeVoll
? dezimalwert
! kehrBruch
! gibFrei



Klasse Bruch

Klassenbeschreibung:
Sum

Attribute
zZaehler, zNenner : Zahl

Dienste
Auftrag init(pZaehler, pNenner : GanzeZahl)
anfang
zZaehler:= pZaehler
zNenner := pNenner
ende

Auftrag setzeZähler(pZaehler : GanzeZahl)
Anfang
zZaehler := pZaehler
ende

Auftrag setzeNenner(pNenner : GanzeZahl)
Anfang
zNenner := pNenner
ende

Anfrage zaehler : GanzeZahl
Anfang
Ergebnis := zZaehler
ende

Anfrage nenner : GanzeZahl
Anfang
Ergebnis := zNenner
ende

Auftrag kuerzeUm(pZahl : GanzeZahl)
Anfang
zZaehler := zZaehler / pZahl
zNenner := zNenner / pZahl
// Es handelt sich hier jeweils um ganzzahlige Divisionen
ende

Auftrag erweitereUm(pZahl : ganzeZahl)
Anfang
zZaehler := zZaehler * pZahl
zNenner := zNenner * pZahl
ende

Auftrag kuerzeVoll
Anfang
selbst.kuerzeUm(selbst.ggT(zZaehler ,zNenner))
ende

Anfrage dezimalwert : Zahl
Anfang
Ergebnis:= zZaehler/zNenner
ende

Auftrag kehrbruch
lTausch : GanzeZahl
Anfang
lTausch := zZaehler
zZaehler := zNenner
zNenner := lTausch
ende

Auftrag gibFrei
Anfang
ende

-------------------------------------------------------------------------------

So ich weiß nicht ob euch das weiterhilft.. Für mich hört sich das, bzw ließt sich das wie chinesich :/
Hoffe auf Hilfe

MFG
Aliena

 

[hdi]

Oh oh... Ich befürchte dein Thread wird sehr schnell in den "Wir machen keine Hausaufgaben" Pool geworfen,
in den niemals jemand reinschaut

Wenn du das verhindern willst, solltest du mit Ansätzen kommen, die du bisher versucht hast.

Einfach nur eine Angabe hier posten und sagen "Hilfe" ist tödlich! Also husch husch, schreib mal zusammen
was du kannst, und poste Code. Dazu kannst du dann konkrete Fragen stellen.

Und wenn du nicht mal eine Zeile Code schreiben kannst, dann sage wenigstens etwas genauer,
was du an der Angabe nicht verstehst.

PS: Aber schön, dass du dich dafür registiert hast :toll:

 

[Aliena]

nein das will ich nicht !

Also das hab ich bis jetzt im Unterricht gemacht:

Der Bruch:

public class Bruch
{int zähler;
int nenner;

public Bruch(int z,int n)
{ nenner=n;
zähler =z;
}

public Bruch mal(Bruch a)
{return new Bruch(zähler*a.zähler,nenner*a.nenner);}

public Bruch plus(Bruch a)
{return new Bruch(zähler*a.nenner+a.zähler*nenner,nenner*a.nenner);}

public Bruch kehrwert()
{return new Bruch(nenner,zähler);}

public String toString()
{if(nenner!=1)
return new String(zähler + "/" + nenner);
else
return new String(""+zähler);
}
}


und dann den Bruchrechner :

public class Bruchrechnung
{public static void main(String [] args)
{ Bruch c=new Bruch(3,4);
System.out.println("Bruch c= " + c); //Ausgabe als String: automatische

Bruch e=new Bruch(7,8);
Bruch r;
r=c.mal(e);
System.out.println(c+" * "+e+" = "+r);
System.out.println(c+" + "+e+" = "+c.plus(e));
Bruch h=new Bruch(2,3);
Bruch i=c.plus(e).mal(h);
System.out.print("("+c+" + "+e+") * "+h+" = "+i);
}
}


Jetzt sollen wir dem aber eine Maske verpassen und dadrin liegt mein problem... Geht das überhaupt? Weil ich nicht weiß wie ich das grafisch darstellen soll.. : /

 

[hdi]

Also erstmal: Code-Abschnitte bitte mit dem Code-Tag versehen. Es gibt beim Schreiben eines Beitrags
im Editor-Menu den Punkt "Code". Einfach den Java-Code markieren und dann da drauf klicken.
Dann kann man's leichter lesen.

Ok also du hast mit dem Programm selbst kein Problem, sondern weisst nur nicht wie du es grafisch
machen sollst. Das hängt halt jetzt davon ab, wie das aussehen soll. Du sollst wohl Brüche eingeben
und ausrechnen können.

Ich geb dir jetzt mal eine Grundfassung, rein vom Optischen her:

import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JTextField;

/**
 * Ein JFrame ist ein Fenster :)
 */
public class BruchRechnerGUI extends JFrame {

	// Wir machen uns zwei Textfelder:
	JTextField zaehler, nenner;

	// Wir machen uns Knöpfe für die Rechen-Operationen
	JButton mal, plus, kehrwert;

	public BruchRechnerGUI() {
		// Titel des Fensters
		super("Mein Bruchrechner");

		// Textfelder werden erstellt
		zaehler = new JTextField("zaehler hier");
		nenner = new JTextField("nenner hier");

		// Wir geben ihnen eine gewisse Grösse
		zaehler.setPreferredSize(new Dimension(100, 20));
		nenner.setPreferredSize(new Dimension(100, 20));

		// Knöpfe werden erstellt
		mal = new JButton("*");
		plus = new JButton("+");
		kehrwert = new JButton("kw");

		// Wir weisen den Knöpfen die weiter unten definierten Aktionen zu
		mal.addActionListener(new MalAction());
		plus.addActionListener(new PlusAction());
		kehrwert.addActionListener(new KehrwertAction());

		// die Komponenten sollen einfach nebeneinander erscheinen
		setLayout(new FlowLayout()); // "Fluss"-Layout, also alles nebeneinander

		// wir legen die Knöpfe auf das Fenster
		add(mal);
		add(plus);
		add(kehrwert);

		// und auch die zwei TextAreas wo man was eingeben kann
		add(zaehler);
		add(nenner);

		// wir packen alles zusammen (das Fenster baut sich zusammen)
		pack();

		// Programm beendet wenn man auf das rote X oben rechts klickt
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		// zeigt das Fenster an
		setVisible(true);
	}

	class MalAction implements ActionListener {

		/* Diese Methode wird aufgerufen, wenn man auf den Mal-Button klickt */
		@Override
		public void actionPerformed(ActionEvent arg0) {

			// ???
		}
	}

	class PlusAction implements ActionListener {

		/* Diese Methode wird aufgerufen, wenn man auf den Plus-Button klickt */
		@Override
		public void actionPerformed(ActionEvent arg0) {

			// ???
		}
	}

	class KehrwertAction implements ActionListener {

		/*
		 * Diese Methode wird aufgerufen, wenn man auf den Kehrwert-Button
		 * klickt
		 */
		@Override
		public void actionPerformed(ActionEvent arg0) {

			// ???
		}
	}

	/**
	 * DEMO
	 */
	public static void main(String[] args) {
		// Diese Zeile baust du in deine schon existierende Main-Methode ein:
		new BruchRechnerGUI();
	}

}

...das kannst du kopieren und gleich starten.
Deine Aufgabe ist es jetzt, die Methoden in den ActionListenern zu schreiben.

Und zwar solltest du immer den Inhalt von den Textfeldern auslesen, dir daraus
einen Bruch erstellen (die Klasse hast du ja schon), und noch entsprechend eine Methode
darauf aufrufen (plus, mal, oder kehrwert je nachdem welcher Listener).

Den Inhalt von einem Textfeld kriegt man so:

einTextfeld.getText(); // returned einen String

Nachdem du das gemacht hast, bekommst du ja immer einen neuen Bruch. Diesen
solltest du dann anzeigen.

Analog zu getText() für Textfelder gibt es

einTextfeld.setText("Mein Text");

Versuch's einfach mal, implementier die 3 ActionListener, also ersetze die "???", und dann
starte es mal, gib nen Zähler und Nenner ein und kuck ob deine Knöpfe etwas tun.