Inhaltsverzeichnis

1. Anmerkung

2. Was ist Vererbung?

Vererbung ermöglicht in Java das Erweitern von Klassen, ohne diese direkt zu verändern.

Haben wir also beispielsweise eine Klasse programmiert, die wir um neue Attribute und Methoden erweitern möchten, können wir das ab heute umsetzen, ohne unsere Klasse dafür verändern zu müssen.

Was ist der Vorteil an der Vererbung?

Wenn wir eine Klasse bereits vollumfänglich getestet haben und sie bereits im Betrieb eingesetzt wird, ist es ziemlich ärgerlich, bei jeder neuen Änderung die ganze Klasse erneut testen zu müssen.

Aus diesem Grund kommt in Java Vererbung ins Spiel. Damit wir unsere Programme nachträglich problemlos erweitern können, auch wenn sie bereits fertig programmiert sind.

Man kann an dieser Stelle noch weit in die Materie eintauchen, allerdings gehört das zum Thema Software-Design, worauf wir erst in einem anderen Beitrag zu sprechen kommen werden.

Was du dir also merken solltest: Die Vererbung ermöglicht das Erweitern von Klassen.

Welches Grundprinzip steckt hinter der Java Vererbung?

Das Grundprinzip ist, eine neue Klasse zu erstellen, die eine bestehende Klasse erweitern soll. Das macht sie, indem sie alle Attribute und Methoden von der Klasse erbt, die wir erweitern möchten.

Anschließend programmieren wir in die neue Klasse noch zusätzliche Funktionalitäten wie Attribute und/oder Methoden.

Das ist auch schon das ganze Konzept hinter der Vererbung.

Im Moment klingt das womöglich noch sehr abstrakt, zumindest ging es mir damals so, als ich zum ersten Mal von der Vererbung in Java gehört habe. Um das ganze Thema also zu veranschaulichen, sehen wir uns nun mal ein Beispiel in der Praxis an.

3. Die Java Vererbung in der Praxis

Für unser Beispiel habe ich ein neues Projekt angelegt und darin drei Klassen programmiert. Dazu gehört die Klasse Program, die wie gewohnt die Main-Methode enthält.

Darüber hinaus gibt es noch die Klasse Dog:

Sowie die Klasse Cat:

Es existiert damit eine Klasse, die einen Hund repräsentiert und eine weitere Klasse, die eine Katze darstellt.

In der Klasse Dog sehen wir zwei Attribute: eines für den Namen (name) und eines für das Alter (age) des Hundes. Schließlich hat jeder Hund sowohl einen Namen als auch ein Alter.

Außerdem gibt es in der Klasse Hund die Methode sleep, die auf der Konsole den String „Schlafen…“ ausgibt.

Da ein Hund auch bellen kann, finden wir in der Dog-Klasse darüber hinaus die Methode bark, in der wir „Wau wau“ ausgeben lassen.

Im nächsten Schritt werfen wir einen Blick auf die Klasse Cat. Auch darin sehen wir ein Attribut für den Namen sowie ein Attribut für das Alter der Katze:

Hier gibt es ebenfalls die Methode sleep, die exakt den gleichen Zweck hat wie die sleep-Methode der Klasse Dog. Nämlich den, auf der Konsole „Schlafen…“ auszugeben:

Außerdem besitzt die Cat-Klasse noch die Methode purr, die das Schnurren der Katze simulieren soll:

Denn bekanntermaßen bellt eine Katze nicht, sondern schnurrt.

Jetzt fällt dir möglicherweise bereits auf, dass das Ganze hier nicht so optimal gelöst ist. Warum? Weil es sehr viel Redundanz in unserem Code gibt. Redundanz bedeutet in diesem Fall, dass wir die gleichen Attribute und Methoden überflüssigerweise mehrmals im Code eingesetzt haben.

Redundanz ist nie gut, da unser Programm damit fehleranfälliger ist und uns zeigt, dass wir eine bessere Lösung finden können.

Diese bessere Lösung heißt an dieser Stelle: Vererbung.

Was ist an den Klassen Dog und Cat gleich?

Die Attribute String name und int age sind sowohl in der Klasse Dog als auch in der Klasse Cat vertreten. Da sie vollkommen identisch sind, sind sie auch redundant.

Des Weiteren kommt die Methode sleep bei beiden Klassen zum Einsatz, da Hunde und Katzen gleichermaßen schlafen können.

Die einzigen spezifischen Methoden, die sich in beiden Klassen unterscheiden, sind die purr-Methode, die für das Schnurren der Katze verantwortlich ist, sowie die bark-Methode, die den Hund bellen lässt.

Vererbung Schritt 1: Eine neue Klasse erstellen

Um die überflüssigen Wiederholungen im Code entfernen zu können, kommt jetzt die Java Vererbung ins Spiel. Hierzu erstellen wir uns erst mal eine weitere Klasse:

Dieser Klasse geben wir den allgemeineren Namen „Animal“:

Der Klassenname „Animal“ passt deshalb, weil sowohl Hunde als auch Katzen Tiere sind.

Außerdem lässt er bereits vermuten, dass die Klasse allgemeiner gehalten ist als die Klassen Dog und Cat.

Oder anders gesagt: Die Klassen Dog und Cat sind spezifischer als die Klasse Animal, weil sie das jeweilige Tier noch genauer beschreiben. Bei der Klasse Dog wissen wir schon im Vorhinein, dass es sich um einen Hund und nicht um ein x-beliebiges anderes Tier handelt.

Vererbung Schritt 2: Redundanten Code löschen und in der neuen Klasse einsetzen

Die Vererbung hat jetzt folgenden Sinn. Wir können nun alle Attribute und Methoden, die in beiden Klassen gleich sind, kopieren und aus den Klassen Dog und Cat löschen. Anschließend fügen wir diese in der Klasse Animal ein:

Das bedeutet, dass die Klasse Animal nun die Attribute name und age enthält, da jedes Tier einen Namen und ein Alter besitzt. Weil auch jedes Tier schlafen kann, haben wir die sleep-Methode ebenfalls in der Animal-Klasse implementiert.

In der Dog-Klasse ist spezifisch, dass ein Hund noch zusätzlich bellen kann. Wir können die bark-Methode natürlich nicht in die Animal-Klasse programmieren, da schließlich nicht jedes Tier bellen kann. Damit ist die Methode exklusiv Bestandteil der Hunde-Klasse und ergibt auch nur darin tatsächlich Sinn.

An diesem Punkt werden wir die Vererbung herstellen. Wie ich bereits erwähnt habe, können wir mithilfe der Java Vererbung eine Klasse erweitern. Genau das möchten wir jetzt bei der Klasse Animal umsetzen.

Vererbung Schritt 3: Eine bestehende Klasse von der neuen Klasse erben lassen

Animal besitzt zwei Attribute und die sleep-Methode. Wir möchten die Klasse jetzt speziell auf den Hund bezogen um die Methode bark erweitern.

Dadurch bietet sich an, dass wir die Klasse Dog von der Klasse Animal erben lassen. Realisieren können wir das ganz einfach folgendermaßen.

Wir bewegen uns mit dem Cursor neben den Klassennamen „Dog“, ergänzen ein Leerzeichen und schreiben dann „extends“. Dabei handelt es sich um das Schlüsselwort, das wir für die Vererbung benötigen. Anschließend folgt der Name der Klasse, von der die Klasse Dog erben soll. In unserem Fall ist das die Klasse Animal:

Jetzt speichern wir das Programm und haben damit bewirkt, dass die Klasse Dog alle Attribute und Methoden der Animal-Klasse erbt.

Diese sind ab sofort neben der bark-Methode in der Klasse Dog verfügbar.

Wir können nun in der Klasse Program zum Beispiel ein Objekt vom Typ Dog erstellen und im Anschluss die sleep-Methode aufrufen:

Wie wir sehen, erscheint keine Fehlermeldung und beim Ausführen des Programms taucht auch schon der String „Schlafen…“ in der Konsole auf:

Somit funktioniert unser Code!

Wir rufen also auf dem Objekt vom Typ Dog die sleep-Methode auf, obwohl sie in der Dog-Klasse gar nicht definiert wurde. Lediglich die bark-Methode haben wir darin erstellt:

Da aber die Klasse Dog von der Klasse Animal erbt und in dieser die Methode sleep enthalten ist, haben wir die Möglichkeit, sie aufzurufen.

Das ist im Prinzip das ganze Konzept, das sich hinter dem Begriff „Vererbung“ verbirgt. Worauf wir hier allerdings wieder achten müssen, sind die Sichtbarkeitsmodifizierer.

Die Sichtbarkeitsmodifizierer bei der Vererbung

In unserer Animal-Klasse haben wir die Attribute als private deklariert, was bedeutet, dass wir darin Getter und Setter für die Attribute hinzufügen müssen:

Da die gerade erzeugten Getter und Setter wieder public sind, werden diese auch ordnungsgemäß an die Klasse Dog vererbt und wir haben die Möglichkeit, von außen darauf zuzugreifen.

Das heißt, wir können jetzt beispielsweise in der Main-Methode dem Hund einen Namen wie etwa „Bello“ zuweisen und diesen anschließend mit dog.getName() auf der Konsole ausgeben lassen:

Beim Ausführen des Programms wird nun auch „Bello“ ausgegeben:

Die Sichtbarkeitsmodifizierer bleiben damit auch bei der Vererbung aktiv, worauf wir immer achten sollten.

Die Klasse Cat von der Klasse Animal erben lassen

Jetzt können wir uns in die Klasse Cat bewegen und auch dort die Attribute name und age sowie die sleep-Methode herauslöschen. Da auch die Katze ein Tier ist, kann die Klasse Cat ebenfalls mit dem Schlüsselwort extends von der Klasse Animal erben:

Nur die spezifische Methode purr, welche die Klasse Animal noch erweitert, implementieren wir in der Klasse Cat. Jetzt könnten wir in der Main-Methode auch eine Katze erzeugen, die sleep-Methode ausführen und so weiter.

4. Warum die Vererbung so nützlich ist

Wie du siehst, haben wir durch die Animal-Klasse zwar eine Klasse mehr, allerdings ist das Programm dadurch wesentlich besser strukturiert.

Denn es gibt keinen redundanten Code mehr, da jede Funktion nur einmal im Programm definiert ist.

Es steht also nicht in jeder einzelnen Tierklasse String name, int age und die Methode sleep. Und das ist ein großer Vorteil, wenn wir bedenken, dass Klassen sehr groß werden können. Stellen wir uns nur mal vor, die Klasse Cat würde 200 Attribute und 2000 Methoden besitzen. Wenn von den 2000 Methoden nun 1000 für alle Tiere gelten, dann müssen wir diese jetzt nicht in jeder Klasse schreiben, sondern definieren stattdessen mit der Klasse Animal eine sogenannte Elternklasse.

5. Was sind Eltern- und Kindklassen?

Damit habe ich auch schon einen von mehreren wichtigen Begriffen genannt, die man beim Thema Vererbung in Java kennen sollte.

Die Klasse Animal, also die Klasse, von der die anderen Klassen erben, bezeichnet man als Super-Klasse oder Eltern-Klasse. Neben diesen Begriffen gibt es noch weitere Synonyme. Welche Bezeichnung du verwenden möchtest, kannst du selbst entscheiden.

Die Klassen, die von einer Klasse erben, nennt man Sub-Klassen oder Kind-Klassen.

Dieses Prinzip der Vererbung lässt sich jetzt immer weiterführen. Wir könnten also neben der Klasse Dog noch spezifischere Klassen bauen, wie zum Beispiel eine Klasse Labrador und eine Klasse Schäferhund, die dann wiederum von der Klasse Dog erben.

Für diese beiden neuen Klassen ist dann die Klasse Dog die Super-Klasse. Genauso ist die Klasse Labrador, die Kind-Klasse für die Klasse Dog. Letztere hat wiederum die Klasse Animal als Super-Klasse bzw. Elternklasse.

Man bezeichnet das ganze Konstrukt als Vererbungshierarchie.

Das Programm beschränkt sich damit nicht jedes Mal nur auf zwei Ebenen, also auf eine Eltern- und eine Kind-Klasse, sondern lässt sich immer feiner gliedern.

6. Zusammenfassung

Wenn wir in unserem Programm etwas vererben möchten, erstellen wir eine Klasse, von der geerbt werden soll und ergänzen anschließend beliebig viele weitere Klassen, die die Klasse erweitern, von der geerbt wird.

Im Fall unseres Beispiels die Klasse Dog um die Methode bark und dann schreiben wir neben den Klassennamen das Schlüsselwort extends und den Namen der Klasse, von der geerbt werden soll. Den Rest erledigt Java intern für uns.

Die Vererbung steht uns als unheimlich mächtiges Feature zur Verfügung, mit welchem sich natürlich auch noch viele weitere nützliche Dinge umsetzen lassen. In diesem Beitrag sollte es allerdings erst mal darum gehen, ein Grundverständnis zum Thema Vererbung zu erlangen.

An dieser Stelle sind wir auch schon am Ende des Crashkurses angekommen! Es hat mir sehr viel Spaß gemacht, deinen Weg in die Programmiersprache Java zu begleiten und ich hoffe, dass dir dadurch der Einstieg deutlich erleichtert wurde.

Inhaltsverzeichnis

1. Rückblick auf unser Praxisbeispiel

Die Klasse Car

Die Klasse Program

Wie bereits erwähnt, werden wir im heutigen Blogartikel in Java Methoden überladen. Damit du verstehen kannst, was es damit auf sich hat, sehen wir uns das Ganze nun mal anhand der drive-Methode an.

2. Der drive-Methode einen Parameter übergeben

In der drive-Methode geben wir aktuell lediglich den Satz „das Auto fährt“ aus:

Genauso könnten wir darin einen Integer Wert übergeben, den wir „speed“ nennen und womit sich zusätzlich angeben lässt, wie schnell das Auto fährt:

Anschließend bewegen wir uns zurück in unser Programm und speichern dieses. Unter der Zeile, in der wir unser Objekt mit den Werten „Grün“, „VW“ und „130“ instanziieren, schreiben wir die folgende Zeile:

Jetzt benötigen wir noch einen Parameter zwischen dem runden Klammerpaar. Das Programm erwartet darin einen Integer-Wert für den Speed. Beispielhaft übergeben wir darin 30, was bedeuten soll, dass das Auto 30 km/h fährt.

Beim Ausführen des Programms sehen wir in der Konsole, dass das Auto 30 km/h fährt:

Bis zu diesem Punkt ist das für uns noch nichts Neues. Jetzt könnte es allerdings sein, dass wir dem Benutzer ermöglichen möchten, direkt einen Wert mitzuübergeben, wodurch er sich unmittelbar die Geschwindigkeit ausgeben lassen könnte. Oder aber, dass wir ihm die Gelegenheit bieten möchten, die drive-Methode ohne Parameter aufzurufen, wenn er zum aktuellen Zeitpunkt noch nicht weiß, wie schnell das Auto fährt.

Das war bisher allerdings nicht machbar, weil wir wissen, dass man einen Methodennamen nur einmal vergeben kann, da der Computer sonst nicht wüsste, was er ausführen soll. Genau hier kommen wir auf das eigentliche Thema dieses Artikels zurück: Methoden überladen.

3. So kann man in Java Methoden überladen

Dafür kopieren wir zunächst die drive-Methode und fügen diese direkt darunter noch einmal ein:

Jetzt zeigt uns das Programm auch schon einen Fehler an:

Duplicate method drive(int) in type Car

Diese Meldung möchte uns mitteilen, dass wir die gleiche Methode fälschlicherweise doppelt verwenden. Wenn wir diese Methode allerdings überladen, indem wir in der kopierten Version den Parameter speed entfernen und die println-Methode ändern, ist der Fehler auch schon verschwunden:

Das liegt daran, dass der Computer nicht nur Methodennamen unterscheidet, welche in unserem Beispiel offensichtlich gleich sind, sondern auch die sogenannte Signatur.

4. Was ist eine Signatur?

Bei der Signatur handelt es sich um die Übergabeparameter, die wir in einer speziellen Reihenfolge übergeben. Der Computer kann darin die Datentypen erkennen, was konkret bedeutet:

Er sieht, dass eine Methode namens drive existiert, in der ein Integer übergeben wird und eine weitere Methode drive, in welcher wir nichts übergeben.

Aus diesem Grund können beide drive-Methoden gleichzeitig bestehen. Wenn wir also beispielsweise die drive-Methode in der Main-Methode aufrufen und den Integer-Wert 30 übergeben, weiß der Computer, dass es sich um die obenstehende drive-Methode handelt, weil darin ein Parameter erwartet wird. Somit führt er deren println-Methode aus:

Löschen wir den Parameter allerdings wieder, weil wir beispielsweise nicht wissen, wie schnell das Auto fährt und führen das Programm aus, sehen wir lediglich „das Auto fährt...“ in der Konsole:

Diesmal wurde also die andere drive-Methode ausgeführt:

Auf diese Weise haben wir die Möglichkeit, nach Belieben unsere Java Methoden zu überladen.

Die Parameterliste in der Signatur ändern

Das bedeutet, dass wir die zweite drive-Methode auch nochmals kopieren und darunter einfügen können:

So sollten wir unser Programm natürlich nicht stehen lassen, da beide Methoden noch die gleiche Signatur besitzen, nämlich keine Parameter. Zwischen die Klammern „int speed“ zu schreiben wäre ebenfalls nicht machbar, weil die Signatur unserer dritten drive-Methode dann mit der ersten drive-Methode übereinstimmen würde. Sie hätten demnach sowohl den gleichen Methodennamen als auch den gleichen Parameter.

Was wir an dieser Stelle noch tun könnten, um einen Unterschied hinzuzufügen, ist Folgendes. Wir übergeben beispielhaft neben dem Integer speed noch einen String mit dem Namen des Fahrers:

Auf diese Weise würde der Code wieder funktionieren. Wir haben damit also die Möglichkeit, unser Programm vielseitig zu gestalten und dem Client, der die Klasse verwendet, verschiedene Möglichkeiten zu bieten, eine Methode zu benutzen.

Wenn er weiß, wie schnell das Auto fährt, kann er die Zahlen direkt mit übergeben. Weiß der Client das hingegen nicht, soll er die Möglichkeit haben, die Methode aufzurufen, auch ohne einen Parameter beim Aufruf mit übergeben zu müssen:

Ist der Name des Fahrers noch wichtig, soll der Nutzer einfach die Methode aufrufen, in der zudem der Name des Fahrers mit übergeben wird. 

Intern wird dieser Name dann entsprechend verarbeitet, je nachdem, was wir im Code dafür vorgesehen haben.

Das ist auch schon das ganze Geheimnis, das hinter dem Überladen von Methoden steckt!

5. Den Konstruktor überladen

Im vergangenen Beitrag haben wir den Konstruktor kennengelernt, welcher im Prinzip nichts anderes als eine Methode ist:

Das bedeutet, dass wir auch den Konstruktor überladen können!

Um das zu veranschaulichen, werden wir uns an dieser Stelle einen Konstruktor erstellen, dem wir keine Parameter übergeben:

Wie wir sehen, unterscheiden sich die Signaturen der beiden Konstruktoren. In einem Konstruktor übergeben wir drei Parameter, im anderen hingegen keinen. Wir können nun beispielsweise in unserem zweiten Konstruktor eine println-Methode ergänzen:

Anschließend rufen wir diesen Konstruktor im Programm auf und stellen fest, dass sich dieses problemlos ausführen lässt.

So funktioniert also das Überladen von Konstruktoren. Wir können sowohl normale Java Methoden überladen als auch statische Methoden und Konstruktoren. Auf diese Weise lässt sich das eigene Programm deutlich flexibler gestalten.

6. Inwiefern müssen sich Signaturen unterscheiden?

Was zu guter Letzt noch klargestellt werden muss, ist, dass sich die Signatur nicht nur auf die Anzahl der Parameter bezieht. Wir könnten also beispielsweise auch in den Klammern unseres ursprünglich parameterlosen Konstruktors drei Parameter übergeben:

Und wie wir sehen, würde das Programm immer noch funktionieren, obwohl sich jetzt bei beiden Konstruktoren drei Parameter in der Signatur befinden:

Wo liegt also der Unterschied? Die Signatur bezieht sich speziell auf die Typen sowie die Reihenfolge. Das heißt, der Computer erkennt, dass wir gerade drei Parameter übergeben haben, die alle jeweils vom Typ String sind.

Beim anderen Konstruktor erkennt er, dass erst zwei Strings angegeben sind und anschließend ein Integer folgt:

Aus diesem Grund kann der Computer sie eindeutig voneinander unterscheiden und das Programm funktioniert.

Inhaltsverzeichnis

1. Was ist ein Java Konstruktor?

2. Wofür braucht man einen Konstruktor?

Der Java Konstruktor wird meistens dazu verwendet, um Attribute zu initialisieren. Wenn wir also ein Objekt instanziieren möchten, gehört dazu eine Klasse, die gewisse Attribute dieses Objekts vorgibt.

Dabei ist es sinnvoll, den Attributen schon zu Beginn, also beim Erstellen einer Instanz, Werte zuzuweisen. Dadurch müssen wir nämlich nicht erst das Objekt erstellen und anschließend mit den Set-Methoden alle Werte einzeln setzen, was sich ziemlich aufwendig gestaltet.

Mithilfe des Konstruktors lässt sich das Ganze beschleunigen. Das bedeutet so gesehen, dass der Konstruktor ein Objekt vorbereitet. Die Aufgabe des Konstruktors ist also, wie der Name schon verrät, Objekte zu konstruieren.

Damit sorgt die spezielle Konstruktor-Methode dafür, dass ein Objekt konstruiert wird. Wie bereits erwähnt, hat jede Klasse einen Konstruktor.

Um das Ganze nun mal in der Praxis zu verdeutlichen, bewegen wir uns direkt in die Entwicklungsumgebung.

3. Der Java Konstruktor in der Praxis

Auf der folgenden Abbildung kannst du das Beispiel erkennen, das wir in den Beiträgen zuvor aufgebaut hatten:

Wir sehen darauf die Klasse Car, von der wir eine Instanz erstellt haben. Die drei Zeilen darunter können wir vorerst löschen. Den Fokus werden wir nämlich erst mal auf die Instanziierung des Objekts legen.

Wie wir sehen, haben wir zunächst eine Variable vom Typ Car erstellt und diese car1 genannt. Anschließend kam der new-Operator zum Einsatz, den wir immer beim Erzeugen von Objekten verwenden. Danach haben wir die Methode Car() aufgerufen.

Dass wir es dabei mit einer Methode zu tun haben, lässt sich an den Klammern erkennen, die typisch für Methodenaufrufe sind. Genauer gesagt handelt es sich hierbei tatsächlich um den Konstruktoraufruf.

Wir rufen also mit dem Namen der Klasse gefolgt von einem Klammerpaar den Konstruktor der Klasse Car auf. Dadurch wird das ganze Objekt einmal konstruiert.

Wenn wir ein Objekt erzeugen, besitzt dieses alle Attribute, die allerdings nicht jeweils mit einem Wert vorbelegt sind. Das liegt daran, dass wir einen Standard-Konstruktor aufgerufen haben.

Wie ich bereits erwähnt habe, besitzt jede Klasse automatisch einen Konstruktor.

Der Standard-Konstruktor

Definiert man keinen Konstruktor, dann existiert lediglich der Standard-Konstruktor. Dieser sieht im Prinzip folgendermaßen aus:

Man beginnt mit einem Sichtbarkeitsmodifizierer, der beim Standard-Konstruktor public ist. Danach folgt der Name der Klasse und ein rundes Klammerpaar. Darunter setzt man einen Codeblock.

Da es sich um den Standard-Konstruktor handelt, wird in diesem nichts ausgeführt.

Wir haben damit den Standard-Konstruktor einmal explizit definiert. Beim Ausführen des Programms bleibt noch alles beim Alten und wir sehen natürlich nichts.

Der Grund, weshalb keine Änderung eingetreten ist, ist der, dass das Programm den Konstruktor ohnehin aufruft, wenn man keinen eigenen definiert.

Vorhin habe ich erwähnt, dass man einen Konstruktor dazu verwendet, um beispielsweise Attribute mit Werten vorzubelegen. Genau das werden wir jetzt einmal tun.

Mithilfe des Konstruktors Werte vorbelegen

Das bedeutet, wir können in den Klammern Parameter übergeben, so wie wir es bereits von den Methoden kennen.

Dafür wählen wir einen Parameter vom Typ String mit dem Namen color, einen weiteren Parameter vom Typ String namens brand und einen Parameter vom Typ Integer namens horsePower:

In den Codeblock schreiben wir folgendes:

Damit rufen wir den Konstruktor auf und übergeben direkt beim Aufruf, der in der Main-Methode stattfindet, die entsprechenden Parameter zwischen den Klammern:

Die Attribute des Objekts werden dann mit den Werten, die wir übergeben, vorbelegt.

Was jetzt allerdings etwas merkwürdig aussieht ist, dass sowohl das Attribut als auch der Parameter „color“ heißen und wir die Zeile „color = color“ schreiben:

Hier stellt sich die Frage, woher der Computer wissen soll, worauf wir uns beziehen. Meinen wir das Attribut oder doch den Parameter? Fest steht: Der Computer kann die beiden Wörter auf diese Weise tatsächlich nicht unterscheiden.

Aus diesem Grund müssen wir das erste „color“ so kennzeichnen, dass er weiß, dass es sich dabei um das Attribut des Objekts handelt.

Das setzt man in Java mit dem Schlüsselwort this um.

Das Schlüsselwort this

Mit this erstellen wir eine Referenz auf das Objekt selbst. Das heißt, dass wir uns mit diesem Schlüsselwort auf das Objekt beziehen, das den Konstruktor aufruft.

Nach dem this folgt ein Punkt und anschließend das Attribut color:

Damit ist dem Computer klar: Mit dem Aufruf this.color ist das Attribut gemeint, wohingegen das Wort color hinter dem =-Zeichen den Parameter darstellt, der uns übergeben wird. Das sieht man bei Konstruktoren immer.

Wir können also auch noch vor den Attributen brand und horsePower das Schlüsselwort ergänzen:

Bei gewöhnlichen Methoden setzen wir das im Übrigen genauso um. Das heißt, wenn wir bei Methoden Parameter übergeben, die die gleichen Namen wie die Attribute besitzen, können wir auch dort mit this arbeiten. So haben wir die Möglichkeit, dem Computer verständlich zu kommunizieren, was zu tun ist.

Die Fehlermeldung "The constructor is undefined"

Wenn wir jetzt das Ganze speichern und uns zurück ins Programm begeben, werden wir auch schon direkt von einer Fehlermeldung begrüßt:

„The constructor Car() is undefined“.

Woran liegt das, wenn es vorher doch noch funktioniert hat? Dadurch, dass wir hier selbst einen Konstruktor definiert haben, verschwindet der Standard-Konstruktor, den wir in der Main-Methode aufrufen, automatisch.

Das heißt, sobald wir einen Konstruktor definieren, zählt dieser und der Standard-Konstruktor wird nicht mehr automatisch erzeugt.

Wie wird man die Fehlermeldung los?

Wenn wir die Fehlermeldung loswerden möchten, müssen wir also die entsprechenden Parameter angeben, die vom Konstruktor verlangt werden. Genauso, wie wir es bereits von Methoden kennen.

Wir übergeben also zunächst eine Farbe, wie beispielsweise Grün. Danach übergeben wir eine Brand, für die wir beispielhaft VW wählen. Zu guter Letzt übergeben wir noch den Wert 130 bei der PS-Anzahl.

Jetzt sehen wir auch schon, dass die Fehlermeldung verschwunden ist und können das Programm ohne Probleme ausführen:

Wir haben unten in der Klasse Car noch unsere Get-Methoden definiert, weshalb wir direkt überprüfen können, ob die Werte auch tatsächlich zugewiesen wurden.

Das können wir zum Beispiel mit einer Konsolenausgabe umsetzen, in der wir uns die Farbe ausgeben lassen:

Führen wir das Programm nun aus, erscheint tatsächlich „Grün“ in der Konsole, weil wir den Wert im Konstruktor von Beginn an auf Grün gesetzt haben:

Was können wir im Java Konstruktor noch tun?

Jetzt, nachdem du das Wichtigste zum Java Konstruktor erfahren hast, kannst du diesen jederzeit definieren und nach eigenem Wunsch mit Werten vorbelegen.

Neben dem Vorbelegen von Attributen können wir im Konstruktor auch andere Dinge tun. Zum Beispiel könnten wir vom eigenen Objekt die Methode drive aufrufen:

Wenn wir das Programm jetzt speichern und ausführen, sehen wir „Das Auto fährt…“ in der Konsole, weil direkt im Anschluss an die Erzeugung des Objekts die Methode ausgeführt wird. Danach folgt die Konsolenausgabe der Farbe Grün:

Im Konstruktor kannst du alles Beliebige tun, das direkt beim Erstellen einer Instanz von einer Klasse passieren soll.

4. Zusammenfassung

Ganz wichtig zu wissen ist: Wenn du keinen Konstruktor definierst, gilt der Standard-Konstruktor.

Der Standard-Konstruktor ist ein „leerer“ Konstruktor, der das Objekt lediglich sauber im Programm aufbaut. Darin ist allerdings noch nichts Nützliches vorbereitet, das man verwenden könnte.

Wenn du allerdings Werte vorbelegt haben möchtest, musst du dir selbst einen Konstruktor definieren.

Der Konstruktoraufbau

Der Konstruktoraufbau ist dabei immer gleich: Zuerst wählt man den Sichtbarkeitsmodifizierer, der in der Regel public ist, damit man ihn auch von anderen Klassen aus, wie etwa der Klasse Program, aufrufen kann. Andere Sichtbarkeitsmodifizierer, wie beispielsweise private können an dieser Stelle aber ebenso verwendet werden.

Mit private würde allerdings der Code innerhalb der Program-Klasse nicht mehr funktionieren, weil wir von dort aus nicht auf die Klasse Car zugreifen können. Dadurch bekommen wir allgemein Schwierigkeiten, Objekte zu erstellen, weil wir von nirgendwo darauf Zugriff haben.

Es gibt gewisse Techniken, durch welche sich eine Lösung für dieses Problem finden lässt, aber das ist fortgeschrittenes Wissen, mit dem wir uns jetzt noch nicht beschäftigen werden.

Wir befinden uns noch beim normalen Konstruktor und das bedeutet, wie bereits gesagt: Wir schreiben lediglich den Sichtbarkeitsmodifizierer und den Namen der Klasse. Der Aufbau ist immer gleich.

Dann übergeben wir die gewünschten Parameter und öffnen geschweifte Klammern für einen Codeblock. In diesen schreiben wir unseren Code und damit ist der Konstruktor auch schon definiert.

Du kennst jetzt also auch den Konstruktor und weißt über den Aufbau von Objekten und Klassen Bescheid.

Darüberhinaus hast du gelernt, dass wir mit der Klasse einen Bauplan von dieser definieren, von welchem wir Objekte erzeugen können. Diese Objekte setzen sich aus Attributen und Methoden zusammen. Außerdem gibt es die Sichtbarkeitsmodifizierer, bei welchen wir beachten müssen, was wir von wo aus aufrufen können.

Zu guter Letzt hast du über den Konstruktor gelernt, dass dieser das Objekt konstruiert. Bisher erschien die Zeile rätselhaft, in welcher der new-Operator und der Klassenname aufgetaucht sind. Jetzt weißt du, dass das der Konstruktor ist.

Inhaltsverzeichnis

1. Was wir bereits wissen

2. Was sind Java Attribute?

Man verwendet in Java Attribute, um Klassen zu beschreiben. In unserem Beispiel haben wir bereits gesehen, dass man diese in Form von Variablen definiert, die das Objekt charakterisieren.

Dafür haben wir eine Klasse Car erstellt, welche ein Auto darstellen soll. Eigenschaften, die ein Auto beschreiben, sind beispielsweise dessen Farbe oder PS-Anzahl.

Um es nochmal kurz zu wiederholen: Methoden hingegen sind für die Funktionalität zuständig.

3. Wie unterscheiden sich in Java Attribute von Variablen?

Diese Frage stellt sich, weil wir Attribute schließlich genau wie gewöhnliche Variablen definieren. Der entscheidende Unterschied ist allerdings der Sichtbarkeitsmodifizierer.

Von den Sichtbarkeitsmodifizierern hast du in den vergangenen Beiträgen bereits des Öfteren gelesen, allerdings sind wir noch nicht wirklich auf deren Auswirkung eingegangen. Das werden wir im heutigen Blogartikel nachholen.

4. Die Sichtbarkeitsmodifizierer

Bisher haben wir die Sichtbarkeitsmodifizierer private und public kennengelernt. Diese kommen immer zum Einsatz, wenn wir sauber objektorientiert programmieren möchten. Das bedeutet, dass wir in der Objektorientierung spezifische Klassen erstellen, wie etwa die Klasse Car aus unserem aktuellen Programm.

Ich habe schon erwähnt, dass man darin nur Methoden und Attribute definieren sollte, die sich auch wirklich auf die Klasse Car beziehen. Dazu gehört die Farbe des Autos. Die Farbe eines Hauses, das sich beispielsweise in einem Computerspiel neben dem Auto befindet, gehört hingegen nicht dazu. Diese sollte man als Attribut in der Klasse Haus definieren.

Mithilfe der Klassen stellen wir sicher, dass wir alles sauber voneinander trennen und die Dinge zusammenfassen, die zusammengehören. Dabei sollten wir darauf achten, die Werte wirklich sicher von den anderen Klassen abzuschirmen.

5. Wofür ist der Sichtbarkeitsmodifizierer private?

Mithilfe des Sichtbarkeitsmodifizierers private sorgen wir dafür, dass von außerhalb der Klasse niemand auf dieses Attribut zugreifen kann. Das möchte ich dir an dieser Stelle im Programm demonstrieren.

Auf der Abbildung kannst du die Klasse Car erkennen, in der wir bisher drei Attribute definiert haben. Wie bereits erwähnt, definieren wir Attribute genau wie Variablen und setzen lediglich vor diese noch einen Sichtbarkeitsmodifizierer. Im Fall unseres Beispiels ist dieser private:

Was hat das nun für Auswirkungen? Um das herauszufinden, setzen wir eines der Attribute zunächst einmal auf public.

6. Was bedeutet public in Java?

Das Schlüsselwort public bedeutet, dass man jetzt auch von außerhalb der Klasse auf das Attribut zugreifen kann. Um das zu testen, bewegen wir uns in die Main-Methode, in der wir bereits ein Objekt von der Klasse Car erstellt haben, nämlich car1. Auf diesem werden wir jetzt das Attribut aufrufen, was wiederum genauso umgesetzt wird wie bei einer Methode.

Wir schreiben dafür zunächst den Namen des Objekts, gefolgt von einem Punkt und wählen dann das jeweilige Attribut aus:

Im Fall unseres Beispiels wählen wir das Attribut color und weisen diesem anschließend einen Wert zu. Dieser kann zum Beispiel die Farbe Gelb sein.

Sobald wir den Wert zugewiesen haben, verschwindet auch schon die Fehlermeldung. Wenn wir das Programm nun starten, führt es zunächst nur die Methode aus:

Um das Attribut auf der Konsole auszugeben, schreiben wir die folgende Zeile Code und führen das Programm anschließend aus:

7. Die Auswirkung von private in der Praxis

An dieser Stelle werden wir den Sichtbarkeitsmodifizierer auf private ändern. „private“ bedeutet, dass ausschließlich die Klasse Zugriff auf das Attribut besitzt. Wir können damit also nur innerhalb von dieser Klasse auf das Attribut color zugreifen.

Wenn wir uns die Main-Methode nun mal genauer ansehen, fällt auf, dass sich diese in einer anderen Klasse befindet. Nämlich in der Klasse Program:

Genau aus diesem Grund sehen wir schon die erste Fehlermeldung, sobald wir den Cursor auf das Symbol neben der Zeilennummer 8 bewegen:

„The field Car.color is not visible”

Diese Fehlermeldung sagt aus, dass wir keine Sichtbarkeit besitzen, weil der Sichtbarkeitsmodifizierer private das Attribut abschirmt. Wir können dadurch also nur innerhalb der Klasse Car darauf zugreifen, nicht aber von anderen Klassen aus.

Deshalb funktioniert der Code so nicht mehr. Die drive-Methode hingegen konnten wir problemlos aufrufen, da wir sie auf public gesetzt hatten:

Wir können damit also von außen darauf zugreifen. Setzen wir allerdings auch bei dieser Methode den Sichtbarkeitsmodifizierer auf private und speichern das Programm, funktioniert auch diese nicht mehr. 

Der ganze Sinn, der sich hinter den Sichtbarkeitsmodifizierern verbirgt, ist also, damit zu regeln, wer worauf Zugriff erhält.

8. Warum man in Java Attribute nicht auf public setzen sollte

Bei der objektorientierten Programmierung setzt man in Java Attribute niemals auf public, sofern man sich an einen sauberen Programmierstil halten möchte. Durch public ist nämlich, wie du bereits sehen konntest, jedem Zugriff gewährt, wodurch sich die Werte von überall im Programm aus manipulieren lassen.

Und das ist natürlich extrem gefährlich. Wenn von außen unkontrolliert jegliche Werte in einer Klasse geändert werden, können an anderen Stellen im Programm Probleme auftreten, weil Werte plötzlich anders sind als erwartet.

Aus diesem Grund setzen wir Attribute immer auf private. Sobald du dich den fortgeschrittenen Themen der Java-Programmierung widmest, werden noch weitere Sichtbarkeitsmodifizierer wie beispielsweise protected zum Vorschein kommen.

Damit haben wir den Vorteil, dass das Ganze noch mit vererbt wird. Das Thema Vererbung werden wir auch innerhalb dieser Tutorialreihe noch anschneiden. Die weiteren Themen gehören dann schon zu den fortgeschrittenen Konzepten.

In diesem Crashkurs möchte ich dir die Grundlagen so vermitteln, dass du am Ende mit einem guten Fundament in die Programmierung starten kannst. Wir werden uns also nicht auf jedes einzelne Detail konzentrieren.

9. Wie können wir trotz private noch auf die Attribute zugreifen?

Wenn wir an dieser Stelle wieder zu den Attributen zurückkehren, sehen wir ein Problem. Jetzt, wo wir diese als private definiert haben, um sie sauber zu kapseln, können wir natürlich nicht mehr von außen darauf zugreifen.

Was ist aber, wenn wir beispielsweise die Farbe des Autos ausgeben oder den Wert von HorsePower in der Main-Methode ändern möchten?

In diesem Fall kommen die sogenannten Getter und Setter ins Spiel.

10. Was sind Getter und Setter?

Bei den Gettern und Settern handelt es sich um Hilfsmethoden, die sich immer auf ein Attribut beziehen. Das bedeutet, dass jedes Attribut (Beispiel: color) einen Getter und einen Setter besitzen kann.

Diese Hilfsmethoden definieren wir in der Klasse Car und sie ermöglichen uns, von außen kontrolliert auf die Attribute zuzugreifen.

Es gibt zwei Möglichkeiten, Getter und Setter zu definieren. Entweder wir schreiben die Methode selbst oder wir lassen sie in Eclipse automatisch generieren. Wir entscheiden uns nun für Letzteres.

11. Getter und Setter automatisch generieren lassen

Dafür klicken wir auf „Source“ und anschließend auf „Generate Getters and Setters“:

Im Fenster, das sich daraufhin öffnet, können wir ankreuzen, für welche Attribute wir Getter und Setter erzeugen lassen möchten. Außerdem lassen sich Getter und Setter dort einzeln abwählen:

Damit kannst du auch gerne selbst etwas herumexperimentieren. Im Anschluss klicken wir auf „OK“.

Wie du siehst, hat uns das Programm nun automatisch mehrere Methoden generiert, bei welchen es sich um die Getter und Setter handelt:

Die Methoden sehen immer gleich aus. Es ist eine Konvention, bei der Get-Methode das Wort „get“ zu schreiben und anschließend den Namen des Attributs beginnend mit einem Großbuchstaben anzugeben.

Da wir oben das Attribut color definiert haben, schreiben wir auch in der Get- und Set-Methode direkt nach den Wörtern get und set den Namen color, allerdings wieder mit einem großen Anfangsbuchstaben. Das lässt sich in der Abbildung oben erkennen.

Wie du siehst, haben die Methoden relativ simple Funktionen. Die get-Methode gibt uns beispielsweise einfach das Attribut zurück:

Der set-Methode übergeben wir einen String-Wert von color, die dem Attribut diesen Wert zuweist.

Damit haben wir eine Möglichkeit gefunden, die Kapselung zu umgehen.

12. Mithilfe der get- und set-Methoden Werte zuweisen und ausgeben

Wir können jetzt in der Klasse Program innerhalb der Main-Methode von car1 den Wert von color setzen. Dafür schreiben wir nicht mehr „car1.color =“, sondern stattdessen folgendes:

Wir schreiben also car1.setColor, rufen damit die Methode auf und übergeben darin einen String, wie die Farbe Rot zum Beispiel.

Wenn wir den Wert noch ausgeben lassen möchten, schreiben wir in die println-Methode darunter nicht „car1.color“, sondern „car1.getColor()“:

Führen wir das Programm jetzt aus, sehen wir, dass es funktioniert und „Rot“ ausgegeben wird:

Mit den Gettern und Settern können wir kontrolliert auf das Attribut zugreifen. Kontrolliert deshalb, weil wir innerhalb des Getters beispielsweise auch noch definieren können, was beachtet werden soll und welche möglichen Validierungen es gibt.

Wir könnten also beispielsweise in der Set-Methode noch eine if-Abfrage einbauen und festlegen, dass das Attribut nur gesetzt werden soll, wenn es aus fünf Buchstaben besteht. Oder es soll nur gesetzt werden, wenn es das Wort „Rot“ oder das Wort „Gelb“ ist.

Dort können wir also von innerhalb der Klasse kontrollieren, was zulässig ist. Damit haben wir wieder einen geregelten Rahmen und die Möglichkeit, sauber auf die Attribute zuzugreifen.

13. Zusammenfassung

Zusammengefasst haben wir uns in diesem Beitrag mit dem Sinn hinter Attributen und Sichtbarkeitsmodifizierern beschäftigt und die sogenannten Getter und Setter kennengelernt. Bei Gettern und Settern handelt es sich um Hilfsmethoden, die man entweder selbst schreiben oder von Eclipse automatisch generieren lassen kann. Letzteres funktioniert über „Source“ und „Generate Getters und Setters“.

Du hast damit wieder weitere äußerst wichtige Grundlagen der objektorientierten Programmierung in Java gelernt!

Inhaltsverzeichnis

1. Wie definiert man eine Methode in einer Klasse?

Wir sehen auf dem Bild die Klasse Program, in welcher zwei Methoden definiert sind. Zum einen die statische Main-Methode, bei der es sich um die Haupt-Methode unseres Programms handelt und zum anderen die Methode „multiply“ darunter. Letztere soll zwei übergebene Zahlen miteinander multiplizieren und anschließend das Ergebnis zurückgeben.

In der Main-Methode fangen wir das Ergebnis in einer Variable auf und geben es dann auf der Konsole aus. Wie bereits erwähnt, sind diese Methoden statisch. Statisch deshalb, weil als Schlüsselwort static angegeben ist.

2. Was bedeutet static?

Das Wort „static“ sagt aus, dass die Methode statisch ist, was wiederum bedeutet, dass sie nicht an ein Objekt einer Klasse gebunden ist.

Das heißt, dass wir die Methode definieren und anschließend aufrufen können, ohne zuvor ein Objekt von dieser Klasse instanziiert zu haben.

Um es noch einmal zu verdeutlichen: Wir definieren die Methode und können sie einfach aufrufen, obwohl wir noch kein Objekt, in diesem Fall von der Klasse Program, erzeugt haben und das Ganze funktioniert trotzdem.

Die Entwicklungsumgebung zeigt uns auch bereits an, dass die Methode statisch ist, indem sie deren Namen beim Methodenaufruf kursiv schreibt, bevor die Parameter folgen:

Das deutet immer an, dass es sich um eine statische Methode handelt und man letztendlich kein Objekt von einer Klasse benötigt, um die Methode aufrufen zu können.

Jetzt fragst du dich womöglich:

3. In welchem Fall müssen wir ein Objekt erzeugen?

Wir brauchen ein Objekt genau im anderen Fall, nämlich dann, wenn wir eine normale Methode innerhalb einer Klasse definieren. Das werden wir uns in diesem Beitrag mal genauer ansehen.

Auf der folgenden Abbildung siehst du das vorherige Beispiel, in welchem wir eine Klasse namens Car definiert haben. Für diese haben wir bereits Attribute und eine Methode erstellt und anschließend eine Instanz davon erzeugt.

Unter dem Kommentar „//Methoden“ sehen wir bereits eine definierte Methode.

Dabei sehen wir zunächst das Schlüsselwort public, welches den Sichtbarkeitsmodifizierer darstellt. Auf diesen werden wir im nächsten Beitrag ausführlich eingehen.

Danach folgt der Rückgabetyp void und der Methodenname drive. Was bei dieser Methode auffällt: Das Schlüsselwort static fehlt. Da wir static nicht angegeben haben, handelt es sich hierbei um keine statische Methode.

Wie du siehst, ist das Definieren von Methoden in einer Klasse ganz einfach. Wir lassen static weg und schreiben dann den entsprechenden Code. Außerdem ist es bei den Methoden der Klasse Car wichtig, dass sie Funktionalitäten bereitstellen, die zur Klasse Auto passen.

Die Methode drive hat in der Klasse Car ihre Daseinsberechtigung, da schließlich jedes Auto fahren kann.

Eine Methode wie hausBauen() sollten wir darin allerdings nicht definieren, da sie offensichtlich nichts mit der Klasse Car zu tun hat, sondern eher in einer Klasse angebracht wäre, die ein Haus darstellt.

Wichtig:
In einer Klasse sollte nur das gekapselt werden, was relevant für diese und deren Objekte ist. Im Fall unseres Beispiels sind das also nur die Methoden, die auch wirklich etwas mit Autos zu tun haben.

4. Methoden aufrufen

Nun werden wir diese Methode aufrufen. Wir haben uns hierzu bereits ein Objekt von der Klasse Car erstellt. Da es sich bei drive um eine normale Methode handelt, die sich auf die Klasse Car bezieht, können wir diese nur aufrufen, wenn schon eine Instanz dieser Klasse existiert.

Mit car1 haben wir bereits eine Instanz und können demnach die Methode folgendermaßen aufrufen:

Wir geben also erst den Bezeichner car1 an, setzen einen Punkt und können anschließend die drive-Methode auswählen, die wir definiert haben:

Die Methode können wir entweder in der Liste auswählen oder einfach selbst ausschreiben. Wenn wir das Programm nun speichern und ausführen, sehen wir, dass die Methode ausgegeben wird:

5. Zusammenfassung

Zusammengefasst haben wir die Möglichkeit, in Klassen Methoden zu definieren, die sich auf den Zweck einer Klasse beziehen. Im Fall unseres Beispiels, in welchem wir es mit einer Auto-Klasse zu tun haben, also auf den Zweck von Car.

Da ein Auto fahren kann, ergibt die drive-Methode in der Klasse Car durchaus Sinn.

Wir lassen bei dieser Methode das Schlüsselwort static weg, weil sie sich auf einzelne Objekte der Klasse bezieht. Schließlich kann jedes Objekt für sich fahren.

Anschließend rufen wir die Methode auf, indem wir ein Objekt der Klasse erstellen, wie etwa car1 und setzen den Punktoperator gefolgt vom Namen der Methode, die wir aufrufen möchten.

Inhaltsverzeichnis

1. Was ist mit der Praxis?

2. Was versteht man unter OOP?

OOP ist die Abkürzung für "objektorientierte Programmierung", worunter man einen modernen Programmierstil versteht. Der Programmierstil ist deshalb modern, weil er dem menschlichen Denken sehr stark ähnelt.

Beim Blick auf den Begriff „Objektorientierte Programmierung“ stellen wir bereits fest, dass das Thema etwas mit Objekten zu tun haben muss.

Wenn du dich mal kurz im Raum umsiehst, dann wirst du zahlreiche Objekte wahrnehmen. Angenommen du liest diesen Beitrag gerade auf deinem PC-Monitor: Dieser ist nichts anderes als ein Objekt! Aber auch wenn du dir diesen Blogartikel auf einem Handy oder einem Tablet durchliest, hast du es dabei mit einem Objekt zu tun.

Sowohl das Tablet als auch das Handy, die Schreibtischlampe und der Stift sind Objekte.

Die objektorientierte Programmierung mit Java ist so aufgebaut, dass wir auch in unserem Programm mit Objekten hantieren.

Das vereinfacht uns Menschen die Arbeit enorm, da wir in der echten Welt auch ständig von Objekten umgeben sind.

3. Die prozedurale Programmierung

Der Gegensatz zum modernen Programmierstil der Objektorientierung ist die prozedurale Programmierung. Mit diesem Stil entwickelt man Programme zum Beispiel bei der Arbeit mit der Programmiersprache C.

Früher gab es lediglich diesen Stil, der nach und nach durch die Objektorientierung abgelöst wurde. Dabei hat man gemerkt, dass Menschen mit der objektorientierten Programmierung besser arbeiten konnten. Aus diesem Grund sind all die modernen Programmiersprachen wie Java, C# und C++ objektorientiert.

4. Was sind Objekte?

Unter Objekten versteht man beschreibbare Dinge, die zusammenarbeiten können, um zur Problemlösung beizutragen.

Brechen wir diesen Satz einmal auseinander und sehen uns die einzelnen Teile genauer an.

Zum einen haben wir die beschreibbaren Dinge, die auch in der echten Welt existieren. Wir haben beispielsweise einen Stift, den wir beschreiben können. Der Stift hat eine gewisse Form, Farbe und einen bestimmten Hersteller. Damit lässt sich dieses Objekt exakt charakterisieren. Genauso funktioniert die objektorientierte Programmierung mit Java:

Wir bauen Objekte, die wir genau beschreiben können.

Nun sehen wir uns den zweiten Teil des Satzes an: „… die zusammenarbeiten können“.

Dieser sagt aus, dass Objekte innerhalb unseres Programms genau wie in der echten Welt zusammenarbeiten können.

Beispiel

Wir nehmen einen Stift in die Hand, um damit auf ein Blatt Papier zu schreiben. Sowohl das Blatt Papier als auch der Stift sind Objekte. In dem Moment, in dem wir auf das Blatt Papier schreiben, arbeiten diese beiden Objekte gewissermaßen zusammen.

Für den Computer sind wir Menschen in der Hinsicht ebenso Objekte, da wir beim Schreiben mit einem Stift schließlich als „Menschenobjekte“ mit dem „Stift-Objekt“ zusammenarbeiten und der Stift wiederum mit dem Objekt Blatt Papier. Auf diese Weise kann man sich die Zusammenarbeit ganz gut vor Augen führen.

Der letzte Teil des Satzes lautet: „um zur Problemlösung beizutragen“. Das bedeutet, dass du mit jedem Computerprogramm, das du schreibst, ein gewisses Ziel verfolgst. 

Du möchtest in der Regel ein Problem lösen.

Selbst beim Programmieren eines Computerspiels haben wir mit einer Problemlösung zu tun, auch wenn es im ersten Moment gar nicht danach aussieht.

Denn wir müssen uns dabei überlegen, wie wir etwas programmieren, damit es nach unseren Vorstellungen funktioniert. Das kann beispielsweise der Standort des Spielers innerhalb der Welt sein oder das Design eines Levels.

Damit haben wir auch schon die Bedeutung des gesamten Satzes aufgedeckt!

Du solltest dir also folgendes merken:

Objekte sind beschreibbare Dinge, die zusammenarbeiten können, um zur Problemlösung beizutragen.

Da das noch ziemlich abstrakt und wahrscheinlich schwer vorstellbar ist, sehen wir uns an dieser Stelle ein kleines Beispiel an.

5. Die objektorientierte Programmierung mit Java an einem Beispiel erklärt

Stell dir einmal vor, du möchtest ein Videospiel programmieren, in dem es eine Spielfigur gibt. Diese Spielfigur ist ein Objekt, das Eigenschaften und Methoden besitzt.

Beispiele für Eigenschaften:
Die Spielfigur hat Lebenspunkte und einen Namen. Eigenschaften sind also Zustände. Der Spieler besitzt aktuell zwei Leben, was einen Zustand darstellt und auch dessen Name gilt als solcher.

Beispiele für Methoden:
Eine Methode kann beispielsweise „kann sich bewegen“ sein. Wenn sich ein Spieler bewegt, dann tut er etwas, wodurch es sich nicht mehr um einen Zustand handeln kann. Das wird als Methode gehandhabt und auch wenn die Spielfigur stirbt, gilt dieser Prozess als Methode.

Neben dieser Spielfigur existieren außerdem noch weitere Objekte. Zum Beispiel eine Kiste, die auch über Eigenschaften und Methoden verfügt. Eine Eigenschaft davon könnte der verschlossene oder geöffnete Zustand der Kiste sein. Die Kiste ist also entweder verschlossen oder geöffnet – dazwischen gibt es nichts.

In der Programmierung könnte man das mit einem Boolean realisieren. Der geschlossene Zustand würde dabei dem Wert false entsprechen und der geöffnete dem Wert true.

Eine Kiste kann darüber hinaus Items, also Dinge enthalten, wobei es sich wieder um einen Zustand handelt. Den Inhalt der Kiste könnte man beispielsweise mit einem Array modellieren.

Wenn sich also ein Schwert, ein Schild und ein Helm darin befinden, könnte man diese drei Elemente in ein Array schreiben, welches wiederum eine Eigenschaft der Kiste darstellt.

Zudem kann auch eine Kiste Methoden besitzen. Beim Öffnen und Schließen der Kiste interagiert man mit dieser. Diesen Prozess modelliert man mit einer Methode.

An diesem kleinen theoretischen Beispiel kann man erkennen, dass sich ein Computerspiel aus zahlreichen Objekten mit Eigenschaften und Methoden zusammensetzt.

Da wir an dieser Stelle wissen, was Objekte sind, fehlt uns nur noch ein wichtiger Punkt, den wir verstehen müssen:

6. Was ist eine Klasse?

Eine Klasse ist ein Bauplan für ein Objekt. 

Das bedeutet, dass wir eine Klasse definieren und dazu nutzen, um ein Objekt zu beschreiben. Wir verleihen dem Objekt Zustände, also Eigenschaften, indem wir es beschreiben und statten dieses mit Methoden aus.

All das wird in einer Klasse festgehalten und diese fungiert nun als Bauplan. In einem Programm kann man von einer Klasse, also von diesem Bauplan, beliebig viele Objekte erzeugen. Jedes Objekt ist dabei ein eigenes Objekt für sich und kann bei seinen Eigenschaften unterschiedliche Werte annehmen.

Konkret bedeutet das: Wenn du für dein Spiel ein Auto programmieren möchtest, definierst du dafür im ersten Schritt die Klasse, also den Bauplan für dieses Auto. In dieser Klasse legst du gewisse Eigenschaften fest, wie etwa einen Hersteller oder eine Farbe. Alle Dinge, mit welchen du das Objekt letztendlich beschreiben kannst, sind Eigenschaften.

Anschließend legst du noch die Methoden, also die Funktionalitäten des Objekts innerhalb der Klasse fest. Diese soll das Objekt ausführen können.

Möchtest du nun in deinem Programm ein Objekt vom Typ Auto erstellen, dann erzeugst du ein Objekt dieser Klasse. Anders gesagt, erzeugst du das Objekt von dem Bauplan, der dir als Vorlage dient. Jedes der erzeugten Objekte ist dann einzeln für sich und kann damit, wie bereits erwähnt, eigene Werte besitzen.

Was bedeutet das in der Praxis?

Das heißt, du kannst dir von der Klasse Auto beispielsweise fünf Autos erzeugen, die auf dem Spielfeld erscheinen sollen. Anschließend hast du die Möglichkeit, für die einzelnen Autos unterschiedliche Farben festzulegen.

Die Eigenschaften der einzelnen Objekte lassen sich dementsprechend unterschiedlich gestalten. Der Grundaufbau, den die Klasse und damit der Bauplan vorgibt, bleibt bei jedem Objekt dennoch gleich.

Das war das komplette Konzept der Objektorientierung im Schnelldurchlauf!

Damit solltest du nun ein ungefähres Gefühl dafür haben, wie die objektorientierte Programmierung mit Java funktioniert und welcher Sinn sich dahinter verbirgt.

Auf unserem YouTube-Kanal haben wir noch ein gesondertes Video, in dem wir im Detail und anhand von Grafiken erklären, was die objektorientierte Programmierung ist. Dieses bezieht sich auf keine Programmiersprache, sondern ist sehr allgemein gestaltet. Wenn du das Thema Objektorientierung also wirklich verstehen möchtest, lohnt es sich, einen Blick darauf zu werfen. Danach hast du das Konzept mit hoher Wahrscheinlichkeit verstanden.

In den kommenden Beiträgen werden wir die objektorientierte Programmierung mit Java in der Praxis angehen. Wir werden uns also ab dem nächsten Blogartikel wieder in die Entwicklungsumgebung begeben und uns ansehen, wie wir die Theorie des heutigen Beitrags in der Praxis umsetzen können.

Inhaltsverzeichnis

1. Was ist ein Rückgabewert?

2. Die Methode ohne Rückgabewert

Auf der folgenden Abbildung ist das Beispiel des vorherigen Beitrags geöffnet:

Dort ist unsere doSomething-Methode, die keinen Rückgabewert besitzt. Das kann man am Schlüsselwort „void“ erkennen, welches für die Abwesenheit eines Rückgabewertes steht.

Wir übergeben dieser Methode zwei Parameter vom Typ Integer und das Programm lädt diese in die Variablen int x und int y. Anschließend rechnet es die Werte der Variablen zusammen, speichert diese in result und gibt das Ergebnis dann auf der Konsole aus.

Im nächsten Schritt werden wir die Methode noch etwas verkürzen. Da das Programm die Werte 20 und 20 direkt in die Variablen number1 und number2 lädt, ist es nicht notwendig, diese in den Variablen x und y zwischenzuspeichern. Das heißt, wir können die beiden Zeilen löschen und das x durch number1 sowie das y durch number2 ersetzen.

Damit sparen wir uns schon mal eine Zeile Code. Alternativ könnten wir auch number1 und number2 direkt in die println-Methode kopieren, anstatt das Ergebnis in result zu speichern. In diesem Fall würde tatsächlich nur eine Zeile Code genügen, um das Ganze auszuführen. Wir lassen den Code jetzt allerdings so stehen, wie er aktuell ist.

Momentan geschieht darin folgendes:

Wir übergeben die Werte, das Programm rechnet das Ergebnis zusammen und gibt es dann auf der Konsole aus.

Doch was ist, wenn wir das Ergebnis, das die doSomething-Methode liefert, in der Main-Methode noch mal benötigen?

Wenn wir unsere Methode in der Main-Methode aufrufen und wir mit dem Ergebnis, das zurückgegeben wird, an dieser Stelle weiterarbeiten möchten, kommen Rückgabewerte ins Spiel.

3. Methoden mit Rückgabewert

Im Prinzip ist es gar nicht mal so kompliziert, was wir hierfür noch ergänzen müssen. Zuerst ändern wir void in den Datentyp um, den unsere Methode zurückgeben soll. Aktuell rechnen wir zwei Integerwerte zusammen und geben das Ergebnis result auf der Konsole aus. Da das Ergebnis result also ein Integerwert ist und wir dieses von der Methode zurückgeben lassen möchten, schreiben wir anstelle von void int:

Damit weiß der Computer, dass diese Methode einen Rückgabewert vom Typ Integer zurückgeben wird. Allerdings ist im Moment noch eine Fehlermeldung zu sehen:

Das Schlüsselwort return

Der Grund dafür liegt darin, dass wir noch nichts zurückgeben. An dieser Stelle löschen wir zunächst die Zeile mit der println-Methode:

Stattdessen werden wir von unserer Methode den Wert der Variable result zurückgeben lassen. Dazu verwenden wir das Schlüsselwort return.

Wenn wir nach return noch das Wort result ergänzen, ist die Fehlermeldung auch schon verschwunden und das Programm gibt den Wert result zurück:

Führen wir das Programm nun aus, sehen wir allerdings erst mal nichts in der Konsole:

Doch woran liegt das und was geschieht hier überhaupt? Wir rufen die doSomething-Methode auf und übergeben die Werte 20 und 20, die das Programm jeweils in die Variablen number1 und number2 lädt. Anschließend rechnet es die beiden Werte zusammen, speichert das Ergebnis in result und gibt dieses zurück.

Dadurch, dass wir result zurückgeben, kommt das Ergebnis darin an der Stelle im Programm an, an der wir die Methode aufrufen. Doch momentan verarbeiten wir dieses Ergebnis noch nicht.

Das heißt, es erreicht zwar den Methodenaufruf, allerdings stellen wir damit nichts an.

Wir könnten den Code in der Main-Methode also umschreiben, indem wir stattdessen eine println-Methode verwenden und innerhalb dieser unsere doSomething-Methode aufrufen:

Es funktioniert nämlich tatsächlich, dass wir innerhalb der println-Methode eine weitere Methode aufrufen. Schließlich wird uns darin ein Wert vom Typ Integer zurückgeliefert und diesen können wir auf der Konsole ausgeben.

Wenn wir das Ganze jetzt also nochmal speichern und ausführen, sehen wir das Ergebnis auf der Konsole:

4. Mit dem Rückgabewert weiterarbeiten

Was auch sein kann ist, dass man den von der doSomething-Methode zurückgegebenen Wert nicht direkt auf der Konsole ausgeben, sondern ihn dauerhaft in der Main-Methode speichern möchte.

Hierzu legen wir eine Variable namens resultFromMethodDoSomething an, der wir den Wert zuweisen können, den wir von der Methode zurückerhalten. Wir rufen dafür einfach die Methode doSomething() auf und müssen dieser noch Werte übergeben. Beispielhaft legen wir dafür 30 und 50 fest:

Mit dieser Zeile Code rufen wir also die Methode auf, wodurch das Programm 30 und 50 zusammenrechnet, was in 80 resultiert. Dieser Wert wird dann der Variable resultFromMethodDoSomething zugewiesen, mit welcher wir anschließend weiterarbeiten können.

Zum Beispiel können wir diese Variable auf der Konsole ausgeben:

Wie wir sehen, erhalten wir 80 in der Konsole:

Natürlich kann man nun auch wie gewohnt mit dieser Variable innerhalb des Codeblocks der Main-Methode arbeiten.

Verschiedene Datentypen für Methoden mit Rückgabewert

Das, was wir in der Methodendefinition mit dem Typ Integer gemacht haben, können wir jetzt mit jedem Datentyp umsetzen:

Anstelle von int wäre es demnach auch möglich, „double“ oder „String“ anzugeben. Die Methode müssen wir dann nur so anpassen, dass bei return sichergestellt ist, dass der zurückgegebene Wert dem jeweiligen Datentyp entspricht.

Wir können an dieser Stelle den Code der doSomething-Methode noch etwas verkürzen, ohne einen Wert in result zwischenspeichern zu müssen. Da wir den Wert ohnehin zurückgeben, können wir den Ausdruck direkt nach return angeben, wodurch wir die Möglichkeit haben, Ausdrücke gleich zurückzugeben:

Das heißt, das Programm wertet zuerst den Ausdruck aus, wodurch wir das Ergebnis erhalten. Dieses wird anschließend zurückgegeben und beim Speichern und Ausführen des Programms sehen wir dann die gleiche Ausgabe in der Konsole:

Inhaltsverzeichnis

1. Wiederholung: Java Klassen und Eigenschaften

2. Methoden in Java

Daneben gibt es Methoden, die in der Klasse definiert und von einem Objekt ausgeführt werden können. Methoden statten Objekte also mit Funktionalitäten aus, wodurch es den Objekten ermöglicht wird, zu handeln.

3. Wofür brauchen wir Objekte?

Mit der Klassendefinition allein können wir in der Praxis noch nichts anfangen.

Wenn man mit der Klasse arbeiten möchte, muss man deshalb zunächst ein Objekt davon erzeugen. 

Dabei können wir von einer Klasse nicht nur ein einziges Objekt erstellen, sondern beliebig viele. Das liegt daran, dass unsere Klasse tatsächlich als mehrfach verwendbarer Bauplan dient.

Jedes Objekt besitzt dabei eigene Attribute und Methoden, die es selbstständig ausführen kann. Wenn wir also beispielsweise drei Objekte einer Klasse Auto erzeugen, ist jedes einzelne Objekt mit eigenen Attributen ausgestattet und kann seine eigenen Methoden ausführen.

So viel zur Theorie. Um das Thema besser verstehen zu können, sehen wir es uns nun mal in der Praxis in unserer Entwicklungsumgebung an.

4. In Java Klassen definieren

Zuerst werden wir hierfür eine Klasse definieren. In Java gibt es die gängige Konvention, jede Klasse eines Programms in ein eigenes File zu schreiben.

Auf dem Bildschirm sehen wir das File Program.java. Dieses enthält bereits die Klasse „Program“:

Ein neues File anlegen

Wenn wir jetzt also eine zusätzliche Klasse erstellen möchten, müssen wir zunächst ein neues File anlegen. Hierzu bewegen wir uns in Eclipse links in den Package-Explorer auf das jeweilige Package. Wir klicken auf „default package“, setzen dann einen Rechtsklick darauf, wählen „New“ aus und klicken anschließend auf „Class“:

Auf diesem Fenster können wir nun verschiedene Daten einstellen. Das ist für uns an dieser Stelle allerdings nicht von Bedeutung, weshalb wir lediglich einen Namen eingeben und ein Auto mithilfe dieser Klasse modellieren werden. Dementsprechend nennen wir die Klasse „Car“:

Wichtig:
Den Anfangsbuchstaben von Klassen schreibt man immer groß. Durch diese Konvention lässt sich später im Programm sofort erkennen, wobei es sich um eine Klasse handelt.

Abschließend klicken wir auf den „Finish“-Button und sehen dann ein neues File in einem separaten Tab geöffnet. Wir können nun zwischen den Tabs hin- und herwechseln und auch im Package-Explorer sehen wir nun zwei Files:

Car.java und Program.java.

Hier hat uns das Programm jetzt schon automatisiert eine Klasse definiert, was durch die Wörter „public class Car“ herbeigeführt wurde. Doch wofür stehen diese Wörter?

Die Schlüsselwörter public und class

Man schreibt zum einen public, gefolgt von dem Schlüsselwort class und vom Namen der Klasse. Danach kommt ein Block. Der Code, den wir in diesen Block schreiben, ist der Inhalt der Klasse.

Das Schlüsselwort public ist ein Sichtbarkeitsmodifizierer. Was diese Sichtbarkeitsmodifizierer bewirken, werden wir uns noch ansehen. Am besten merkst du dir an dieser Stelle, zuerst „public“ und anschließend „class“ zu schreiben. Letzteres verwenden wir, weil wir eine Klasse definieren. Das ist also selbsterklärend.

5. Eigenschaften in Klassen definieren

Ich hatte bereits erwähnt, dass es in Klassen sowohl Attribute bzw. Eigenschaften als auch Methoden gibt. Jetzt werden wir ein Auto modellieren, das bekanntermaßen verschiedene Eigenschaften besitzt. Wir schreiben nun beispielhaft folgendes:

Bei private handelt es sich wieder um einen Sichtbarkeitsmodifizierer, auf den wir ebenfalls später noch eingehen werden.

Jetzt definieren wir eine ganz normale Variable. Dafür schreiben wir „String“ und nennen diese „color“, um darin beispielsweise eine Farbe zu speichern.

Anschließend legen wir ein weiteres Attribut an, das wir „brand“ nennen, um darin die Marke des Autos zu speichern:

Zu guter Letzt erstellen wir ein Attribut namens „horsePower“ mit dem Datentyp Integer, in welchem wir die PS-Zahl speichern werden.

Natürlich könnten wir noch weitere Attribute festlegen, um unser Auto noch genauer zu beschreiben. Das hängt ganz davon ab, welche Daten wir generell von dem jeweiligen Auto benötigen.

6. Methoden definieren

Neben den Attributen gibt es innerhalb der Java Klassen noch die Methoden. Eine Methode könnte beispielsweise drive() sein:

Zur Veranschaulichung definiere ich diese Methode direkt:

In einem anderen Beitrag dieser Tutorial-Reihe haben wir bereits gelernt, was eine Methode ist. In diesem Artikel gibt es nun die Besonderheit, dass wir die Methode mitten in der Klasse definieren und das Schlüsselwort static fehlt:

Das liegt daran, dass es sich hierbei nicht um eine statische Methode handelt. Was das bedeutet, wirst du ebenfalls später lernen. Abgesehen davon setzt sich der Aufbau der Methode so zusammen, wie wir ihn bereits kennen:

public
Der Sichtbarkeitsmodifizierer public, auf den wir noch eingehen werden.

void
Der Rückgabetyp void, der darauf hinweist, dass nichts zurückgegeben wird.

drive()
Der Name der Methode.

Danach folgt der Block, in dem etwas passieren soll. In unserem Fall wird darin lediglich der Satz „Das Auto fährt …“ auf der Konsole ausgegeben.

Wir haben damit eine komplette Klasse mit Attributen und einer Methode definiert:

7. So erzeugt man Objekte von Java Klassen

Jetzt möchten wir mit dieser Klasse natürlich auch etwas anfangen. Nach wie vor startet unser Programm in der Main-Methode und führt deren gesamten Code von oben nach unten aus. Beim Starten des Programms sehen wir, dass trotz dieser Klasse erst mal gar nichts passiert.

Das liegt daran, dass unsere Klasse, wie bereits erwähnt, nur ein Bauplan ist, mit welchem wir allein nichts anfangen können.

Erst müssen wir ein Objekt dieser Klasse erstellen und diesen Vorgang bezeichnet man auch als Instanziierung.

Die Begriffe Instanz und Objekt kann man synonym verwenden. Um nun ein Objekt der Klasse Car zu erstellen, schreiben wir im Code folgendes:

Mit der obenstehenden Zeile haben wir ein Objekt der Klasse Car erzeugt. Sehen wir uns nun mal an, was hier genau passiert ist.

Im vorderen markierten Bereich der Zeile legen wir eine Variable an, in der wir das Objekt vom Typ Car speichern werden.

Das Objekt ist vom Typ Car, was bedeutet, dass Klassen und so wie wir sie benennen, eigene Datentypen repräsentieren.

Es handelt sich dabei allerdings nicht mehr um primitive Datentypen wie etwa Integer oder String, sondern um komplexere Datentypen, die sich aus verschiedenen Komponenten zusammensetzen.

Im Fall unseres Beispiels heißt der Typ Car und die Variable, in der das Objekt gespeichert ist, nennen wir car1. Das Objekt wird jetzt mithilfe des sogenannten new-Operators erzeugt.

Dabei handelt es sich um ein weiteres Schlüsselwort, das du dir merken solltest. Wir schreiben also new, gefolgt vom Namen der Klasse, von der wir ein Objekt erzeugen möchten und einem runden Klammerpaar.

Hierbei haben wir es mit dem sogenannten Konstruktoraufruf zu tun:

Der Konstruktor konstruiert sozusagen die Klasse und erzeugt davon ein Objekt. Darauf werden wir in einem gesonderten Artikel noch genauer eingehen.

In diesem Blogbeitrag ist einfach nur wichtig, dass du verstehst, wie man eine Klasse definiert.

8. Zusammenfassung

Zusammengefasst haben wir die Möglichkeit einer Klasse Attribute sowie Methoden mitzugeben und ohne ein Objekt bzw. eine Instanz der Klasse können wir mit dieser allein erst mal nichts anfangen.

Ein Objekt erzeugt man, indem man das Schlüsselwort new und anschließend den Namen der Klasse schreibt sowie ein rundes Klammerpaar dahinter setzt. Das Ganze wird dann in einer Variable gespeichert, die (in unserem Beispiel) vom Typ Car ist:

Damit sind wir am Ende des heutigen Beitrags angekommen. Bisher haben wir noch nicht wirklich mit unserer Klasse gearbeitet, was daran liegt, dass uns noch etwas Grundwissen dazu fehlt. Dieses wirst du in den kommenden Beiträgen lernen.

Inhaltsverzeichnis

1. Was ist eine Methode?

2. In Java Methoden definieren

Wichtig ist, dass wir unsere eigene Methode nicht in der Main-Methode, sondern unterhalb ihres Codeblocks definieren. Dazu schreiben wir erst mal folgendes:

Auf diese drei Begriffe komme ich gleich noch zu sprechen. Jetzt müssen wir uns einen Namen für unsere Methode überlegen.

Genau wie Variablen haben nämlich auch in Java Methoden Bezeichner, über die wir sie ansprechen können. 

Für unser Beispiel werde ich unsere Methode einfach mal „doSomething“ nennen. Nach dem Bezeichner folgt ein leeres rundes Klammerpaar und anschließend geschweifte Klammern, die einen neuen Block bilden.

In diesen Block können wir ab sofort den Code schreiben, den wir ausführen lassen möchten, wenn wir die Methode doSomething in unserem Programm aufrufen.

Um das Ganze zu veranschaulichen, schreiben wir darin jetzt ein kleines Programm.

Dafür legen wir eine Variable vom Typ Integer an, nennen diese x und speichern darin den Wert 10. Danach erstellen wir eine weitere Variable namens y, der wir den Wert 20 zuweisen. Unter dieser deklarieren wir noch die Variable „result“, in der wir das Ergebnis von x + y speichern werden. Abschließend lassen wir uns dieses auf der Konsole ausgeben:

Wenn wir das Programm so ausführen, sehen wir, dass erst mal gar nichts passiert. Das liegt daran, dass wir diese Methode zwar definiert, aber noch nirgendwo aufgerufen haben.

3. Wie ruft man eine Methode auf?

Wir bewegen uns also in die Main-Methode und rufen unsere eigene Methode dort auf. Vorher und nachher werden wir jeweils testweise eine println-Methode ausgeben lassen, damit wir unsere selbst definierte Methode sauber auf der Konsole sehen können:

Zwischen den beiden println-Methoden rufen wir jetzt doSomething auf. Das funktioniert denkbar einfach, indem wir folgendes schreiben:

Wenn wir das Programm nun erneut ausführen, sehen wir unsere doSomething-Methode in Aktion:

4. So funktioniert unsere Methode

Zunächst gibt uns das Programm „Vor dem Methodenaufruf!“ aus. Dann ruft es die doSomething-Methode auf und arbeitet deren Codeblock von oben nach unten ab.

Dabei wird uns result, also das Ergebnis aus 10 plus 20 ausgegeben, was die Zahl 30 in der Konsole erklärt.

Sobald unsere Methode vollständig abgearbeitet ist, steuert das Programm zurück in die Main-Methode und setzt seine Arbeit unter doSomething() im Code fort.

Dort gibt es noch den String „Nach dem Methodenaufruf!“ aus. Wie man sieht, ist das Ganze gar nicht so schwierig.

5. Der Aufbau von Java Methoden

An dieser Stelle gehen wir mal auf den Aufbau einer Methode ein. In der ersten Zeile sehen wir den Methodenkopf:

Darunter befindet sich der Methodenblock:

Der Methodenblock ist mittlerweile selbsterklärend. Genau wie bei einer if-Anweisung führt das Programm beim Aufruf der Methode den Code aus, der in diesem Block geschrieben steht.

Beim Methodenkopf hingegen wird es schon etwas interessanter. Hier gibt es nämlich drei besondere Schlüsselwörter: public, static und void.

Die beiden Schlüsselwörter „public“ und „static“ beziehen sich auf die Objektorientierung. Da wir beim Thema Objektorientierung allerdings noch nicht angekommen sind, macht es an dieser Stelle wenig Sinn, public und static zu erklären. Wir werden darauf aber natürlich noch innerhalb dieser Tutorial-Reihe in einem gesonderten Blogbeitrag eingehen.

Bis dahin reicht es zu wissen, dass du zu Beginn der Methodendefinition immer public static void angibst.

6. Das Schlüsselwort void

„void“ steht für den Rückgabetyp. Vor den Bezeichner einer Methode schreiben wir den Rückgabewert, welcher einen Datentyp darstellt. So wie es bei Variablen auch der Fall ist.

Wenn wir möchten, dass diese Methode nichts zurückgibt, verwenden wir void.

Der nächste Beitrag wird in Java Methoden mit Rückgabewert behandeln. Bei diesem werden wir das Schlüsselwort void durch einen richtigen Datentyp ersetzen und einen Wert zurückgeben.

Im heutigen Blogartikel behandeln wir lediglich void, welches erkennen lässt, dass eine Methode nichts zurückgibt. Was das genau bedeutet, wird im nächsten Beitrag noch deutlich werden.

7. Alltägliche Methoden

Auch wenn es dir bisher womöglich nicht bewusst gewesen ist, verwenden wir bereits durchgehend in Java Methoden. Zum einen die besondere Main-Methode, welche den Programmablauf steuert und diesen damit vorgibt. Bei dieser Methode handelt es sich aber um einen Sonderfall, auf den wir hier nicht näher eingehen werden.

Du kennst allerdings auch bereits ganz normale Methoden, wie beispielsweise println. Diese haben wir in unserem bisherigen Programm schon zweimal eingesetzt.

Beim Aufrufen von println öffnen wir ein Klammerpaar, wodurch wir erkennen, dass es sich ganz klar um eine Methode handelt. Das „System.out.“ vor println gehört wieder zum Thema Objektorientierung. Warum wir diese beiden Wörter benötigen, wirst du später erfahren.

Hier werden wir uns erst mal ausschließlich auf den Methodenaufruf println() konzentrieren. Der einzige Unterschied, den wir dabei zu unserer selbst definierten Methode haben, ist der, dass wir in die runden Klammern noch etwas hineinschreiben. Nämlich einen sogenannten Parameter.

8. Wofür benötigt man Parameter?

Die println-Methode wurde in einer bestimmten Bibliothek definiert und ist damit automatisch in unser Programm eingebunden. Aus diesem Grund können wir sie problemlos aufrufen.

Zum Zeitpunkt, als diese Methode programmiert wurde, konnte der Programmierer natürlich noch nicht wissen, was wir auf der Konsole konkret ausgeben möchten. Genau deshalb gibt es Parameter.

So können wir in unserem Programm einfach einen Parameter mitgeben, der dann intern im Code der println-Methode verwertet wird. In unserem Fall ist der Parameter der String „nach dem Methodenaufruf!“, welchen das Programm dank dieser Methode auf der Konsole ausgibt.

Darüber hinaus können wir auch für unsere eigens definierte Methode Parameter festlegen, die wir anschließend mitgeben. Genau das werden wir jetzt umsetzen.

Wir wissen, dass wir in unserer Methode doSomething zwei Zahlen zusammenrechnen lassen möchten. Das können wir auf dem folgenden Weg beispielhaft mit den Zahlen 20 und 20 realisieren:

Jetzt zeigt uns das Programm allerdings eine Fehlermeldung an, was wir an der rot gepunkteten Linie unterhalb unseres Methodennamens erkennen:

Das liegt daran, dass diese Methode bisher noch so definiert ist, dass keine Parameter darin erwartet werden:

Wir möchten allerdings Parameter übergeben und das funktioniert selbstverständlich nicht. Das heißt, wir müssen in unserer Methodendefinition auch noch festlegen, welche Parameter in welcher Reihenfolge das Programm zu erwarten hat und das funktioniert wie folgt.

9. So gibt man Parameter in der Methodendefinition an

Wir geben zuerst den Datentyp an und danach einen x-beliebigen Namen. Dieser soll beispielhaft number1 sein und direkt im Anschluss legen wir noch getrennt durch ein Komma einen zweiten Parameter fest. Dieser Parameter soll auch wieder vom Typ Integer sein und number2 heißen.

Jetzt sehen wir auch schon, dass die Fehlermeldung verschwunden ist, weil wir definiert haben, dass zwei Integerwerte erwartet werden und wir diese im Methodenaufruf bereits übergeben.

Wenn wir andersherum die Werte innerhalb des Methodenaufrufs löschen, erhalten wir ebenfalls eine Fehlermeldung:

Das liegt daran, dass wir die Methode ohne Parameter nicht mehr aufrufen können, weil das Programm die beiden Werte zwingend erwartet.

Wenn du dich also dafür entscheidest, musst du sie auch übergeben.

Wir ergänzen dementsprechend wieder die Zahlen 20 und 20 und können dann mit den Bezeichnern, die wir im Kopf der Methodendefinition festgelegt haben, innerhalb der Methode arbeiten.

Das heißt, wir weisen der Variable x nicht den Wert 10 zu, sondern number1 und für die Variable y legen wir nicht den Wert 20 fest, sondern number2:

10. Funktionsweise einer Methode mit Parametern

Wir rufen die Methode auf und übergeben dabei die Werte 20 und 20. Jetzt lädt das Programm die erste 20 in die Variable number1 und die zweite 20 in die Variable number2.

Nun sehen wir, dass number1 an x übergeben wird und number2 an y. Diese Variablen rechnet das Programm dann zusammen und gibt sie aus. Wenn wir das Programm an dieser Stelle ausführen, sollten wir also die Zahl 40 in der Konsole sehen:

Bei den Parametern hat man die Möglichkeit, eine beliebige Anzahl zu übergeben. Man kann also entweder keinen, einen, zwei oder auch hunderte Parameter angeben.

Wichtig ist, sowohl den Datentyp als auch den Bezeichner festzulegen, mit dem man anschließend intern in der Methode arbeiten kann.

Beim Aufrufen der Methode übergibt man die konkreten Werte in der Reihenfolge, in der man sie auch definiert hat.

Das ist im Grunde alles, was du zu den Java Methoden aktuell wissen solltest. Im nächsten Beitrag wirst du lernen, was es mit dem Rückgabetyp auf sich hat.

Inhaltsverzeichnis

1. Was ist ein mehrdimensionales Array?

Auf der Abbildung erkennen wir ein gewöhnliches Array, das man sich wie eine Liste mit einer gewissen Reihenfolge vorstellen kann. Die 0 zwischen den Klammern soll das Feld repräsentieren, auf welchem ein Wert gespeichert ist. Man kann diesen Wert, welcher gleichzeitig das erste Element des Arrays darstellt, über den Index 0 ansprechen.

Dann folgt Index 1, womit wir das zweite Element des Arrays ansprechen können. Mit Index 2 sprechen wir das dritte Element an und so geht es immer weiter.

Bei mehrdimensionalen Arrays verhält es sich genauso, mit dem Unterschied, dass es bei diesen mehr Dimensionen gibt. Auf der folgenden Skizze eines zweidimensionalen Arrays können wir uns das Ganze mal veranschaulichen.

Beispiel eines zweidimensionalen Arrays

Wie wir sehen, haben wir dort keine Reihe mehr, wie es bei den eindimensionalen Arrays der Fall war, sondern eine Tabelle. Folglich gibt es jetzt auch zwei Indizes, um ein Element sicher identifizieren zu können.

Oben links in der Ecke sehen wir in Klammern 0|0, wobei die orange Null den Index symbolisiert, welcher uns zeigt, in welcher Zeile der Tabelle wir uns befinden. Auch hier fangen wir wieder bei 0 an zu zählen.

Damit hat die erste Zeile den Index 0. Die weiße Null daneben, gibt an, in welcher Spalte der Tabelle wir uns befinden. Auch hier beginnen wir bei null zu zählen und sind damit aktuell in der ersten Spalte.

Ein Feld daneben (0 | 1) befinden wir uns noch immer in der ersten Zeile, weshalb dort auch wieder der Index 0 steht. Die zweite Zahl ist nun die Eins, da wir in der zweiten Spalte sind.

Dieses Schema zieht sich die gesamte Tabelle hindurch. Wenn wir beispielsweise das Element ansprechen möchten, das sich in der dritten Zeile und dritten Spalte befindet, müssen wir in der Tabelle Ausschau nach dem orangen Index 2 halten. Schließlich gibt dieser an, dass wir uns in der dritten Zeile befinden.

Um noch in die dritte Spalte zu gelangen, suchen wir rechts beim Spaltenindex ebenfalls nach der Zahl 2. Diese befindet sich unten in der Mitte, wodurch wir das Element auch schon gefunden haben:

Arrays mit mehr als zwei Dimensionen

Mit mehreren Dimensionen verhält es sich im Grunde genauso. Bei drei Dimensionen haben wir beispielsweise nicht mehr die Form einer Tabelle, sondern die eines dreidimensionalen Würfels.

Auch vier- oder fünfdimensionale Arrays sind im Programm umsetzbar. Da besteht dann allerdings das Problem, dass wir Menschen uns das nicht mehr vorstellen können. In der Regel kommen wir aber ohnehin höchstens mit zweidimensionalen Arrays in Berührung.

Solltest du sehr naturwissenschaftliche Programme schreiben, kann es sein, dass du mehr als eine oder zwei Dimensionen benötigst. Das bildet aber wie gesagt eher die Ausnahme.

Aus diesem Grund werden wir uns jetzt im Praxisteil dieses Beitrags auf ein zweidimensionales Array beschränken. Analog dazu lassen sich dann auch Arrays mit mehr als zwei Dimensionen programmieren.

2. Mehrdimensionale Arrays in der Praxis

Jetzt sehen wir uns das ganze Thema mal in der Praxis anhand einer Tabelle an. Wir möchten ein zweidimensionales Array programmieren und darin logisch zueinander gehörende Vor- und Nachnamen speichern.

Unsere Tabelle wird beispielhaft fünf Zeilen und zwei Spalten haben. Die erste Spalte ist dabei immer für den Vornamen und die zweite Spalte für den Nachnamen einer Person gedacht.

Dass wir hierfür den Datentyp String benötigen, dürfte an diesem Punkt klar sein. Schließlich möchten wir Namen speichern.

Bei den eindimensionalen Arrays war es bisher so, dass wir ein eckiges Klammerpaar hinter den Datentyp beim Erstellen eines Arrays setzen mussten.

Wenn wir mit zweidimensionalen Arrays arbeiten, benötigen wir zwei eckige Klammerpaare, da wir noch einen zusätzlichen Index verwenden. Anschließend folgt wie gewohnt der Bezeichner des Arrays. Wir wählen dafür beispielhaft „firstAndLastName“ und setzen die Zeile folgendermaßen fort:

Da auch mehrdimensionale Arrays eine feste Größe besitzen, habe ich diese ebenfalls direkt festgelegt.

Wie bereits anfangs erwähnt, möchten wir fünf Zeilen und zwei Spalten. Eine der Spalten soll für den Vornamen und eine für den Nachnamen genutzt werden. Der erste Index und damit die erste eckige Klammer steht immer für die Zeilen und die zweite eckige Klammer steht für die Spalten.

Dem zweidimensionalen Array Werte zuweisen

Jetzt können wir in der ersten Zeile schon mal den ersten Namen speichern. Das funktioniert wie bei den eindimensionalen Arrays. Dazu schreiben wir erst den Namen des Arrays und anschließend die beiden eckigen Klammern, die für die Zeile und die Spalte stehen. Um das Element zuweisen zu können, das sich in der ersten Zeile und in der ersten Spalte befinden soll, verwenden wir jeweils die Zahl 0. Wir weisen hier beispielhaft den Namen „Franz“ zu:

Danach kopieren wir diese Zeile Code und fügen sie darunter nochmal ein. Nun möchten wir die zweite Spalte der ersten Zeile noch ansprechen. Wir fügen also beim Spaltenindex eine 1 ein und speichern den Nachnamen „Bauer“ darin.

Diesen Vorgang wiederholen wir auch noch bei zwei weiteren Zeilen. Wenn wir diese kopieren und unter dem bisherigen Code einfügen, müssen wir lediglich noch den Zeilenindex ändern. Da wir uns in der zweiten Zeile befinden, tragen wir jeweils den Index 1 ein. Anschließend weisen wir noch den Namen „Felix Huber“ zu:

Für die dritte Zeile benötigen wir Index 2 und darin speichern wir „Fritz Meier“:

3. Wie gibt man mehrdimensionale Arrays auf der Konsole aus?

An dieser Stelle möchten wir uns das Ganze natürlich noch auf der Konsole ausgeben lassen, damit wir sehen, ob es funktioniert hat. Hierfür setzen wir for-Schleifen ein, damit wir uns das Array in einem Zug ausgeben lassen können.

Wir erstellen dafür zunächst eine äußere For-Schleife. Mit einem Kommentar im Code können wir diesen Schritt dokumentieren:

Diese Schleife bezieht sich immer auf den Zeilenindex, der „i“ sein soll. Zusätzlich soll es noch eine innere For-Schleife geben, die sich auf den Spaltenindex bezieht. Wir nennen diesen beispielhaft „j“.

In der Praxis setzen wir das Ganze jetzt folgendermaßen um:

Danach folgt die zweite For-Schleife:

Jetzt, wo wir Zeilen- und Spaltenindex haben, können wir uns das Ganze ausgeben lassen. Dafür schreiben wir in die println-Methode den Namen des Arrays und zwei eckige Klammerpaare, in die wir den Zeilenindex i und den Spaltenindex j setzen. Mit diesen Indizes können wir das Array durchlaufen und ausgeben lassen:

4. Erläuterung des Codes

Um die Grenzen des Arrays nicht zu überschreiten, verwenden wir in den For-Schleifen wieder das length-Attribut.

Bei den eindimensionalen Arrays haben wir den Array-Namen angegeben, einen Punkt gesetzt und anschließend „length“ ergänzt. Damit konnten wir die maximale Länge des Arrays automatisch ermitteln lassen.

Bei den mehrdimensionalen Arrays gibt es zum einen die Index-Reihe für die Zeilen und zum anderen die Index-Reihe für die Spalten.

Um uns die maximale Spaltenanzahl ausgeben zu lassen, schreiben wir den Namen des Arrays, nämlich „firstAndLastName“ und anschließend in einem eckigen Klammerpaar eine Integerzahl, die die Zeile angibt, in der wir uns aktuell befinden. Anschließend lassen wir noch mit .length die maximale Anzahl der Spalten ermitteln, die sich in dieser Zeile befindet.

Da wir mit i über die Zeilen laufen, schreiben wir bei der inneren for-Schleife in das eckige Klammerpaar hinter dem Array-Namen „i“. Damit du das Ganze besser verstehen kannst, führen wir das Programm direkt einmal aus.

In der Ausgabe steht Folgendes:

Wir sehen nun die Werte, die wir in die ersten Zeilen und Spalten gespeichert haben und darüber hinaus viermal „null“. Letzteres wird ausgegeben, weil es noch zwei weitere Zeilen mit jeweils zwei Spalten gibt, in die wir keine Werte geschrieben haben.

5. Die Ausgabe des Arrays übersichtlicher gestalten

Da die Ausgabe noch ziemlich unübersichtlich dargestellt wird und nicht die Form des Arrays im vorherigen Bild zeigt, passen wir den Code noch etwas an. Wir legen also fest, dass kein Zeilenumbruch stattfinden soll, wenn wir die unterschiedlichen Elemente der verschiedenen Spalten ausgeben lassen. Damit am Ende nicht alles zusammenklebt, fügen wir noch eine Leerzeile hinten an.

Nach jeder Zeile, die vollständig ausgegeben wurde, soll dann ein Zeilenumbruch gesetzt werden:

Wenn wir das Programm erneut ausführen, sehen wir die Struktur des zweidimensionalen Arrays perfekt. Dieses hat insgesamt fünf Zeilen und zwei Spalten, wie wir auf der Konsole erkennen können:

Wie bereits am Anfang erwähnt, wirst du in den meisten Fällen höchstens mit zweidimensionalen Arrays in Berührung kommen. In diesem Fall kannst du sie mithilfe der For-Schleife auf der Konsole ausgeben lassen, indem du die Konstruktion der for-Schleifen beachtest.

Bei der äußeren For-Schleife gibst du den Namen des Arrays sowie das length-Attribut an und bei der inneren For-Schleife ergänzt du nach dem Array-Namen ein eckiges Klammerpaar. Darin spezifizierst du die Zeile, von welcher du die Spaltenanzahl ausgeben lassen möchtest.

Die Arbeit mit mehrdimensionalen Arrays unterscheidet sich von der Arbeit mit gewöhnlichen Arrays also insofern, als man ein weiteres eckiges Klammerpaar ergänzen muss.

Wenn du ein dreidimensionales Array erstellen möchtest, setzt du anstatt zwei eckigen Klammerpaaren, einfach drei.

So verhält es sich analog zu allen Dimensionen. Dir sind also keine Grenzen gesetzt und du musst lediglich darauf achten, dass du genügend Speicher hast und vor allem, dass du etwas Sinnvolles damit umsetzen kannst.