Klassen

Klassen sind ein Konstrukt in Java, mit dem wir eigene Datentypen definieren können. Wie erläutert, müssen wir um einen Datentyp zu definieren, zwei Dinge festlegen. Erstens welche Werte repräsentiert werden können (die Daten) und zweitens welche Operationen darauf definiert sind.

Wir führen Klassen anhand des Beispiels ein. Sie können sich vorstellen, dass wir zum Beispiel eine Zeichenanwendung schreiben sollen. Dabei kommt es häufig vor, dass wir einen Ort auf einer Ebene bezeichnen wollen. Dann ist es nützlich die x und y Koordinaten gemeinsam in einem Datentyp Punkt speichern zu können. Die x und y Koordinate entspricht so unseren Daten. Zudem wollen wir einen Punkt auf der Ebene um eine angegebene Strecke verschieben können. Dies entspricht einer Operation, die wir auf den Daten ausführen können.

Definition der Klasse​

Um den Datentyp zu definieren, schreiben wir das Schlüsselwort class gefolgt von einem von uns gewählten Namen (hier Point). Der Klassenrumpf, also der Bereich, indem wir den Inhalt der Klasse definieren, wird von geschweifte Klammern umschlossen. Die Definition der Klasse Point, noch ganz ohne Inhalt, sieht wie folgt aus:

class Point {

}

Felder der Klasse​

Die Definition eines Datentyps verlangt, dass wir angeben, welche Daten durch den Datentyp repräsentiert werden können. In unserem Beispiel sind dies die $x$- und $y$-Koordinaten des Punktes. Wir können diese Daten in speziellen Variablen, genannt Felder oder Attribute der Klasse, speichern. Dazu definieren wir diese einfach innerhalb des Klassenrumpfs. Wir wollen jede Koordinate durch eine Gleitkommazahl repräsentieren, deshalb wählen wir den Datentyp double. Generell sind wir in der Wahl des Datentyps für ein Feld aber nicht eingeschränkt.

Unsere Klasse Point, zusammen mit den Feldern, sieht nun wie folgt aus:

class Point {
  double x;
  double y;
}

Erzeugen von Objekten​

Wir können nun bereits Instanzen von dem Datentyp Point erzeugen. Diese werden in Java Objekte genannt. In folgendem Beispiel erzeugen wir zwei Instanzen des Datentyps Point und weisen diese den Variablen point1, respektive point2 zu:

Point p1 = new Point();
Point p2 = new Point();

Da eigene Datentypen Referenzobjekte sind, werden diese mittels des Operators new erzeugt.

Setzen und Lesen der Werte der Felder eines Objekts​

Wir können auf Felder der Objekte zugreifen und deren Wert wie normale Variablen setzen. Dies machen wir, indem wir das Objekt hinschreiben, und, getrennt von einem Punkt, den Name des Feldes. Wir wollen nun dem Punkt p1 die Koordinaten $(0, 0)$ zuweisen. Der Punkt p2 soll hingegen die Koordinaten $(1, 2)$ zugewiesen bekommen. Dazu können wir folgendes schreiben:

p1.x = 0;
p1.y = 0;

p2.x = 1;
p2.y = 2;

Entsprechend können wir die Koordinaten auch wieder lesen und ausgeben:

System.out.println("Punkt 1, x-Koordinate: " + p1.x);
System.out.println("Punkt 1, y-Koordinate: " + p1.y);
System.out.println("Punkt 2, x-Koordinate: " + p2.x);
System.out.println("Punkt 2, y-Koordinate: " + p2.y);

Probieren Sie dies doch gleich selbst aus:

Methoden​

Der zweite Teil einer Definition eines Datentyps sind die Operationen, die wir darauf ausführen können. Diese werden über Methoden definiert.

Wir wollen unserem Datentyp Point eine Operation translate zur Verfügung stellen um diesen zu verschieben. Dabei soll der Punkt um die Strecke dx in x-Richtung und dy in y-Richtung verschoben werden. Wir können dies wie folgt implementieren:

class Point {
  double x; 
  double y;

  public void translate(double dx, double dy) {
    x = x + dx;
    y = y + dy;
  }
}

Die Methode nimmt als Parameter zwei Gleitkommazahlen entgegen und setzt anhand dieser Parameter die Punktkoordinaten dieses Punkts neu. Beachten Sie folgende zwei Dinge:

1. Die Methode darf auf die Felder x und y die innerhalb der Klasse definiert sind zugreifen.
2. Die Methodendefinition entspricht genau dem Muster von Methodendefinitionen, wie wir dies bisher kennengelernt haben, ausser, dass das Schlüsselwort static fehlt.

Um die Methode aufzurufen, nutzen wir die uns bereits bekannte Syntax:

p1.translate(2, 3); // Translates object p1 of type Point

Konstruktoren​

In obigen Codebeispielen haben wir einen Punkt erstellt und haben in einem separaten Schritt die x- und y-Koordinaten gesetzt. Schöner wäre es, könnten wir die Werte für die Felder direkt bei der Erzeugung des Objekts angeben. Um dies zu ermöglichen, können wir einen Konstruktor definieren. Ein Konstruktor ist eine spezielle Methode, die beim Erzeugen des Objekts aufgerufen wird. Die ist immer dann der Fall, wenn wir ein Objekt mit new erstellen. Wir dürfen den Namen eines Konstruktors aber nicht frei wählen. Der Konstruktor muss immer so heissen wie die Klasse. Zudem müssen wir beim Konstruktor keinen Rückgabewert angeben. Um einen Konstruktor für die Klasse Punkt zu definieren, der die x- und y-Koordinate als Parameter entgegennimmt, schreiben wir Folgendes:

class Point {
  double x;
  double y;

  // Definition des Konstruktors
  Point(double xValue, double yValue) {
    x = xValue;
    y = yValue;
  }
}

Wenn wir nun ein Objekt vom Typ Point erzeugen, können wir die zwei Argumente xValue und yValue direkt angeben:

Point p1 = new Point(0, 0);

Probieren Sie doch auch dies direkt aus:

Experimente​

• Schreiben Sie für in der Klasse Point eine Methode print welche dieselbe Art Ausgabe erzeugt wie schon im Code verwendet wird. Ersetzen Sie dann die Ausgaben mithilfe der Methode print.
• Fügen Sie mit System.out.println eine Ausgabe in den Konstruktor hinzu, um zu überprüfen, dass dieser wirklich beim Erzeugen ausgeführt wird.
• Fügen Sie der Klasse Point noch ein Feld label vom Type String hinzu um Punkte benennen zu können. Ergänzen Sie die Methode print, sodass das Label mit ausgegeben wird.
• Erstellen Sie dann zwei Punkte hideout und treasure mit entsprechendem Label und geben Sie diese auf die Konsole aus.

Haben Sie Fragen oder Bemerkungen? Schreiben Sie diese doch ins Forum.