Aufgabe richtig verstehen

Neue Frage »

Auf diesen Beitrag antworten »
SarahK. Aufgabe richtig verstehen

Meine Frage:
Hallo :-)

Eine kurze Frage, und zwar: Wie versteht ihr die folgende Aufgabe:

Brüche (z.B. 1/3) werden in Java meist mittels float-Variablen dargestellt. Das kann aber in mathematischen
Anwendungen zu Rundungsfehlern führen, welche man vermeiden kann, wenn man eine eigene
Klasse Bruch verwendet. Die Klasse Bruch hält intern den Zähler und den Nenner eines Bruchs
als Integer-Zahlen. Ein Bruch wird unter Angabe seines Zählers und seines Nenners erzeugt. Für
einen Bruch gilt, dass er Zähler und Nenner immer in gekürzter Form speichert und ein negatives
Vorzeichen immer im Zähler hält. (Bei Eingabe von 5 und -10 wird also -1 und 2 gespeichert. Die
Klasse Bruch bietet die vier Grundrechenarten als statische Methoden und eine Methode toString(),
welche einen Bruch in der Form "<z>/<n>" zurückgibt.

Meine Ideen:
So wie ich es verstehe, soll ein Bruch eingegeben werden können und dieser dann in gekürzter Form ausgegeben werden. Sollte das Minus - Zeichen im Nenner stehen, muss dieses in den Zähler?


Besten Dank
 
Auf diesen Beitrag antworten »
Karlito

Hallo SarahK.,

nicht ganz. Die Ausgabe spielt eigentlich keine Rolle, Du sollst nur die Methode toString() so überschreiben, dass es den Wert des gekürzten Bruches ausgibt. Außerdem soll das Minus nicht in den Zähler wenn es im Nenner steht, sondern immer wenn der Bruch insgesamt negativ ist. Und weiterhin sollst Du mit Brüchen rechnen können... Die Klasse muss also über die Methoden add(), substract(), multiply() und divide() verfügen.

Gruß,

Karlito
Auf diesen Beitrag antworten »
SarahK.

Sorry, das ich mich jetzt erst melde. War ein harter Tag an der Hochschule :-)

Vielen Dank für dein Verständnis. Bei den Methoden hätte ich voll daneben gelangt.

Eine Frage noch:

Hat das mit "statische" Methoden eine besondere Bedeutung?
Was bedeutet in Java eigentlich genau static?

Besten Dank :-)
Auf diesen Beitrag antworten »
Karlito

Kein Problem. Ich habe auch nicht immer Zeit hier zu antworten. Das mit den statischen Methoden hat eine besondere Bedeutung. Statische Methoden sind solche, die man auch ohne eine Klasseninstanz ausführen kann. Ein Beispiel dafür ist die main-Methode. An der Stelle siehst du auch den Modifikator "static".

Aber hier noch einmal ein Beispiel:
code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
class Program{

	public static void statischeMethode(){
		System.out.println("statische Methode");
	}

	public void klassenMethode(){
		System.out.println("KlassenMethode");
		this.klassenMethode2(); // geht
		//this.statischeMethode(); //geht nicht
		Program.statischeMethode(); //geht
	}

	public void klassenMethode2(){
		System.out.println("KlassenMethode2");
	}

	public static void main(String[] args){
		Program p = new Program();
		p.klassenMethode(); //geht
		p.klassenMethode2(); //geht
		//p.statischeMethode(); //geht nicht

		//Program.klassenMethode(); //geht nicht
		//Program.klassenMethode2(); //geht nicht
		Program.statischeMethode(); //geht
		
	}
}


Hier noch ein Beispiel was näher an die Aufgabe herankommt:
code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
class Ganzzahl{

	private int wert;

	public Ganzzahl(int wert){
		this.wert = wert;
	}

	public Ganzzahl add(Ganzzahl wert2){
		return new Ganzzahl(wert2.getWert() + this.wert);
	}

	public int getWert(){
		return wert;
	}

	@Override
	public String toString(){
		return "" + wert; //implizier Cast, kommt bestimmt erst später in der Vorlesung
	}

	public static Ganzzahl add(Ganzzahl z1, Ganzzahl z2){
		return new Ganzzahl(z1.getWert()+z2.getWert());
	}

	public static void main(String[] args){
		Ganzzahl g1 = new Ganzzahl(42);
		Ganzzahl g2 = new Ganzzahl(4711);
		System.out.println("Ganzzahl1:\t\t" + g1); //hier wird toString() implizit aufgerufen
		System.out.println("Ganzzahl2:\t\t" + g2);
		System.out.println("Klassenmethode:\t\t" + g1.add(g2)); //Ausnutzung der Klassenvariable
		System.out.println("Statische Methode:\t" + Ganzzahl.add(g1, g2)); //Ausnutzung der statischen Methode
	}
}


Wird sicher eine Weile dauern, bis das alles wirklich verständlich ist, aber ich hoffe das macht es klar.

Gruß,

Karlito
 
Auf diesen Beitrag antworten »
SarahK.

Danke für die Antwort. Das wird eine Weile dauern, bis das sitzt.
Auf diesen Beitrag antworten »
SarahK.

Ich glaube es verstanden zu haben mit static (auf die Aufgabe Bruch bezogen). Wenn ich in den 4 statischen Methoden Summe, Differenz, Multiplikation und Division static verwende, dann wird der Wert, welcher in den Objekten definiert wird auf diese statischen Methoden übergeben?
Auf diesen Beitrag antworten »
Karlito

Mh... Statisch heißt eigentlich im Prinzip nur, dass du keine Instanz der Klasse brauchst um die Methode benutzen zu können. Das hat zur Folge, dass Du, wenn du zwei Brüche addieren willst, die Objektreferenzen an die statische Methode übergeben musst.

Gruß,

Karlito
Auf diesen Beitrag antworten »
SarahK.

Okey :-) Danke dir.
Auf diesen Beitrag antworten »
SarahK.

Hey Leute,

ich bräuchte noch einmal Eure Hilfe zu der Aufgabe.

Habe jetzt den folgenden Code geschrieben:

code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
public class Bruch
{
	public static void main (String[]args)
	{
		Rechnen h = new Rechnen (18,12,44,10);
		h.multiplikation();
		h.ggT();
	}
}

class Rechnen 
{
	static int zaehler;
	static int nenner;
	static int zaehler1; 
	static int nenner1; 
	
	public Rechnen (int zaehler, int nenner, int zaehler1, int nenner1)
	{
		this.zaehler = zaehler;
		this.nenner = nenner;
		this.zaehler1 = zaehler1;
		this.nenner1 = nenner1; 
	}
	
	public static void multiplikation ()
	{
		int ergebnis = (zaehler*zaehler1);
		int result = (nenner*nenner1);  
	}
	
	public static void ggT ()
	{
	int c;
	if (zaehler==nenner)
	{
		System.out.println("Der ggT betraegt " + zaehler);
	}
	if (zaehler<nenner)
		{
			int speicherplatz;
			speicherplatz = zaehler; // 1 in Speicherplatz
			zaehler = nenner; // 12 in Zähler
			nenner = speicherplatz; // 1 in Nenner
		}
		for (int i=0; i<zaehler*nenner; i++)
		{
			while (zaehler>nenner) // Mit while(true) ersetzen; 
			{
				c = zaehler-nenner;   // c = 11
				zaehler=c; 		// a = 11
				if (zaehler<nenner)		//Wenn c kleiner b , dann 	
				{
					int speicher;		 // 
					speicher = zaehler;		// 48 in Speicher
					zaehler = nenner;				// 4 auf a 
					nenner = speicher;		// 48 auf b
				}
				
				if (zaehler==nenner)
				{
					System.out.println("ggT = " + zaehler); 
					break; 
				}
			}
		}
	}
}




Jetzt müsste ich es nur noch schaffen, dass in der Multiplizieren - Methode ergebnis und result durch den ggT geteilt werden, ich bekomme es einfach nicht hin. Wenn weitere Fehler im Code sind, wäre ich euch dankbar, wenn ihr mir sagt, wo diese sind.

Könnt Ihr mir bitte weiterhelfen?
Auf diesen Beitrag antworten »
eulerscheZahl

Zunächst einmal finde ich die Architektur nicht gelungen: du legst hier zwei Brüche in einer Klasse an und teilst dann die Rechenmethode mit. Was, wenn man mit dem Ergebnis weiterrechnen will, oder auch nur einen Bruch anlegen und kürzen? Außerdem darf die Multiplikation nicht static sein, wenn du sie mit h.multiplikation() aufrufen willst.

Die Klasse Bruch hat einen Zähler und einen Nenner. Du kannst einen anderen Bruch dazuaddieren, subtrahieren, ….
Beim ggT gibst du am besten das Ergebnis zurück, also private static int ggT (int a, int b)
Und beim kürzen teilst du Zähler und Nenner beide durch den vom ggT berechneten Wert.
Auf diesen Beitrag antworten »
SarahK.

Danke für die Antwort, dann werde ich das mal abändern.
Auf diesen Beitrag antworten »
Karlito

Check mal bitte noch den ggT. Du hast meiner Meinung nach den euklidischen Algorithmus falsch implementiert.
Auf diesen Beitrag antworten »
SarahK.

Hab heute Mittag zig Versuche damit gestartet und die waren alle erfolgreich.
Auf diesen Beitrag antworten »
Karlito

OK, dann will ich nix gesagt haben. Habe es halt nicht geprüft.

Gruß,

Karlito
Auf diesen Beitrag antworten »
SarahK.

Kein Problem :-)
Auf diesen Beitrag antworten »
Java_Beginner

Hi :-)

Ich habe die gleiche Aufgabe bekommen und stelle mir jetzt vorab die Frage, wie diese genau zu verstehen ist. Ich habe den Konstruktor welcher den ersten Bruch enthält

code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
private static int zaehler;
private static int penner;

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


und dann die statischen Methoden add() ,subtrakt(), multiply() und division() die jeweils zwei weitere Integer - Parameter haben?
Auf diesen Beitrag antworten »
eulerscheZahl

int penner? geschockt

Du hast bei add zwei Möglichkeiten: willst du einen neuen Bruch erzeugen oder den bestehenden verändern?
Für den neuen Bruch brauchst du ein
code:
1:
static Bruch add(Bruch b1, Bruch b2) {...}

Um den bestehenden zu verändern:
code:
1:
void add(Bruch b2) {...}
Auf diesen Beitrag antworten »
Java_Beginner

Sorry für das Penner großes Grinsen Diese bescheuerte Autokorrektur muss ich mal ausschalten böse


Zitat:
willst du einen neuen Bruch erzeugen oder den bestehenden verändern?


Das geht mir aus der Aufgabenstellung eben nicht wirklich hervor. Um Brüche zu addieren oder auch subtrahieren, benötige ich ja zwei Stück. Daher meine Vermutung, dass der Bruch aus dem Konstruktor genommen werden muss und die Methode add() den zweiten Bruch beinhaltet?
Auf diesen Beitrag antworten »
eulerscheZahl

Gehen wir mal davon aus, dass die Funktionen nicht static sind.
Die Variablen zaehler und nenner dürfen auf keinen Fall static sein (auch wenn du add als static deklarierst): das heißt nämlich, dass alle Brüche den selben Zähler und Nenner haben. Da du aber verschiedene Brüche haben willst, ist das kontraproduktiv.
Die Multiplikation würde dann so funktionieren:
code:
1:
2:
3:
4:
5:
void multiply(Bruch b2) {
    this.zaehler *= b2.zaehler;
    this.nenner *= b2.nenner;
    //evtl. noch kürzen
}
 
Neue Frage »
Antworten »


Verwandte Themen

Die Beliebtesten »
Die Größten »
Die Neuesten »