Was ist eine Klasse?

Das Klassenkonzept

In der 'realen Welt' besitzt ein Objekt Eigenschaften und Fähigkeiten: Ein Fahrzeug hat z.B. eine Farbe, eine Größe und eine bestimmte Anzahl an Rädern. Es kann beschleunigen, bremsen und der Motor kann laufen oder nicht. Darüber hinaus besteht ein solches Fahrzeug-Objekt aus weiteren Objekten: einem Motor, Rädern, einer Karosserie, etc. Die Räder wiederum bestehen aus einer Felge, dem Reifen, dem Lager, etc. Alle diese Teile besitzen wiederum jeweils spezifische Charakteristika.
Man versucht nun im Rahmen der Objektorientierung, diese Ordnung vom Prinzip her nachzubilden, mit dem Ziel, die komplexe Struktur moderner Softwareprojekte zu beherrschen. Hiezu wird jedem 'Gegenstand' entsprechend eine Klasse als Datentyp definiert, der dessen Eigenschaften und Fähigkeiten als eine Art 'Bauplan' zusammenfasst, von dem dann beliebig viele (virtuelle) Objekte erzeugt werden können. Ganz so, wie in einer Autofabrik viele Autos nach der selben Vorlage gebaut werden.
Bezogen auf obiges Beispiel gäbe es somit jeweils eine Klasse Motor, Rad, Karosserie, etc.

Grundlegender Aufbau einer Klasse

Erzeugt man eine Klasse Fahrzeug, dann kann man nach diesem Bauplan beliebig viele (virtuelle) Fahrzeuge, man sagt Objekte vom Typ Fahrzeug, erzeugen. Jedes dieser Objekte stellte ein individuelles Fahrzeug dar, aber alle besäßen zunächst die selben Charkteristika.

Im einfachsten Fall besteht die Deklaration einer Klasse aus dem Schlüsselwort class und einem Bezeichner, der von einem Codeblock in geschweiften Klammern gefolgt wird.

class Fahrzeug {
}

Eine Eigenschaft jedes Fahrzeugs ist z.B. seine Geschwindigkeit. Man kann sie durch einen einfachen int-Wert erfassen. Sie wird in einer sog. Instanzvariablen gespeichert, einer Variablen, die direkt im Klassenblock deklariert und ggf. auch direkt initialisiert wird.

class Fahrzeug {
    int tempo = 0;
}

Die Geschwindigkeit des Fahrzeugs muss natürlich verändert werden können. Hierzu deklariert man eine Methode, der ein Wert als Parameter übergeben wird. Er wird zur bisherigen Geschwindigkeit addiert und so die Eigenschaft tempo des Fahrzeugs erhöht. Übergibt man hier einen negativen Wert, so wird eine negative Beschleunigung, eine Verzögerung realisiert.

class Fahrzeug {
    int tempo = 0;
    void beschleunige(int mehr) {
        tempo += mehr;
    }
}

Auch wenn die Klasse in dieser Form noch nicht verwendet werden kann¹, so zeigt sie doch den grundlegenden Aufbau:

• Das Schlüsselwort class kennzeichnet die Klassendeklaration.
• Ihr Bezeichner wird mit großem Anfangsbuchstaben geschrieben und folgt dem sog. CamelCase-Aufbau.
• Der Klassenquelltext (Variablen und Methoden) ist in einem Block eingeschlossen, der durch geschweifte Klammern eingegrenzt wird.

Um die Klasse nutzen zu können, muss sie gespeichert werden: Üblicherweise erfolgt die Klassendeklaration in einer Datei, die den Klassenbezeichner als Namen mit der Extension .java trägt, hier also Fahrzeug.java. Soll die Klasse programmweit aufgerufen werden können, muss die Klassendeklaration jedoch den Zugriffsmodifikator public tragen. In diesem Fall müssen dann Klassenbezeichner und Dateibezeichner zwingend identisch sein.

public class Fahrzeug {
    //...
}

In den meisten Fällen sollte jede Klasse in einer separaten Datei notiert sein. Sind zwei oder mehrere Klassen jedoch funktional eng miteinander verbunden, so können sie auch in einer Datei notiert werden. In diesem Fall darf davon nur eine Klasse public sein, nämlich diejenige, deren Name dem Dateinamen entspricht.

Klassensyntax

Wie erwähnt liegt in Javaprogrammen der gesamte Quelltext grundsätzlich in Klassen gegliedert vor, die mit dem Schlüsselwort class und eventuell vorangestellten Zugriffsmodifikatoren gekennzeichnet werden. Dem Bezeichner folgt der in geschweifte Klammern ({}) eingeschlossene Klassenblock. Quelltextanteile außerhalb einer Klassendeklaration extistieren nicht. Die einzigen Ausnahmen hiervon bilden ggf. Package-Angaben, Import-Anweisungen und Kommentare, auf die an dieser Stelle jedoch nicht weiter eingegangen wird:

package de.javabeginners.test;
import java.util.*;
/*
 * Testklasse
 */
class Fahrzeug {
    //...
}

Die Reihenfolge der Codeelemente innerhalb der Klasse ist funktional unerheblich, wird aber durch die Code-Konventionen geregelt.

Objektbildung

Wie oben erwähnt stellt eine Klasse Fahrzeug selbst noch kein Fahrzeug dar, sondern lediglich den entsprechenden Datentyp, ähnlich wie die Klasse String selbst auch noch kein String ist. Nach dem Bauplan einer Klasse müssen vielmehr konkrete Objekte gebildet werden. Diese besitzen dann die Eigenschaften (Variablen) der Klasse, die durch deren Fähigkeiten (Methoden) für jedes Objekt individuell modifiziert werden können.
Die Objektbildung geschieht mit Hilfe des Schlüsselwortes new und der Nennung des Klassennamens, gefolgt von einem Paar runder Klammern.

new Fahrzeug();

Selbstverständlich kann das Objekt auch in einer Variablen gespeichert werden:

Fahrzeug fahrzeug = new Fahrzeug();

An diesem Ausdruck lässt sich folgendes ablesen:

• Die Variable fahrzeug speichert ein Objekt vom neu erzeugten Datentyp Fahrzeug.
• Die Objektbildung scheint durch einen Methodenaufruf zu erfolgen, wie an den Klammern zu erkennen ist. Hier wird in der Tat der Konstruktor der Klasse aufgerufen, eine Methode, die jede Klasse besitzt und die speziell der Objektbildung dient. Näheres hierzu findet sich im Artikel über Konstruktoren.

Das neu erzeugte Objekt kann jetzt verwendet werden. Möchte man auf die o.a. Instanzvariable tempo zugreifen, so kann dies in der einfachsten Form mit Hilfe des Punktoperators erfolgen, indem die gewünschte Variable auf dem neu gebildeten Objekt aufgerufen wird.

Fahrzeug fahrzeug = new Fahrzeug();
System.out.println(fahrzeug.tempo);

Allerdings werden Variablen aus gutem Grund üblicherweise durch Accessor-Methoden angesprochen.
Auch der Zugriff auf die Methoden der Klasse erfolgt mit Hilfe des Punkt-Operators:

Fahrzeug fahrzeug = new Fahrzeug();
fahrzeug.beschleunige(50);
System.out.println(fahrzeug.tempo); // 50

An dieser Stelle muss jedoch beachtet werden, dass die Zugriffe auf Variablen und Methoden durch Zugriffsmodifikatoren eingeschränkt sein können.