Einführung in die objektorientierte Programmierung

Wir beginnen nun unsere Reise in die Welt der objektorientierten Programmierung. Wir konzentrieren uns zunächst auf die Beschreibung von Konzepten und Daten mithilfe von Objekten.

Objektorientierte Programmierung befasst sich damit, Konzepte eines Problembereichs in separate Einheiten zu isolieren und dann diese Einheiten zur Lösung von Problemen zu verwenden. Konzepte, die mit einem Problem verbunden sind, können erst berücksichtigt werden, wenn sie identifiziert wurden. Mit anderen Worten, wir können Abstraktionen aus Problemen bilden, die diese Probleme leichter zugänglich machen.

Sobald Konzepte im Zusammenhang mit einem bestimmten Problem identifiziert wurden, können wir auch beginnen, Konstrukte zu erstellen, die sie in Programmen darstellen. Diese Konstrukte und die einzelnen Instanzen, die daraus gebildet werden, d.h. Objekte, werden zur Lösung des Problems verwendet. Die Aussage „Programme werden aus kleinen, klaren und kooperativen Objekten gebaut“ mag noch keinen Sinn ergeben. Sie wird jedoch verständlicher, wenn wir im Kurs fortschreiten, vielleicht sogar offensichtlich.

Klassen und Objekte

Wir haben bereits einige der von Java bereitgestellten Klassen und Objekte verwendet. Eine Klasse definiert die Attribute von Objekten, d.h. die mit ihnen verbundenen Informationen (Instanzvariablen), und ihre Befehle/Aktionen, d.h. ihre Methoden. Die Werte der Instanzvariablen definieren den internen Zustand eines einzelnen Objekts, während Methoden die von ihm angebotenen Funktionalitäten definieren.

Eine Methode ist ein benannter Abschnitt von Quellcode, der innerhalb einer Klasse geschrieben ist und aufgerufen werden kann. Eine Methode gehört immer zu einer Klasse und wird häufig verwendet, um den internen Zustand eines aus einer Klasse instanziierten Objekts zu ändern.

Ein Objekt wird immer durch Aufrufen einer Methode erstellt, die ein Objekt erstellt, d.h. einen Konstruktor, indem das Schlüsselwort new verwendet wird.

Klassen erstellen

Eine Klasse spezifiziert, wie die von ihr instanziierten Objekte aussehen.

• Die Variablen des Objekts (Instanzvariablen) spezifizieren den internen Zustand des Objekts.
• Die Methoden des Objekts spezifizieren, was das Objekt tut.

Jetzt werden wir uns damit vertraut machen, eigene Klassen zu erstellen und die dazugehörigen Variablen zu definieren.

Eine Klasse wird definiert, um eine bedeutungsvolle Entität darzustellen, wobei eine "bedeutungsvolle Entität" oft ein reales Objekt oder Konzept meint. Wenn ein Computerprogramm beispielsweise persönliche Informationen verarbeiten müsste, wäre es sinnvoll, eine separate Klasse Person zu definieren, die Methoden und Attribute im Zusammenhang mit einer Person enthält.

Lassen Sie uns beginnen. Wir gehen davon aus, dass wir eine Projektvorlage haben, die ein leeres Hauptprogramm enthält:

public class Main {

    public static void main(String[] args) {

    }
}

Lassen Sie uns eine Klasse namens Person erstellen. Für diese Klasse erstellen wir eine separate Datei mit dem Namen Person.java. Unser Programm besteht jetzt aus zwei separaten Dateien, da auch das Hauptprogramm in einer eigenen Datei liegt. Die Datei Person.java enthält zunächst die Klassendefinition public class Person und die geschweiften Klammern, die den Inhalt der Klasse umschließen.

public class Person {

}

Nach dem Erstellen einer neuen Datei sieht der aktuelle Zustand wie folgt aus. Im Bild unten wurde die Klasse Person der SandboxExercise hinzugefügt.

Man kann auch ein Klassendiagramm zeichnen, um eine Klasse darzustellen. Wir werden uns im Laufe der Zeit mit den Notationen vertraut machen. Eine leere Klasse namens Person sieht folgendermaßen aus:

Eine Klasse definiert die Attribute und das Verhalten der Objekte, die von ihr erstellt werden. Lassen Sie uns entscheiden, dass jedes Person-Objekt einen Namen und ein Alter hat. Es ist naheliegend, den Namen als Zeichenkette und das Alter als Ganzzahl darzustellen. Wir fügen diese zu unserem Bauplan hinzu:

public class Person {
    private String name;
    private int age;
}

Wir spezifizieren hier, dass jedes Objekt, das aus der Klasse Person erstellt wird, einen name und ein age hat. Variablen, die innerhalb einer Klasse definiert sind, werden Instanzvariablen genannt (auch Objektfelder oder Objektattribute).

Instanzvariablen werden auf den Zeilen nach der Klassendefinition public class Person { geschrieben. Jede Variable wird durch das Schlüsselwort private eingeleitet. Das Schlüsselwort private bedeutet, dass die Variablen im Inneren des Objekts "versteckt" sind. Dies wird als Kapselung bezeichnet.

Im Klassendiagramm werden die Variablen, die mit der Klasse verbunden sind, als "variableName: variableType" definiert. Das Minuszeichen vor dem Variablennamen zeigt an, dass die Variable gekapselt ist (sie hat das Schlüsselwort private). Durch die Deklaration von Variablen und Methoden als privat schützen Sie die Integrität der Klasse, indem Sie verhindern, dass externe Objekte direkt auf diese zugreifen oder sie manipulieren können. Stattdessen erfolgt der Zugriff über öffentliche Methoden (Getter und Setter), was eine kontrollierte Interaktion ermöglicht und die Wartbarkeit sowie Sicherheit des Codes erhöht.

Wir haben jetzt einen Bauplan — eine Klasse — für das Person-Objekt definiert. Jedes neue Person-Objekt verfügt über die Variablen name und age, die objektspezifische Werte enthalten können. Der "Zustand" einer Person besteht aus den Werten, die ihrem Namen und ihrem Alter zugewiesen sind.

Definition eines Konstruktors

Wir möchten einen Anfangszustand für ein erstelltes Objekt festlegen. Benutzerdefinierte Objekte werden auf die gleiche Weise erstellt wie Objekte aus vorgefertigten Java-Klassen, wie z. B. ArrayList, unter Verwendung des Schlüsselworts new. Es wäre praktisch, die Variablen dieses Objekts beim Erstellen mit Werten zu versehen. Zum Beispiel ist es nützlich, wenn man beim Erstellen eines neuen Person-Objekts einen Namen angeben kann:

public static void main(String[] args) {
    Person ada = new Person("Ada");
    // ...
}

Dies wird durch die Definition der Methode erreicht, die das Objekt erstellt, d. h. seines Konstruktors. Der Konstruktor wird nach den Instanzvariablen definiert. Im folgenden Beispiel wird ein Konstruktor für die Klasse Person definiert, der verwendet werden kann, um ein neues Person-Objekt zu erstellen. Der Konstruktor setzt das Alter des erstellten Objekts auf 0 und den als Parameter übergebenen Zeichenkette als dessen Namen:

public class Person {
    private String name;
    private int age;

    public Person(String initialName) {
        this.age = 0;
        this.name = initialName;
    }
}

Der Name des Konstruktors ist immer derselbe wie der Klassenname. Die Klasse im obigen Beispiel heißt Person, daher muss der Konstruktor ebenfalls Person heißen. Dem Konstruktor wird auch der Name des zu erstellenden Person-Objekts als Parameter übergeben. Der Parameter wird in Klammern eingeschlossen und folgt dem Namen des Konstruktors. Den Klammern, die optionale Parameter enthalten, folgen geschweifte Klammern. Zwischen diesen Klammern befindet sich der Quellcode, den das Programm ausführt, wenn der Konstruktor aufgerufen wird (z. B. new Person ("Ada")).

Objekte werden immer mit einem Konstruktor erstellt.

Ein paar Dinge sind zu beachten: Der Konstruktor enthält den Ausdruck this.age = 0. Dieser Ausdruck setzt die Instanzvariable age des neu erstellten Objekts (d. h. das "dieses" Objekt age) auf 0. Der zweite Ausdruck this.name = initialName weist ebenso die übergebene Zeichenkette der Instanzvariable name des erstellten Objekts zu.

Methoden für ein Objekt definieren

Wir wissen, wie man ein Objekt erstellt und seine Variablen initialisiert. Ein Objekt benötigt jedoch auch Methoden, um irgendetwas tun zu können. Wie wir gelernt haben, ist eine Methode ein benannter Abschnitt von Quellcode innerhalb einer Klasse, der aufgerufen werden kann.

public class Person {
    private String name;
    private int age;

    public Person(String initialName) {
        this.age = 0;
        this.name = initialName;
    }

    public void printPerson() {
        System.out.println(this.name + ", age " + this.age + " years");
    }
}

Eine Methode wird innerhalb der Klasse unter dem Konstruktor geschrieben. Der Methodenname wird von public void eingeleitet, da die Methode für die Außenwelt sichtbar sein soll (public), und sie keinen Wert zurückgibt (void).

Zusätzlich zum Klassennamen, den Instanzvariablen und dem Konstruktor enthält das Klassendiagramm jetzt auch die Methode printPerson. Da die Methode mit dem Modifikator public versehen ist, wird der Methodenname mit einem Pluszeichen vorangestellt. Für die Methode sind keine Parameter definiert, daher wird nichts in die Klammern der Methode gesetzt. Die Methode wird auch mit Informationen versehen, die angeben, dass sie keinen Wert zurückgibt, hier void.

Die Methode printPerson enthält eine Zeile Code, die die Instanzvariablen name und age verwendet — das Klassendiagramm sagt nichts über deren interne Implementierungen aus. Instanzvariablen werden mit dem Präfix this referenziert. Alle Variablen des Objekts sind innerhalb der Methode sichtbar und verfügbar.

Erstellen wir drei Personen im Hauptprogramm und fordern sie auf, sich selbst auszugeben:

public class Main {

    public static void main(String[] args) {
        Person ada = new Person("Ada");
        Person antti = new Person("Antti");
        Person martin = new Person("Martin");

        ada.printPerson();
        antti.printPerson();
        martin.printPerson();
    }
}

Ausgabe:

Den Wert einer Instanzvariablen in einer Methode ändern

Fügen wir der zuvor erstellten Person-Klasse eine Methode hinzu, die das Alter der Person um ein Jahr erhöht.

public class Person {
    private String name;
    private int age;

    public Person(String initialName) {
        this.age = 0;
        this.name = initialName;
    }

    public void printPerson() {
        System.out.println(this.name + ", age " + this.age + " years");
    }

    // growOlder() Methode wurde hinzugefügt
    public void growOlder() {
        this.age = this.age + 1;
    }
}

Die Methode wird innerhalb der Klasse Person genauso geschrieben wie die Methode printPerson. Die Methode erhöht den Wert der Instanzvariablen age um eins.

Das Klassendiagramm erhält ebenfalls ein Update.

Rufen wir die Methode auf und sehen, was passiert:

public class Main {

    public static void main(String[] args) {
        Person ada = new Person("Ada");
        Person antti = new Person("Antti");

        ada.printPerson();
        antti.printPerson();
        System.out.println("");

        ada.growOlder();
        ada.growOlder();

        ada.printPerson();
        antti.printPerson();
    }
}

Die Ausgabe des Programms lautet wie folgt:

Das bedeutet, dass die beiden Objekte, wenn sie "geboren" werden, beide null Jahre alt sind (this.age = 0; wird im Konstruktor ausgeführt). Die Methode growOlder des ada-Objekts wird zweimal aufgerufen. Wie die Ausgabe zeigt, ist Ada nach dem Älterwerden 2 Jahre alt. Das Aufrufen der Methode für ein Objekt, das Ada entspricht, hat keine Auswirkungen auf das Alter des anderen Personenobjekts, da jedes Objekt, das aus einer Klasse instanziiert wird, seine eigenen Instanzvariablen hat.

Die Methode kann auch bedingte Anweisungen und Schleifen enthalten. Die folgende growOlder-Methode begrenzt das Altern auf 30 Jahre.

public class Person {
    private String name;
    private int age;

    public Person(String initialName) {
        this.age = 0;
        this.name = initialName;
    }

    public void printPerson() {
        System.out.println(this.name + ", age " + this.age + " years");
    }

    // niemand wird älter als 30 Jahre
    public void growOlder() {
        if (this.age < 30) {
            this.age = this.age + 1;
        }
    }
}

Rückgabe eines Werts von einer Methode

Eine Methode kann einen Wert zurückgeben. Die bisher in unseren Objekten erstellten Methoden haben nichts zurückgegeben. Dies wurde durch das Tippen des Schlüsselworts void in der Methodendefinition gekennzeichnet.

public class Door {
    public void knock() {
        // ...
    }
}

Das Schlüsselwort void bedeutet, dass die Methode keinen Wert zurückgibt.

Wenn wir möchten, dass die Methode einen Wert zurückgibt, müssen wir das void-Schlüsselwort durch den Typ der zurückzugebenden Variable ersetzen. Im folgenden Beispiel hat die Klasse Teacher eine Methode grade, die immer eine ganzzahlige (int) Variable zurückgibt (in diesem Fall den Wert 10). Der Wert wird immer mit dem return-Befehl zurückgegeben:

public class Teacher {
    public int grade() {
        return 10;
    }
}

Die obige Methode gibt eine int-Variable mit dem Wert 10 zurück, wenn sie aufgerufen wird. Damit der Rückgabewert verwendet werden kann, muss er einer Variablen zugewiesen werden. Dies geschieht genauso wie die normale Wertzuweisung, d. h. mit dem Gleichheitszeichen:

public static void main(String[] args) {
    Teacher teacher = new Teacher();

    int grading = teacher.grade();

    System.out.println("The grade received is " + grading);
}

Der Rückgabewert der Methode wird einer Variablen des Typs int zugewiesen, wie dies bei jeder anderen int-Variable der Fall wäre. Der Rückgabewert könnte auch als Teil eines Ausdrucks verwendet werden.

public static void main(String[] args) {
    Teacher first = new Teacher();
    Teacher second = new Teacher();
    Teacher third = new Teacher();

    double average = (first.grade() + second.grade() + third.grade()) / 3.0;

    System.out.println("Grading average " + average);
}

Alle Variablen, die wir bisher gesehen haben, können auch von einer Methode zurückgegeben werden. Zusammengefasst:

• Eine Methode, die nichts zurückgibt, hat den Modifizierer void als Typ der zurückzugebenden Variablen.

public void methodThatReturnsNothing() {
    // der Methodenrumpf
}

• Eine Methode, die eine Ganzzahl zurückgibt, hat den Modifizierer int als Typ der zurückzugebenden Variablen.

public int methodThatReturnsAnInteger() {
    // der Methodenrumpf, erfordert eine return-Anweisung
}

• Eine Methode, die eine Zeichenkette zurückgibt, hat den Modifizierer String als Typ der zurückzugebenden Variablen

public String methodThatReturnsAString() {
    // der Methodenrumpf, erfordert eine return-Anweisung
}

• Eine Methode, die eine Gleitkommazahl mit doppelter Genauigkeit zurückgibt, hat den Modifizierer double als Typ der zurückzugebenden Variablen.

public double methodThatReturnsADouble() {
    // der Methodenrumpf, erfordert eine return-Anweisung
}

Lassen Sie uns mit der Klasse Person fortfahren und eine returnAge-Methode hinzufügen, die das Alter der Person zurückgibt.

public class Person {
    private String name;
    private int age;

    public Person(String initialName) {
        this.age = 0;
        this.name = initialName;
    }

    public void printPerson() {
        System.out.println(this.name + ", age " + this.age + " years");
    }

    public void growOlder() {
        if (this.age < 30) {
            this.age = this.age + 1;
        }
    }
    // die hinzugefügte Methode
    public int returnAge() {
        return this.age;
    }

Die Klasse in ihrer Gesamtheit:

Lassen Sie uns veranschaulichen, wie die Methode funktioniert:

public class Main {

    public static void main(String[] args) {
        Person pekka = new Person("Pekka");
        Person antti = new Person("Antti");

        pekka.growOlder();
        pekka.growOlder();

        antti.growOlder();

        System.out.println("Pekka's age: " + pekka.returnAge());
        System.out.println("Antti's age: " + antti.returnAge());
        int combined = pekka.returnAge() + antti.returnAge();

        System.out.println("Pekka's and Antti's combined age " + combined + " years");
    }
}

Wie wir bemerkt haben, können Methoden genauso Quellcode enthalten wie andere Teile unseres Programms. Methoden können bedingte Anweisungen oder Schleifen enthalten, und andere Methoden können ebenfalls von ihnen aufgerufen werden.

Schreiben wir nun eine Methode für die Person, die bestimmt, ob die Person volljährig ist. Die Methode gibt einen boolean-Wert zurück - entweder true oder false:

public class Person {
    // ...

    public boolean isOfLegalAge() {
        if (this.age < 18) {
            return false;
        }

        return true;
    }

    /*
     Die Methode könnte folgendermaßen prägnanter geschrieben werden:

    public boolean isOfLegalAge() {
        return this.age >= 18;
    }
    */
}

Und testen wir sie:

public static void main(String[] args) {
    Person pekka = new Person("Pekka");
    Person antti = new Person("Antti");

    int i = 0;
    while (i < 30) {
        pekka.growOlder();
        i = i + 1;
    }

    antti.growOlder();

    System.out.println("");

    if (antti.isOfLegalAge()) {
        System.out.print("of legal age: ");
        antti.printPerson();
    } else {
        System.out.print("underage: ");
        antti.printPerson();
    }

    if (pekka.isOfLegalAge()) {
        System.out.print("of legal age: ");
        pekka.printPerson();
    } else {
        System.out.print("underage: ");
        pekka.printPerson();
    }
}

Lassen Sie uns die Lösung etwas verfeinern. In ihrer jetzigen Form kann eine Person nur auf eine Weise „ausgegeben“ werden, die sowohl den Namen als auch das Alter enthält. Es gibt jedoch Situationen, in denen wir nur den Namen eines Objekts wissen möchten. Schreiben wir eine separate Methode für diesen Anwendungsfall:

public class Person {
    // ...

    public String getName() {
        return this.name;
    }
}

Die getName-Methode gibt die Instanzvariable name an die aufrufende Methode zurück. Der Name dieser Methode ist etwas seltsam. Es ist in Java üblich, eine Methode, die eine Instanzvariable zurückgibt, genau so zu benennen, d.h. getVariableName. Solche Methoden werden oft als „Getter“ bezeichnet.

Die gesamte Klasse sieht so aus:

Passen wir das Hauptprogramm so an, dass es die neue „Getter“-Methode verwendet:

public static void main(String[] args) {
    Person pekka = new Person("Pekka");
    Person antti = new Person("Antti");

    int i = 0;
    while (i < 30) {
        pekka.growOlder();
        i = i + 1;
    }

    antti.growOlder();

    System.out.println("");

    if (antti.isOfLegalAge()) {
        System.out.println(antti.getName() + " is of legal age");
    } else {
        System.out.println(antti.getName() + " is underage");
    }

    if (pekka.isOfLegalAge()) {
        System.out.println(pekka.getName() + " is of legal age");
    } else {
        System.out.println(pekka.getName() + " is underage ");
    }
}

Die Ausgabe beginnt, ziemlich ordentlich zu werden:

Eine Zeichenkettenrepräsentation eines Objekts und die toString-Methode

Wir haben uns eines eher schlechten Programmierstils schuldig gemacht, indem wir eine Methode zum Ausgeben des Objekts erstellt haben, d.h. die printPerson-Methode. Ein bevorzugter Weg ist es, eine Methode für das Objekt zu definieren, die eine „Zeichenkettenrepräsentation“ des Objekts zurückgibt. Die Methode, die die Zeichenkettenrepräsentation zurückgibt, heißt in Java immer toString. Definieren wir diese Methode für die Person im folgenden Beispiel:

public class Person {
    // ...

    public String toString() {
        return this.name + ", age " + this.age + " years";
    }
}

Die toString-Methode funktioniert wie printPerson. Sie druckt jedoch nichts selbst aus, sondern gibt eine Zeichenkettenrepräsentation zurück, die die aufrufende Methode nach Bedarf zum Ausgeben verwenden kann.

Die Methode wird auf eine etwas überraschende Weise verwendet:

public static void main(String[] args) {
    Person pekka = new Person("Pekka");
    Person antti = new Person("Antti");

    int i = 0;
    while (i < 30) {
        pekka.growOlder();
        i = i + 1;
    }

    antti.growOlder();

    System.out.println(antti); // entspricht System.out.println(antti.toString());
    System.out.println(pekka); // entspricht System.out.println(pekka.toString());
}

Im Prinzip fordert die Methode System.out.println die Zeichenkettenrepräsentation des Objekts an und gibt sie aus. Der Aufruf der toString-Methode, die die Zeichenkettenrepräsentation zurückgibt, muss nicht explizit geschrieben werden, da Java sie automatisch hinzufügt. Wenn eine Programmierender Folgendes schreibt:

System.out.println(antti);

Erweitert Java den Aufruf zur Laufzeit in die folgende Form:

System.out.println(antti.toString());

Daher ruft der Aufruf System.out.println(antti) die toString-Methode des antti-Objekts auf und gibt die Zeichenkette zurück, die von dieser Methode zurückgegeben wird.

Wir können die nun überflüssige printPerson-Methode aus der Person-Klasse entfernen.

Methodenparameter

Setzen wir die Arbeit mit der Person-Klasse fort. Wir haben beschlossen, dass wir den Body-Mass-Index von Personen berechnen möchten. Dazu schreiben wir Methoden

für die Person, um sowohl die Größe als auch das Gewicht zu setzen, und auch eine Methode zur Berechnung des Body-Mass-Index. Die neuen und geänderten Teile des Person-Objekts sind wie folgt:

public class Person {
    private String name;
    private int age;
    private int weight;
    private int height;

    public Person(String initialName) {
        this.age = 0;
        this.weight = 0;
        this.height = 0;
        this.name = initialName;
    }

    public void setHeight(int newHeight) {
        this.height = newHeight;
    }

    public void setWeight(int newWeight) {
        this.weight = newWeight;
    }

    public double bodyMassIndex() {
        double heigthPerHundred = this.height / 100.0;
        return this.weight / (heigthPerHundred * heigthPerHundred);
    }

    // ...
}

Die Instanzvariablen height und weight wurden der Person hinzugefügt. Werte für diese Variablen können mit den Methoden setHeight und setWeight gesetzt werden. Es wird erneut die Standardbenennungskonvention von Java verwendet, d.h., wenn der einzige Zweck der Methode darin besteht, einer Instanzvariablen einen Wert zuzuweisen, wird sie als setVariableName benannt. Methoden, die Werte setzen, werden oft als „Setter“ bezeichnet. Die neuen Methoden werden in folgendem Fall verwendet:

public static void main(String[] args) {
    Person matti = new Person("Matti");
    Person juhana = new Person("Juhana");

    matti.setHeight(180);
    matti.setWeight(86);

    juhana.setHeight(175);
    juhana.setWeight(64);

    System.out.println(matti.getName() + ", body mass index is " + matti.bodyMassIndex());
    System.out.println(juhana.getName() + ", body mass index is " + juhana.bodyMassIndex());
}

Die Ausgabe lautet:

Ein Parameter und eine Instanzvariable haben denselben Namen!

Im vorherigen Beispiel setzt die Methode setHeight den Wert des Parameters newHeight auf die Instanzvariable height:

public void setHeight(int newHeight) {
    this.height = newHeight;
}

Der Name des Parameters könnte auch derselbe wie der der Instanzvariablen sein, sodass Folgendes ebenfalls funktionieren würde:

public void setHeight(int height) {
    this.height = height;
}

In diesem Fall bezieht sich height in der Methode speziell auf einen Parameter namens height, und this.height auf eine Instanzvariable mit demselben Namen. Zum Beispiel würde das folgende Beispiel nicht funktionieren, da der Code sich überhaupt nicht auf die Instanzvariable height bezieht. Was der Code in der Praxis bewirkt, ist, dass die empfangene height-Variable als Parameter auf den Wert gesetzt wird, den sie bereits enthält:

public void setHeight(int height) {
    // TUN SIE DAS NICHT!!!
    height = height;
}

public void setHeight(int height) {
    // TUN SIE DAS STATT DESSEN!!!
    this.height = height;
}

Aufrufen einer internen Methode

Das Objekt kann auch seine eigenen Methoden aufrufen. Wenn wir beispielsweise möchten, dass die von toString zurückgegebene Zeichenkettenrepräsentation auch den Body-Mass-Index einer Person angibt, sollte die eigene bodyMassIndex-Methode des Objekts in der toString-Methode aufgerufen werden:

public String toString() {
    return this.name + ", age " + this.age + " years, my body mass index is " + this.bodyMassIndex();
}

Wenn ein Objekt eine interne Methode aufruft, reichen der Name der Methode und das this-Präfix aus. Eine alternative Möglichkeit besteht darin, die eigene Methode des Objekts in der Form bodyMassIndex() aufzurufen, wobei kein Wert darauf gelegt wird, dass die eigene bodyMassIndex-Methode des Objekts aufgerufen wird:

public String toString() {
    return this.name + ", age " + this.age + " years, my body mass index is " + bodyMassIndex();
}