Die Klasse stellt die elementare Datenstruktur in der objektorientierten Programmierung (kurz OOP) dar. Eine Klasse ist im Wesentlichen ein Kontainer, der sowohl Variablen als auch Funktionen enthält. Die Funktionen nennt man Methoden, die Variablen nennt man Eigenschaften (engl. property) oder auch Felder (engl. field), nicht zu verwechseln mit der Datenstruktur Feld (engl. array).
public class BeispielKlasse {
private int wert1, wert2;
public BeispielKlasse() { // ein Konstruktor
wert1 = 7;
wert2 = 125;
}
public int berechneProdukt() { // Instanzmethode
return wert1 * wert2;
}
public int berechneSumme() {
return wert1 + wert2;
}
public void setzeAllesNull() {
wert1 = 0;
wert2 = 0;
}
public static void macheIrgendwas() { // Klassenmethode
System.out.println("Hello World");
// kann nicht auf wert1 oder wert2 zugreifen
}
}
Die Klasse BeispielKlasse
besitzt zwei Eigenschaften und
fünf Methoden. Dabei können die (nicht static
) Methoden
auf die Eigenschaften zugreifen. Was es mit dem static
auf sich
hat wird weiter unten erläutert.
Die Methode, die den Namen der Klasse trägt und keinen Rückgabetyp hat, nennt man Konstruktor. Sie wird verwendet um neue Objekte zu erstellen. Eine Klasse kann mehrere Konstruktoren besitzen, welche sich dann in der Liste ihrer Parameter unterscheiden müssen. Den Namen und die Typen der Parameter nennt man auch Signatur der Methode.
Eine Klasse ist nur ein Datentyp. Um damit vernünftig zu arbeiten, werden Variablen dieses Typs benötigt. Diese nennt man Objekte oder auch Instanzen einer Klasse.
BeispielKlasse obj = new BeispielKlasse();
System.out.println("Produkt = " + obj.berechneProdukt());
System.out.println("Summe = " + obj.berechneSumme());
BeispielKlasse.macheIrgendwas();
Mit new
wird eine neue Instanz der Klasse erstellt. Während
dieser sogenannten Instanziierung, wird der Konstruktor der Klasse aufrufen
(der Aufruf steht hinter dem new
). Die Variable obj
enthält nicht das Objekt, sondern nur eine Referenz darauf (das ist sowas
wie ein Pointer, aber man kann damit arbeiten, als würde die Variable das
Objekt enthalten). Mit Hilfe dieser Referenz können dann die Methoden
aufgerufen werden.
Um die Methoden aufzurufen, die ohne static
deklariert wurden,
wird eine Instanz benötigt. Deshalb heissen diese auch
Instanzmethoden. Die letzte Methode ist als
static
deklariert und kann ohne eine Instanz gestartet werden
(letzte Zeile des Beispiels). Solche heissen deshalb
Klassenmethode. Diese Klassenmethode kann aber
nicht auf die Eigenschaften wert1
und wert2
zugreifen.
Es gibt auch Klasseneigenschaften, d.h. solche, die als static
deklariert wurden.
public class Foo {
public static int a = 0; // Klasseneigenschaft
public int b = 0; // Instanzeigenschaft
public Foo() {}
public void setzen(int wert) { // Instanzmethode
a = wert;
b = wert;
}
public static void setzeA(int wert) { // Klassenmethode
a = wert;
// auf b kein Zugriff
}
}
Die Variable b
existiert lokal in jeder Instanz, die Variable
a
existiert aber nur ein einziges Mal für die gesamte
Klasse, egal wie viele Instanzen man erstellt.
Foo x = new Foo();
Foo y = new Foo();
// Foo.a = 0, x.b = 0, y.b = 0
x.setzen(3);
// Foo.a = 3, x.b = 3, y.b = 0
// y.a ist auch 3, da a nur einmal für die Klasse existiert
Foo.setzeA(1);
// Foo.a = 1, x.b = 3, y.b = 0
x.setzeA(1);
y.setzeA(1);
Da a
als Klassenvariable nur einmal vorhanden ist, würde der
Zugriff auf a
von y
aus nach der
setzen
-Anweisung auch 3
leifern. Die letzten drei
Anweisungen sind identisch. Eine Klassenmethode kann auch von einer Instanz
aus aufgerufen werden. Man sollte aber immer die erste Variante verwenden,
damit sichtbar ist, dass es sich um einen solchen Aufruf handelt.