Thema in Kurzform:
Eine Klasse ist ein "Bauplan" für Objekte. Im Klassencode wird beschrieben, welche Eigenschaften und Methoden die Objekte einer Klasse haben sollen.
// Objekt erzeugen
Auto obj = new Auto();Das Grundprinzip: Klassen und Objekte
Es ist in der Tat so, dass das Prinzip der Objektorientierung für viele Java-Anfänger eine Verständnishürde darstellt. Dies mag sicherlich daran liegen, dass die Objektorientierung etwas sehr Abstraktes ist. Auf der anderen Seite jedoch ist sie auch zutiefst logisch und wenn man das Prinzip erst einmal verstanden hat, vergisst man es so schnell nicht wieder.
Die beiden zentralen Begriffe, die man in diesem Zusammenhang draufhaben muss, lauten Klasse und Objekt. Wir erklären das mal anhand eines Beispiels:
Stellen Sie sich vor, Sie möchten ein Rennspiel programmieren. Das Wichtigste, das wir hierzu brauchen, sind natürlich Autos. Alle Autos werden gemeinsame Eigenschaften teilen: Sie haben alle einen Typ, haben alle eine Farbe, eine Motorleistung und Geschwindigkeit. Daneben können Sie auch alle das Gleiche tun: Sie können beschleunigen und bremsen.
Die einzelnen Autos unterscheiden sich aber darin, wie diese gemeinsamen Eigenschaften ausgeprägt sind. So können die Autos ganz verschiedene Typen, Farben, Leistungswerte etc. haben. Bei einer modernen Rennspiel-Simulation wie Forza Motorsport etwa gibt es Hunderte ganz unterschiedliche Fahrzeuge. Aber gleichgültig, ob Sie sich nun einen schwarzen Porsche mit 455PS, einen roten Oldtimer mit 130PS oder sonst irgendein Auto vorstellen: Es sind und bleiben immer Autos.
Übertragen auf die Objektorientierung heißt das: Der Porsche und der Oldtimer sind zwei spezielle Objekte einer gemeinsamen allgemeinen Klasse Auto.
Man muss eine Klasse als einen Bauplan (Blaupause) für Objekte begreifen. Eine Klasse beschreibt nämlich, wie die aus ihr ins Leben gerufenen Objekte gemacht sein sollen. Die erzeugten Objekte (also der Porsche, Oldtimer etc.) stellen dann ganz individuelle Repräsentation der allgemeinen Klasse dar. Sie sind alle Autos, können sich aber hinsichtlich der ausgeprägten Werte voneinander unterscheiden, denn es sind verschiedene, zunächst einmal unabhängig voneinander existierende Objekte.
Aufbau einer Klasse
Nachdem wir uns nun mit den theoretischen Überlegungen rumgeschlagen haben und verstehen, was eine Klasse ist, wollen wir uns jetzt endlich den Code unserer Auto-Klasse anschauen.
Wenn Sie Programmieranfänger sind, dürfen wir Ihnen eine Beruhigungstablette verabreichen: Lassen Sie sich vom Programmcode unten nicht abschrecken - es braucht immer etwas Zeit, um sich an fremden Code zu gewöhnen. Aber je mehr Erfahrung Sie erlangen, desto einfacher wird es Ihnen fallen.
//Start der Klase (Klassenkopf)
public class Auto {
//Instanzvariablen
private String autotyp;
private String farbe;
private int motorleistung;
private int aktuelleGeschwindigkeit;
//Konstruktor
public Auto(String autotyp, String farbe, int motorleistung){
this.autotyp = autotyp;
this.farbe = farbe;
this.motorleistung = motorleistung;
aktuelleGeschwindigkeit = 0;
}
//Methoden
public void beschleunigen(){
System.out.println("Ich beschleunige...");
aktuelleGeschwindigkeit += 30;
}
public void bremsen(){
System.out.println("Ich bremse...");
aktuelleGeschwindigkeit -= 30;
}
public void gibDetails(){
System.out.println("Autotyp: " + autotyp
+", Farbe: " + farbe
+", Motorleistung: " + motorleistung);
System.out.println("Aktuelle Geschwindigkeit: " + aktuelleGeschwindigkeit);
}
}Wie wir sehen, besteht ein Java-Klassen-Code aus insgesamt vier Bestandteilen:
Klassenkopf
Mit dem Klassenkopf beginnt eine jede Klasse. Dieser ist nach folgendem Muster aufgebaut:
public class Auto{
// Inhalt der Klasse
}Der Klassenkopf besteht aus drei Teilen: Einem sog. Modifier (hier: public), dem Schlüsselwort class sowie dem Namen der Klasse (Achtung: Klassennamen werden konventionell immer groß geschrieben!).
Die Modifier zu Beginn dienen dazu, die Sichtbarkeit von Klassen (und anderen Programmelementen) festzulegen. public("öffentlich") bedeutet, dass andere Klassen Zugriff auf die Klasse Auto haben. Das braucht uns jetzt noch nicht zu interessieren. Es wird aber einmal wichtig werden. Deshalb sollten wir jetzt schon einmal davon gehöhrt haben.
Nach dem Klassenkopf kommt schließlich eine geschweifte Klammer {, die den Klassenkörper öffnet. Innerhalb dieses Bereichs wird der gesamte Klassencode geschrieben. Ganz am Ende wird die Klasse mit } geschlossen.
Instanzvariablen
Dieser Teil des Codes bestimmt, welche Eigenschaften die Objekte unsere Klasse haben sollen.
// ...
private String autotyp;
private String farbe;
private int motorleistung;
private int aktuelleGeschwindigkeit;
// ...In unserem Beispiel gibt es insgesamt vier Instanzvariablen, nämlich autotyp, farbe, motorleistung und aktuelleGeschwindigkeit. Es ist ein Muss, den jeweiligen Instanzvariablen beim Deklarieren einen festen Datentyp zuzuweisen.
Vor jeder Instanzvariablen sollte der Modifier private stehen. private bedeutet, dass andere Klassen die Instanzvariablen nicht sehen und verändern können (Kapselung).
Konstruktor
Es folgt als nächster Teil der Klasse der Konstruktor:
public Auto(String autotyp, String farbe, int motorleistung){
this.autotyp = autotyp;
this.farbe = farbe;
this.motorleistung = motorleistung;
aktuelleGeschwindigkeit = 0;
}Ein Konstruktor muss immer so heißen wie die Klasse und sollte den Modifier public haben. Der Körper des Konstruktors, also der Teil, in dem die einzelnen Programm-Anweisungen stehen, beginnt und endet mit geschweiften Klammern { }.
Er hat zwei ganz bedeutsame Aufgaben:
- Konstruktoren ermöglichen es, dass ein Objekt nach seiner Erzeugung in einen gültigen Zustand versetzt wird. Ohne Konstruktoren könnten keine Objekte erzeugt werden. Niemals. Sehen Sie den Konstruktor als spezielle Methode an, die das Objekt ins Leben bringt.
- Wir können in einen Konstruktor außerdem alle möglichen Anweisungen packen. Diese werden dann unmittelbar nach der Objekterzeugung (quasi automatisch) ausgeführt. In unserem Fall werden die drei Instanzvariablen autotyp, farbe und motorleistung mit gültigen Werten initialisiert. Diese Werte wurden zuvor als Argumente dem Konstuktor übergeben. Der vierten Instanzvariable aktuelleGeschwindigkeit wird der Wert 0 zugewiesen. Ein neues Auto steht ja erst einmal und fährt noch nicht. Um es zum Fahren zu bringen, müssen wir zuvor die Methode beschleunigen() aufrufen:
Methoden
public void beschleunigen(){
// Inhalt der Methode (Methodenkörper)
}
// weitere Methoden...Ohne Methoden würden unsere Objekte zwar existieren, aber sie könnten nichts tun. Wenn wir von Methoden sprechen, meinen wir: "Was kann ein Objekt tun?"
Die Klasse Auto hat insgesamt drei Methoden. Die Methoden beschleunigen() und bremsen() erhöhen bzw. verringern den Wert der Instanzvariable aktuelleGeschwindigkeit um jeweils 30. Die Methode gibtDetails() gibt uns die Details zum Auto auf dem Bildschirm aus.
Der Kopf einer Methode besteht aus einem Modifier (hier: public), einem Rückgabetyp (hier: void), dem Namen der Methode sowie einer (hier: leeren) Parameterliste. Es folgt nach der geschweiften Klammer { der Methodenkörper, der einzelne Anweisungen durchführt und mit } endet.
Wir haben hier den ersten Kontakt mit den Konzepten Konstruktor und Methode erhalten. In den nächsten Kapiteln werden wir uns sehr viel ausführlicher damit beschäftigen. Für hier und jetzt muss das Gelernte aber genügen - denn wie heißt es so schön: Einen Schritt nach dem anderen 😉
Objekte erzeugen und benutzen
Es wird Zeit, einige Objekte der Klasse Auto zu erzeugen! Haben wir erst einmal eine Klasse geschrieben, können wir beliebig viele Objekte dieser Klasse ins Leben rufen. Und wann immer wir in Java ein neues Objekt erzeugen - der Fachbegriff hierfür lautet Instanziieren - werden wir dies immer auf die gleiche Art und Weise tun. Da Java objektorientiert ist, ist die Erzeugung von Objekten der Herzschlag dieser Programmiersprache.
Für unsere Auto-Klasse sieht die Anweisung zur Erzeugung eines Objekts musterhaft so aus:
In diesem Code steckt so einiges drin - unter anderen ein neues Objekt ☺️. Gehen wir die Anweisung aber zunächst Schritt für Schritt durch:
Wir erzeugen eine neue Variable namens auto1. Diese Variable verweist dann auf das neu erzeugte Auto-Objekt, das wir mit dem new-Operator ins Leben rufen. Da solche Variablen dann (anders als Variablen, die Werte primitiver Datentypen speichern) auf ein Objekt verweisen (referieren), nennt man sie Referenz-Variablen.
Wichtig ist, dass wir der Variablen einen Typ zuweisen (Variablen-Typ) und auch die Klasse, von der das neue Objekt erstellt wird (Objekt-Typ) muss angegeben werden. Zu unserem jetzigen Programmier-Level sind beide Typen noch identisch. Wie wir später noch sehen werden, ist dies aber häufig nicht der Fall. Wir werden beim Thema Vererbung noch darauf zurückkommen.
Zu guter Letzt müssen wir uns noch um das Zeug in den runden Klammern kümmern - die Parameterliste. Der Konstruktor der Klasse Auto schreibt ja vor, dass wir bei der Objekterzeugung 3 Werte mitgeben müssen. Hier nochmal das Teil:
public Auto(String autotyp, String farbe, int motorleistung){
//Code im Konstruktor (siehe oben)
}Das heißt: Bei der Objekterzeugung von dieser Klasse müssen zwingend zwei Strings und ein int-Wert (und zwar in genau dieser Reihenfolge!) als Argumente übergeben werden! Andernfalls kompiliert der Code nicht.
Doch genug gequatscht. Erstellen wir nun testweise drei Auto-Objekte in unserer IDE und machen anschließend eine kleine Probefahrt mit einem davon:
public class Startklasse {
public static void main(String args[]){
Auto auto1 = new Auto("Porsche", "schwarz", 455);
Auto auto2 = new Auto("Oldtimer", "rot", 130);
Auto auto3 = new Auto("Lamborghini", "weiß", 420);
auto2.beschleunigen();
auto2.beschleunigen();
auto2.beschleunigen();
auto2.gibDetails();
}
}Diesen Code in einer Klasse namens Startklasse.java ausgeführt, erzeugt folgende Konsolenausgabe:
Ich beschleunige...
Ich beschleunige...
Ich beschleunige...
Autotyp: Oldtimer, Farbe: rot, Motorleistung: 130
Aktuelle Geschwindigkeit: 90
Um einem Objekt zu sagen, was es machen soll, benutzen wir einfach den Punkt-Operator nach der Referenzvariablen und anschließend die Methode, die ausgeführt werden soll, also z.B: auto2.beschleunigen();
So eine Spritztour ist doch etwas Feines - und in der Tat dürfen wir gut drauf sein, denn wir haben nicht nur 3 Objekte erzeugt, sondern auf einem davon sogar verschiedene Methoden aufgerufen!
