4. einfaches Klassenproblem.

einfaches Klassenproblem.

  • A

    Ich habe die Klasse Rational geschrieben, nun gibt es eine Methode die das aktuelle Objekt mit einem anderen addieren soll und das Ergebnis als Objekt zurückgibt. Rational add(Rational zahl).

    Im Konstruktor (double, double) benötige ich eine Zwischenvariable
    Rational rat, die immer die Summe 2er Zahlen(Objekte) speichert. wie weise ich nun das Ergebnis dem aktuellen Objekt zu? hab da this= add(rat) stehen.
    Der Rückgabetyp von add(rat) ist Rational, also der gleiche Typ wie der des Objekts.

    Code:

    public class Rational 
{
	private long zähler, nenner;

	Rational()							// Standardkonstruktor
	{
		this(0,1);
	}
	Rational(long z,long n)				// Konstruktor für Zähler und Nenner Eingabe.
	{
		this.zähler=z;
		this.nenner=n;
		normalize();
	}
	Rational(long zahl)					// Konstruktor für long Eingabe.
	{
		this(zahl,1);
	}
	Rational(double zahl, double prec)	// Konstruktor für double Eingabe mit Genauigkeit.
	{
		this.zähler=0;
		this.nenner=1;
		this=add(new Rational((long)(zahl)));	//Die Vorkommazahl wird in einen Bruch umgewandelt	
												// der bruch wird zum Objekt addiert
//		System.out.println(add(rat).getZähler()+"/"+add(rat).getNenner());
		zahl-=(long)(zahl);
		long i=10;
		while(zahl>prec)				// die Stellen hinter dem Komma werden in Brüche umgewandelt
		{								// und zur Zahl hinzu addiert.
//			System.out.println(rat.getZähler()+"/"+rat.getNenner());
//			System.out.println(add(rat).getZähler()+"/"+add(rat).getNenner());
			this=add(new Rational((long)(zahl*i)));
			zahl-=(double)(long)(zahl*i)/i;
			i*=10;
		}		

	}
	public void normalize()	// ggT Verfahren. Zähler und Nenner werden durch den ggT(zähler,nenner) geteilt.
	{
		long a=this.zähler, b=this.nenner, r;
		if(b*b>a*a)
		{
			a=this.nenner;
			b=this.zähler;
		}
		while((a%b)!=0)
		{
			r=a%b;
			a=b;
			b=r;
		}
		this.zähler/=b;
		this.nenner/=b;

	}
	public long getZähler()		// Zähler wird zurückgegeben
	{
		return this.zähler;
	}
	public void setZähler(long z)	// setzt den Zähler auf z
	{
		this.zähler=z;
	}
	public long getNenner()			// Nenner wird zurückgegeben
	{
		return this.nenner;
	}
	public void setNenner(long n)	// setzt den Nenner auf n
	{
		if (n!=0)
		{
			this.nenner=n;
		}
		else
		{
			System.out.println("Nulldivision nicht möglich");
		}
	}

	public Rational add(Rational zahl)	// Addiert zur Zahl eine rationale Zahl zahl.
	{
		long z,n;		
		z=this.zähler*zahl.nenner + zahl.zähler*this.nenner;
		n=this.nenner*zahl.nenner;
		return(new Rational(z,n));
	}
	public Rational sub(Rational zahl)	// Subtrahiert zur Zahl eine rationale Zahl zahl.
	{
		long z,n;
		z=this.zähler*zahl.nenner - zahl.zähler*this.nenner;
		n=this.nenner*zahl.nenner;
		return(new Rational(z,n));
	}
	public Rational mul(Rational zahl)	// Multipliziert die Zahl mit einer rationalen Zahl zahl.
	{
		long z,n;
		z=this.zähler*zahl.zähler;
		n=this.nenner*zahl.nenner;
		return(new Rational(z,n));
	}
	public Rational div(Rational zahl)	// Dividiert die Zahl durch eine rationale Zahl zahl.
	{
		long z,n;
		z=this.zähler*zahl.nenner;
		n=this.nenner*zahl.zähler;
		return(new Rational(z,n));
	}
	public long parseLong()			// wandelt die Zahl in eine Ganzzahl vom Typ long um.
	{
		return (this.zähler/this.nenner);
	}
	public double parseDouble()		// wandelt die Zahl in eine Gleitkommazahl vom Typ double um.
	{
		return(this.zähler/(double)this.nenner);
	}

}
    0
  • ?

    1. Für Rational würde sich IMO eine imutable Klasse anbieten, also die Datenelemente final.

    2. rat.zähler und rat.nenner kannst du dir sparen, wenn du gleich den passenden Konstruktor für rat aufrufst.

    wie weise ich nun das Ergebnis dem aktuellen Objekt zu? hab da this= add(rat) stehen.

    Diese Frage verstehe ich nicht. Überhaupt ist mir nicht klar, warum du dazu eine Schleife brauchst. Mach doch einfach einen Bruch

    doubleWert / (precision*10) <- ohne Gewähr

    und ruf eine Methode zum Kürzen auf (das Kürzen sinnvollerweise gleich im Konstruktor).

    4. Überhaupt würde ich in den ganzen Konstruktoren mich auf die anderen beziehen, kennst du this() ?

    0
  • A

    Ist eine Uniaufgabe, this() ging irgendwie nicht um das abzukürzen, ist aber auch egal, wie weise ich nun den berechneten Wert zu?

    0
  • ?

    Naja das geht doch mit so einem temp-Bruch doch ohne Probleme.
    Erstellst deinen temp Bruch mit dem passenden Konstruktor und weist ihn an die this-Referenz zu. Eigentlich so wie du es machst.
    Ich würde aber lieber den zähler und nenner ausrechnen und den eigenen datenelementen zuweisen, das ist vielleicht weniger confusing (und anschließend kürzen). Mir ist immer noch nicht so ganz dein Problem klar.

    Und das this() geht folgendermaßen:

    Rational(long zahl)
{
    this(zahl, 1);            // Ruft den Konstruktor Rational(long, long) auf.
}

    Hat den Vorteil, dass du dir einen Master-Konstruktor zusammenbaust, der dann auch kürzt und alle anderen Konstruktoren rufen den auf. Und damit wäre auch dein Problem gelöst weil du dann einfach zähler und nenner in zwei lokalen Variablen ausrechnest und dann deinen Master-Konstruktor (<- meine Wortschöpfung) aufrufst. 🙂
    Damit enfällt dein Problem von ganz allein.

    0
  • A

    habs korrigiert, aber mein Prob bleibt, add gibt mir einen Bruch zurück. Dieser Wert soll auf das Aktuelle Objekt übertragen werden. Wie geht das? this scheint nicht zu gehen!!!!!

    also irgenwie muss da ...=add(...); stehen.
    was muss vor das Gleichzeichen damit das Objekt nachher den Wert von add hat.

    0
  • ?

    Das System.out.println(add(rat).getZähler()+"/"+add(rat).getNenner());
    hat ganz bestimmt nicht den Effekt, den du dir wünscht, weil du erst sagst: this = ...
    und dann zur Ausgabe WIEDER addest und DAS dann ausgibst. Generell habe ich ziemliche Mühe, deinen Code zu durchschauen.

    Wofür ist das i erst 1, du benutzt den Wert gar nicht.

    Dein Konstruktor soll doch den Bruch anhand des double-Wertes initialisieren, wofür brauchst du da überhaupt ein add??

    Jetzt überlege dir mal in aller Ruhe einen Algorithmus. Und kick das, was du bist jetzt hast. 😉
    Ich kann dir nur erneut dringend raten, erstmal vernünftig den zähler und nenner auszurechnen, in zwei lokalen Variablen und anschließend die Werte zuzuweisen. Mach es dir nicht schwerer, als es ist. 🙂

    Rational(double zahl, double prec)
{
    long zähler, nenner;

    [...]  // berechne zähler und nenner

    this(zähler, nenner);
}
    0
  • A

    was soll der mist, ich muss bei der zahl 3.759 folgendes machen:

    3+7/10+5/100+9/1000 = der gewünschte Bruch.

    die add methode hab ich ja schon geschrieben um die Brüche zu addieren.
    Das Objekt ist mein Ergebnis.

    ich mache also
    obj=3/1.
    obj=obj+7/10
    obj=obj+5/100
    obj=obj+9/1000

    wieso geht das nicht?
    was ist daran verwirrend?

    Der wert geht ja, ich muss nur wissen wie ich ihn an das Objekt übergeben kann. Mit this gehts nicht, antworte mal darauf bitte.

    0
  • ?

    Inzwischen ist der Code nicht mehr so unverständlich, ja- 😉
    Ich habe ehrlich gesagt keine Ahnung, ich habe noch nie jemanden im Konstruktor die this-Referenz ändern sehen. Vielleicht geht das gar nicht. Probier mal einen temp-Bruch aus, rechne mit dem rum und schau, ob der am Ende die richtigen Werte hat. Dann weist du this = temp zu. Wenn dass dann nicht geht, dann musst du halt zähler und nenner einzeln zuweisen.

    Ich habe aber auch echt keine Ahnung, warum du das überhaupt so umständlich löst. Du hast ja sogar ne Methode zum kürzen, du könntest den Bruch auch einfach mit zahl * 10000.0 / 10000 initialisieren (abhängig von der genauigkeit, versteht sich) und dann kürzen.

    0
  • A

    lol, danke für den Tipp, genial 🙂
    hast mir sehr geholfen.

    0
Anmelden zum Antworten