Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
wie kann ich nun in der add() Methode auf die Werte 1,5 vom r1 zugreifen?
Habs mit this probiert aber dann sagt der mir "call to this must be first statement in constructor".
class Bruch {
int zaehler;
int nenner;
...
public void add(Bruch that) {
...
}
}
Nun kannst du auf die Instanzvariablen des aufrufenden Objekts r1 innerhalb von add einfach mit [c]zaehler[/c] oder [c]this.zaehler[/c] verweisen, und auf die Instanzvariablen des Arguments mit [c]that.zaehler[/c]. Oder anders ausgedrückt: Das aufgerufene add ist sozusagen das add von r1 und "kennt" deshalb seine "eigenen" Variablen.
Hey das geht ja super schnell hier.
Danke, ich sehe es jetzt, aber deine add Methode ist fehlerhaft.
Das muss andersrum sein, dann werden Brüche addiert
Das Objekt ist nicht null.
Mit Bruch s = null löschst Du die Referenz auf das Objekt der Klasse Bruch, die in s gespeichert war.
Damit kannst Du mit s nicht mehr auf das Objekt zugreifen, da es ins Leere zeigt. Daher auch die NullPointerException.
Wenn Du Werte innerhalb des Objektes verändern möchtest, solltest Du in der Klasse Bruch entsprechende setter Methoden implementieren.
Edit:
Achja, Du solltest auch nicht direkt von außen auf Variablen des Objektes zugreifen, sondern hierfür entsprechende getter Methoden implementieren
Java:
class Bruch {
private int ergebnis;
...
public int getErgebnis()
{
return ergebnis;
}
public void setEregbis(int wert)
{
ergebnis = wert;
}
}
Der this Operator ruft immer das die aktuelle Instanz auf. Wenn du this() so benutzen willst, dann kannst du es nur als ersten Operator benutzen da es logischerweise den Konstruktor des aktuellen Objekts aufruft.
Java:
class Bruch {
private int zaehler;
private int nenner;
public Bruch() {
this(3, 8);
}
public Bruch(int zaehler, int nenner) {
this.zaehler = zaehler;
this.nenner = nenner;
}
public void add(Bruch b) {
this.nenner = this.nenner * b.getNenner();
this.zaehler = (this.zaehler * b.getNenner) + (b.getZaehler * this.nenner);
}
public int getNenner() {
return this.nenner;
}
public int getZaehler() {
return this.zaehler;
}
Wenn du den Konstruktor mit den beiden Parametern aufrufst kannst du den Zäher bzw. Nenner beim Instanziieren selbst bestimmen, wenn du den Konstruktor ohne Parameter aufrufst wird ein Objekt mit Defaul-Parametern instanziiert. Ich mache das sehr gerne weil ich bei Default-objekten bzw. wenn ich Teste nicht immer Parameter schreiben muss.
Zu deiner Frage mit den Gettern, ich habe in dem Code mal zwei Getter definiert, in der Methode add(...) werden sie auch benutzt. Dadurch das die beiden Instanzvariablen Zaehler und Nenner private sind kann man sie nicht von "außen" aufrufen.
In diesem Beispiel könnten nämlich sonst b.nenner und b.zaehler von "außen" also vom Objekt "this" nicht aufgerufen werden. Durch den Getter bleiben die Variablen aber immer noch schreibgeschützt und können nur gelesen werden. Das ganze nennt sich Kapselung und sollte eigentlich bei jedem OO-Programm verwendet werden. Bei einer einzigen Klasse, die nur aus der main() gesteuert wird mag das noch seltsam wirken aber bei Projekten mit mehreren Klassen hats schon Sinn. Am besten man gewöhnt sich sowas schon im kleinen an, damit mans im Großen nicht vergisst
PS: Setter werden dann im Gegenzug benutzt um Variablenwerte zu setzen
Setter und Getter haben den Vorteil, dass du kontrollieren kannst, was du bekommst und herausgibst. Stell dir vor, du initialisierst ein Feld ordentlich, und dann schreibt dir jemand einfach null rein - ärgerlich. Oder du willst jemand Lesezugriff auf eine Liste geben - mit dem direkten Zugriff kannst du nicht verhindern, dass die Liste verändert wird, bei einem Getter kannst du z.B. mit Collections.unmodifiableList(list) eine unveränderliche Kopie zurückgeben. Oder deine Werte müssen bestimmte Bedingungen erfüllen, etwa wenn du eine Zeitspanne von-bis mit Date abbildest, und der von-Wert immer kleiner als der bis-Wert sein muss.
getter und setter enthalten nicht immer nur Zuweisungen bzw eine return statement.
Es kann durchaus sein, dass ein setter Werte überprüft, dann speichert und gleich noch eine Berechnung auslöst oder einen Counter hochzählt oder oder ....
Es kann aber auch sein, dass die Berechnung nicht im setter sondern erst im getter gemacht wird.
Private Membervariablen zwingen die Benutzer dazu deine Methoden zu verwenden und die bist frei darin, die Berechnung dahin zu verschieben wo es geeigneter ist ....
Ein weiterer Vorteil ist die Flexibilität: Stell dir vor du hast eine Klasse Person, die auch das Alter enthält. Später fällt dir ein, dass es praktischer wäre, stattdessen den Geburtstag zu speichern. Bei direktem Zugriff hast du Pech, alle Anwender dieser Klasse müssten sich umstellen. Fragst du das Alter dagegen über einen Getter ab, gibt es kein Problem, er berechnet einfach das Alter aus dem Geburtsdatum, ohne dass sich etwas für den Nutzer der Klasse ändern würde. Getter und Setter schirmen also in einem gewissen Maße "Interna" der Klasse von der Außenwelt ab.
