Inhalt des Kurses

Dieser Kurs gibt dir einen Einblick in die Programmierung mit Java. Du wirst unter anderem lernen, wie du eigene Objekte erzeugst oder Klassen anlegst. Außerdem erfährst du alles, was du brauchst, um direkt deine eigenen Programme zu schreiben. Dabei erfährst du auch, wie du deinen Code gut strukturierst, sodass du noch nach Wochen weißt, wie dein Programm funktioniert. Durch die Aufgaben, kannst du dein Wissen sofort selbst einschätzen und du siehst, welchen Teil du schon gut kannst und welchen Teil du nochmal wiederholen solltest.

Voraussetzungen

Das einzige, was du brauchst, um diesem Kurs zu folgen, ist ein Computer oder Laptop mit einer Internetverbindung. Dieser Kurs richtet sich vor allem an Anfänger, welche sich für die Programmierung interessieren. Du brauchst also keine Vorkenntnisse um mit dem Kurs zu starten. Solltest du allerdings schon mal in einer anderen Programmiersprache programmiert haben, kommen dir wahrscheinlich einige Prinzipien vertraut vor und du kannst Teile des Kurses überspringen.

Warum Java?

Java ist eine der meistgenutzten objektorientierten Programmiersprachen. Man findet die Sprache auf allen möglichen Geräten, egal ob Desktop, Server, Android, etc. Java bringt durch die Plattformunabhängigkeit einen großen Vorteil mit sich, denn es ist egal auf welchem Gerät du deine Anwendung startest, Java läuft überall. Darüber hinaus ist Java eine sehr beliebte Lehrsprache, eventuell hast du schon in der Schule Kontakt mit Java, aber auch im Informatik Studium wird sie dir mit Sicherheit irgendwann begegnen.

Kursdauer

~ 2-3 Stunden

Bevor es an dein erstes Java Programm geht, musst du noch ein paar Kleinigkeiten erledigen. Denn um mit Java zu programmieren, benötigst du das Java Development Kit (JDK), es enthält die notwendigen Entwicklerwerkzeuge. Zudem brauchst du noch eine Entwicklungsumgebung (IDE), eine IDE stellt dir einige hilfreiche Funktionen zur Verfügung, welche dir die Arbeit mit Java extrem erleichtern können. Schauen wir uns nun kurz den Installationsprozess an.

Und das war es auch schon! Du hast nun alles, was du brauchst, um direkt mit der Java Entwicklung zu starten.

Jetzt bist du so weit. Es wird Zeit, dass du dein erstes Java Programm schreibst. Zunächst musst du dafür Eclipse starten. Du wirst dann gefragt, in welchem Workspace du arbeiten möchtest. Hier kannst du einfach einen Ordner für deine zukünftigen Java Projekte anlegen oder du wählst den Standard Workspace. Danach öffnet sich Eclipse und du landest auf der Willkommensseite. Von hier aus hast du zwei Möglichkeiten ein neues Java Projekt zu erstellen:

Nachdem du dich nun ein wenig mit der Entwicklungsumgebung vertraut gemacht hast, wollen wir nun einen Blick auf Variablen und Datentypen werfen. Solltest du bereits erste Erfahrungen in anderen Programmiersprachen gesammelt haben, wird dir einiges schon bekannt vorkommen.

Variablen werden benutzt, um Daten zwischenzuspeichern. Das Erstellen einer Variable erfolgt in Java immer nach dem gleichen Prinzip:

Mithilfe einer Variable können wir beispielsweise Werte definieren, welche wir zu jedem Zeitpunkt in unserem Programm wieder abrufen können. Schauen wir uns nochmal das erste Programm aus dem vorherigen Abschnitt an, diesmal aber mit einer Variable.

Wie du siehst, wird die Variable verwendet wie ein ganz normaler Text. Der große Vorteil, welchen eine Variable bietet, ist der, dass Änderungen des Variablenwerts sofort im ganzen Programm übernommen werden.

Möchten wir jetzt das Quadrat von zehn, anstelle von neun berechnen, dann müssen wir nur die Zahl in der Variablendeklaration ändern. Die zweite Zeile bleibt, dank der Variablen, unberührt.

Wie dir mit Sicherheit schon aufgefallen ist, haben wir in dem Beispiel unterschiedliche Datentypen verwendet. Im ersten Beispiel haben wir einen String, also eine Zeichenkette, benutzt und in dem zweiten haben wir einen Integer, also eine Ganzzahl, genutzt. In Java gibt es aber noch ein paar mehr Datentypen, die wichtigsten findest du in dieser Tabelle:

Diese Datentypen unterscheiden sich in primitive Datentypen und Objektdatentypen. Wie du bereits gelernt hast, ist die Programmiersprache Java objektorientiert, lediglich wenige primitive Datentypen bilden eine Ausnahme. Diese haben im Gegensatz zu Objektdatentypen keine Eigenschaften oder Funktionen. Du hast bereits beide Arten von Datentypen kennengelernt. Ein String ist ein Objektdatentyp, beispielsweise existiert hier die Funktion length(), welche dir die Länge deiner Zeichenkette zurückgibt. Probieren wir es doch mal mit dem Beispiel aus:

Im Gegensatz zu String, hast du mit int einen primitiven Datentyp kennengelernt. Vielleicht ist dir auch schon ein wichtiger Unterschied aufgefallen: primitive Datentypen (int, float, double, …) werden kleingeschrieben und Objektdatentypen (String) werden großgeschrieben.

Zusammenfassung

• Variablen dienen zum zwischenspeichern von Daten

• Die Deklaration erfolgt nach folgendem Muster: $Datentypvariablenname=Wert;Datentyp\backslash \; variablenname=Wert;$

• In Java gibt es sowohl primitive Datentypen, als auch Objektdatentypen

Nachdem du nun die wichtigsten Datentypen für deine Java-Programme kennst, werfen wir nun einen etwas genaueren Blick auf Arrays. Lass uns gleich mit einem Beispiel starten: nur wenige Leute haben ein einziges T-Shirt, aber wie kannst Du nun deine T-Shirts in Java erfassen? Hier kommen Arrays ins Spiel. Arrays lassen sich am einfachsten als eine Art Liste beschreiben. Die Definition sieht so aus:

Das, was nun noch etwas befremdlich aussieht, lässt sich recht leicht erklären. Zunächst wählst du den Typ, welchen dein Array hat. (int, String, etc.) dann legst du einen Namen für dein Array fest. Nach dem Gleichheitszeichen erfolgt die Definition. Mit $newDatentyp[gr\ddot{o}\text{ß}e];new\; Datentyp[größe];$ legst du erneut den Typ fest und gibst mit der Größe an, wie viele Elemente du speichern möchtest. Schauen wir uns wieder das T-Shirt Beispiel an, wir legen also das Array $tshirtstshirts$ mit einer Größe von 10 an:

Daten im Array speichern

Jetzt fragst du dich mit Sicherheit, wie du nun echte Daten in das Array bekommst, denn bisher hast du nur leere Arrays einer bestimmten Größe erstellt. Um das Array mit Daten zu füllen, gibt es verschiedene Möglichkeiten. Im Folgenden möchte ich dir zwei davon näher vorstellten. In dem Abschnitt zum Thema Schleifen lernst du dann eine weitere Methode kennen, welche dir einige Arbeit abnehmen wird.

Die erste Möglichkeit ist es, das Array direkt bei der Initialisierung mit Daten zu versehen. Schau dir dazu folgende Beispiele an:

Wie du siehst werden die Werte direkt bei dem Erstellen des Arrays, mithilfe von geschweiften Klammern, angegeben. Das hat natürlich den Nachteil, dass du schon beim Initialisieren des Arrays wissen musst, welche genauen Daten du speichern möchtest. Eine weitere Möglichkeit Daten in das Array zu bekommen ist folgende:

In diesem Fall wird zunächst das String-Array $farbenfarben$ definiert. Später greifen wir mithilfe der eckigen Klammern auf die einzelnen Stellen des Arrays zu und weisen den entsprechenden Stellen die gewünschten Werte zu. Wichtig zu wissen ist dabei: Es wird bei null angefangen zu zählen, ein Array mit einer Größe von drei hat also die Stellen: 0, 1, 2 und nicht, wie du es vielleicht gewohnt bist: 1, 2, 3.

Zugriff auf Daten im Array

Diese Möglichkeit hat dir auch gleichzeitig ein weiteres Konzept vorgestellt: Den Zugriff auf einzelne Stellen im Array. Selbstverständlich möchtest du die Daten, welche in einem Array gespeichert sind auch abrufen können.

Wie du siehst ist das Konzept ähnlich simpel, wie die Zuweisung von Daten. In eckigen Klammern schreibst du die Stelle, auf die zuzugreifen möchtest. In der dritten Zeile siehst du, dass Stellen aus dem Array natürlich auch in Variablen gespeichert werden können. Überleg gerne mal welchen Wert die Variable $stelleImArraystelleImArray$ jetzt hat. (Denke daran, dass es bei null anfängt zu zählen). Im nächsten Kapitel lernst du ein weiteres wertvolles Werkzeug der Programmierung, besonders im Umgang mit Arrays kennen: Schleifen.

Zusammenfassung

• In Arrays kannst du mehrere Einträge des gleichen Datentypen speichern

• Du kannst dir ein Array als eine Art Liste vorstellen

• Ein Array wird grundsätzlich nach folgendem Muster erstellt: $Datentyp[]name=newDatentyp[gr\ddot{o}\text{ß}e];Datentyp[]\backslash \; name=new\backslash \; Datentyp[größe];$

• Die erste Stelle im Array hat den index 0

Du kennst nun bereits einige grundlegende Strukturen der Programmiersprache Java. In den folgenden Teilen dieses Kurses soll es nun darum gehen, die bisher gelernten Elemente zusammenzubringen. Als Erstes schauen wir uns dazu in diesem Teil Iterationen an.

Wie du dir vorstellen kannst, ergeben Iterationen immer dann Sinn, wenn du einen bestimmten Teil deines Programms mehrmals ausführen möchtest. Kannst du dir schon ein Beispiel aus deinem täglichen Leben vorstellen? Wie wäre es mit Raum voller Menschen. Die Aufgabe: Jeden der 30 Personen über eine Konsolenausgabe zu grüßen.

Man muss keinen Doktor in Informatik haben, um zu sehen, dass diese Lösung nicht sinnvoll ist. Zum Glück schaffen Iterationen Abhilfe.

Die for-Iteration

Schauen wir uns die Lösung mit einer for-Iteration an:

Wie du siehst, spart uns die Iteration bereits bei diesem kleinen Beispiel einige Zeilen an Code. Schauen wir uns die for-Iteration genauer an, im Besonderen den Bereich zwischen den Klammern. Hier finden sich drei verschiedene Ausdrücke. Zunächst definieren wir einen Integer $personNrpersonNr$, dieser repräsentiert die Nummer der jeweiligen Person. Dabei handelt es sich um eine Hilfsvariable, in der Praxis wird sie häufig $ii$ genannt. Die Variable dient auch dazu festzulegen, wann die Iteration beendet werden soll. Diese sogenannte Abbruchbedingung ist sehr wichtig und wird in dem zweiten Ausdruck definiert. : Die Iteration wird also so lange ausgeführt, bis der Wert von $personNrpersonNr$ kleiner oder gleich 30 ist. Zum Schluss setzten wir fest, dass die Variable nach jedem Durchlauf um eins erhöht wird. $personNr++personNr++$ ist dabei nur eine kürzere Schreibweise für $personNr=personNr+1personNr\; =\; personNr\; +\; 1$. Innerhalb der Iteration findet sich dann nur noch die Konsolenausgabe. Eine Besonderheit dabei ist die Verkettung der Strings. Dies geschieht in Java mit einem „+“, die Variable repräsentiert dann einfach den Wert des aktuellen Durchlaufs, also in unserem Beispiel den Wert der aktuellen Person.

Die for-Iteration im Umgang mit Arrays

Wie im vorherigen Teil erwähnt, lernst du mit der for-Iteration auch ein mächtiges Werkzeug im Umgang mit Arrays kennen. Schauen wir uns dazu ein Beispiel an:

Wie du siehst haben wir ein Array mit Namen von Personen, welche wir grüßen möchten. Wir setzten zunächst unsere Hilfsvariable $ii$ auf null. In der Abbruchbedingung definieren wir dann, dass die Iteration so lange ausgeführt werden soll, bis wir das letzte Element im Array erreicht haben. Innerhalb der for-Iteration enthält $personen[i]personen[i]$ also den aktuellen Namen aus dem Array.

Die while-Iteration

Eine weitere Iteration in Java ist die while-Iteration. Der wesentliche Unterschied zwischen den beiden Iterationen ist der, dass es bei der for-Iteration schon vorher klar ist, wie oft die Iteration ausgeführt wird. Die while-Iteration bietet sich also immer dann an, wenn du noch nicht weißt, wie oft die Iteration durchlaufen soll. Schauen wir uns dazu erneut das erste Beispiel an, nur dieses Mal gelöst mit der while-Iteration:

Wie du siehst lässt sich das Problem auch mit einer while-Iteration lösen, allerdings bietet sie dir nicht die Möglichkeit Variablen direkt in der Definition zu erstellen.

Zusammenfassung

• Iterationen helfen dir dabei, wenn du gleichen Code mehrmals hintereinander ausführen möchtest

• In Java gibt es die for- und die while-Iteration

• Die for-Iteration ist dann praktisch, wenn du schon vorher weißt, wie oft du den Code ausführen möchtest (z.B. für alle Elemente im Array)

• Die while-Iteration bietet sich an, wenn du noch nicht weißt, wie oft die Iteration durchlaufen soll

In diesem Teil werfen wir nun einen Blick auf Verzweigungen. Diese sind ein Punkt in deinem Programm, an dem Entscheidungen getroffen werden: links oder rechts, richtig oder falsch, gewonnen oder verloren? Natürlich soll bei jeder Option etwas anderes passieren, hat ein Spieler ein Spiel verloren, möchtest du natürlich nicht anzeigen, dass er gewonnen hat. Dabei hilft dir die Verzweigung:

Du hast bestimmt schon erkannt, dass in unserem Beispiel der else-Block ausgeführt wird. Natürlich kannst du auch Variablen in der if-Bedingung benutzen, um über den weiteren Verlauf zu entscheiden. Aber was ist, wenn es mehr Optionen gibt, als nur richtig und falsch? In dem Fall hast du zwei Optionen:

Beispiel: Du möchtest wissen, welche Option ein Nutzer gewählt hat. (1, 2 oder 3?)

Lösung mit Else-If

Hier machen wir von der Option des Else-If Gebrauch. Jeder Fall bekommt hierbei seine eigene If-Abfrage. Um auch den Fall abzudecken, dass die Eingabe keine der geforderten Option ist, wird abschließend ein else-Block verwendet.

Alternative Lösung mit Switch-Case

Eine etwas elegantere Lösung für das Beispiel ist Switch Case. Hier geben wir unsere Eingabe ein und decken die Optionen dann mit je einem Case ab. Ist die Eingabe falsch, haben wir einen Default-Case definiert, welche die gleiche Aufgabe übernimmt wie das else aus der ersten Lösung. Wichtig ist, dass wir jeden Case mit $breakbreak$ beenden. Dies ist notwendig, damit wir das Switch Case Konstrukt verlassen. Du kannst gerne mal ausprobieren, was passiert, wenn du $breakbreak$ weglässt.

Aussagen verknüpfen

Natürlich ist es auch möglich, mehrere Aussagen zu verknüpfen. Schau dir zum Beispiel folgenden Code an:

Hier möchten wir herausfinden, ob eine bestimmte Farbe Teil der Grundfarben ist. Dazu verknüpfen wir mehrere Farben als Oder-Verknüpfung. Es muss also nur eine der drei Bedingungen wahr sein, damit der if-Block ausgeführt wird. Ist die Farbe keine Grundfarbe, wird der else-Block ausgeführt. Dir ist mit Sicherheit schon der besondere Vergleich mit $\mathrm{.}equals(\dots ).equals(\dots )$ aufgefallen. Bisher haben wir für diese Art von Vergleichen ein doppeltes Gleichheitszeichen verwendet. In diesem Fall nutzen wir $\mathrm{.}equals(\dots ).equals(\dots )$, da es sich bei dem Vergleich um zwei Strings, also zwei Objekte, handelt. Du kannst dir also folgendes merken: Vergleichst du ein Objekt nutzt du $\mathrm{.}equals(\dots ).equals(\dots )$ und wenn es sich um einen primitiven Typen wie int, float, etc. handelt, nutzt du das doppelte Gleichheitszeichen.

Übersicht: Wahr oder Falsch?

Abschließend findest du hier noch eine kleine Auflistung von wahren und falschen Aussagen. Schau sie dir gerne an und probiere sie in deinem eigenen Code aus, um vertrauter damit zu werden.

Zusammenfassung

• Verzweigungen lassen dein Programm Entscheidungen treffen

• Dazu verwendest du eine if-else-Anweisung

• Bei vielen Möglichkeiten hilft dir switch-case dabei, deinen Code übersichtlich zu halten

• Du kannst mehrere Bedingungen miteinander verknüpfen (UND-Verknüpfung, ODER-Verknüpfung)

In diesem Teil des Kurses soll es um Methoden gehen. Methoden sind ein essenzieller Bestandteil der Programmierung. Sie helfen dir dabei, häufig ausgeführten Code auszulagern, sodass du ihn nicht immer wieder neu schreiben musst. Stell dir zum Beispiel vor, du möchtest ein Programm schreiben, welches neue Besucher begrüßt. Natürlich könntest du für jeden neuen Besucher eine eigene Konsolenausgabe erzeugen, allerdings macht es dein Programm unübersichtlich. Deshalb bietet es sich an, die Begrüßung in eine Methode auszulagern:

Um eine Methode zu erstellen, musst du zunächst festlegen, welchen Rückgabewert die Methode haben soll. Da wir in diesem Fall nichts zurückgeben wollen, sondern lediglich eine Begrüßung auf der Konsole ausgeben möchten, benutzen wir den Typ $voidvoid$. Im nächsten Schritt geben wir der Methode einen Namen und legen innerhalb der Klammern fest, welche Parameter, also Eingabewerte, die Methode haben soll. In unserem Fall geben wir als Parameter den Namen der Person an, welche begrüßt werden soll. Innerhalb der geschweiften Klammern kommt dann nichts ungewohntes mehr: Hier schreibst du den Code, welchen die Methode ausführen soll. Damit die Methode dann ausgeführt wird, müssen wir sie aufrufen. Dies geschieht, indem wir den Namen schreiben und eventuell die Parameter innerhalb von Klammern angeben. Hat deine Methode keine Eingabeparameter, lässt du die Klammern leer, weglassen darfst du sie aber nicht.

Methoden mit Rückgabewerten

Schauen wir uns nun zum besseren Verständnis eine Methode mit Rückgabewerten an. In diesem Beispiel möchten wir eine Methode schreiben, welche die Summe zweier (ganzer) Zahlen berechnet.

Der Aufbau der Methode erfolgt genauso wie gerade, diesmal geben wir statt $voidvoid$ aber den Rückgabetyp $intint$ an, da wir eine ganze Zahl zurückgeben möchten. Die Parameter der Methode sind die beiden Zahlen, welche addiert werden sollen. Innerhalb der Methode wird dann zunächst die Summe in einer Variable gespeichert, danach wird die Summe zurückgegeben. Da wir dieses Mal keine Konsolenausgabe innerhalb der Methode haben, müssen wir diese außerhalb der Methode schreiben, damit wir das Ergebnis sehen können. Wie du siehst, ist es kein Problem die Methode innerhalb der Konsolenausgabe aufzurufen. Natürlich kannst du auch Variablen als Parameter in die Methode geben. Versuch doch mal, die beiden Zahlen zunächst in Variablen zu speichern und erst danach in die Methode zu geben.

Im nächsten Teil des Kurses lernst du das wohl wichtigste Konzept der objektorientierten Programmierung kennen: Klassen und Objekte.

Zusammenfassung

• In Methoden kannst du häufig genutzten Code auslagern

• Es gibt Methoden mit und ohne Rückgabewert

• Eine Methode kann außerdem beliebig viele Parameter, also Eingabewerte besitzen

Erinnerst du dich noch an das T-Shirt Beispiel aus dem Teil zu Arrays? Natürlich hat Java keinen Datentyp für deine T-Shirts. In diesem Kapitel lernst du, wie du deine eigenen Klassen und Objekte erstellen kannst. Dies ist ein sehr wichtiger Bestandteil von Java, da deine eigenen Programme natürlich nicht nur aus Java's hauseigenen Klassen bestehen sollen.

Klassen

Beginnen wir zunächst mit dem Konzept von Klassen. Du kannst dir eine Klasse als eine Art Bauplan für Objekte vorstellen. Die Klasse T-Shirt beispielsweise hat Attribute wie eine Farbe, eine Marke, einen Herstellungsort etc. Allerdings sind diese Attribute noch nicht konkret. Es ist also an diesem Punkt noch vollkommen unklar, welche Farbe, welche Marke und welchen Herstellungsort dieses T-Shirt hat. Es ist nur klar, dass diese Attribute bei T-Shirts vorhanden sind. Die Definition dieser Klasse sieht wie folgt aus:

Zunächst legen wir die Sichtbarkeit fest, dies wird auch Datenkapselung genannt. In unserem Beispiel ist die Klasse $publicpublic$, auf sie kann also auch von außerhalb der Klasse zugegriffen werden. In der folgenden Tabelle findest du weitere Arten der Datenkapselung.

Nachdem wir die Sichtbarkeit festgelegt haben, wird definiert, dass es sich um eine Klasse handelt. Anschließend folgt der Name der Klasse. Es ist gängige Praxis diesen Klassennamen großzuschreiben, damit sofort erkannt werden kann, dass es sich um eine Klasse handelt. Eine weitere Konvention ist die, dass der Dateiname nach der Klasse benannt wird. Im Normalfall findet sich pro Datei auch nur eine Klasse, in unserem Fall wäre der Dateiname also TShirt.java. Nachdem du nun gelernt hast, wie Klassen erstellt werden, schauen wir uns an, wie wir die Attribute der Klasse festlegen können.

Die Attribute werden genauso festgelegt wie Variablen, allerdings normalerweise ohne die Zuweisung eines Wertes. Natürlich können Klassen auch Methoden enthalten. In diesem Fall hat die Klasse eine Methode zur Ausgabe aller Attribute. Das Wort $thisthis$ meint nur, dass es sich um Attribute der aktuellen Klasse handelt und nicht etwa um Hilfsvariablen.

Konstruktor der Klasse

Natürlich soll die Klasse auch in der Lage sein, richtige Informationen zu speichern. Dafür benötigt die Klasse noch einen Konstruktor. Dieser verhält sich ähnlich wie eine Methode. Er wird aufgerufen, sobald ein Objekt der Klasse erstellt wird. Das klingt etwas komplizierter als es ist, deswegen schauen wir uns dazu ein Beispiel an:

Anders als bei einer Methode, musst du hier keinen Rückgabewert angeben, da ein Konstruktor nicht dazu gemacht ist, etwas zurückzugeben. Der Name des Konstruktors ist derselbe, wie der Name der Klasse. In unserem Fall dient der Konstruktor dazu, Informationen von dem Objekt in der Klasse zu speichern. Die Zuweisungen innerhalb des Konstruktors dienen dazu, den Klassenattributen ($this\mathrm{.}farbethis.farbe$, $this\mathrm{.}markethis.marke$, etc.) die Werte aus den Parametern zuzuweisen.

Objekte

Objekte sind im Gegensatz zu Klassen spezifisch. Hier bekommt die Klasse ihr „Leben“, also ihre Werte zugewiesen. Das Objekt $TShirtTShirt$ repräsentiert also ein echtes T-Shirt, zum Beispiel aus deinem Kleiderschrank. Schauen wir uns nun an, wie wir ein entsprechendes Objekt unserer Klasse $TShirtTShirt$ erstellen können:

Die Definition eines Objekts wird auch Instanziierung genannt. Sie erfolgt ähnlich wie die Definition einer Variable. Zunächst wird der Name der Klasse angegeben, danach kannst du dem Objekt einen eigenen Namen geben. Zuletzt erfolgt die Zuweisung: $newTShirt(\dots )new\; TShirt(\dots )$ macht dabei nichts anderes, als den Konstruktor der Klasse $TShirtTShirt$ aufzurufen. Dieser speichert dann die Parameterwerte in der Klasse. Du kannst nun alle Attribute und Methoden der Klasse an dem Objekt aufrufen. Möchtest du zum Beispiel Informationen über das T-Shirt haben, kannst du einfach die Funktion $gibInformationenAus()gibInformationenAus()$ an dem Objekt aufrufen.

Auf die gleiche Art kannst du natürlich auch auf Attribute zugreifen. Denk aber daran, dass diese nicht automatisch ausgegeben werden.

Zusammenfassung

Du hast nun eines der wichtigsten Konzepte der objektorientierten Programmierung kennengelernt. Da dieses Konzept durchaus etwas kompliziert ist, möchte ich dir hier nochmal die wichtigsten Punkte an die Hand geben:

• Eine Klasse ist eine Art abstrakter Bauplan

• Das Objekt ist der tatsächliche Gegenstand, welcher anhand der Klasse als Bauplan erstellt wurde

• Eine Klasse hat verschiedene Sichtbarkeitsstufen. Diese werden unter dem Begriff der Datenkapselung zusammengefast.

• Du solltest deine Klassennamen groß schreiben

• Klassenname und Dateiname sollten identisch sein

• Der Konstruktor speichert Objektinformationen in Klassenattributen

Spricht man von Objektorientierung, dann fällt früher oder später der Begriff „Vererbung“. Und genau darum soll es in diesem Teil des Kurses gehen. In der Programmierung ist die Vererbung die Weitergabe von Attributen und Methoden von einer Klasse an die nächste. Lass und nochmal an das T-Shirt Beispiel denken. Diesem T-Shirt haben wir schon ein paar Attribute zugesprochen: Farbe, Marke, etc. Gehen wir nun eine Ebene höher, könnte man ein T-Shirt als ein Kleidungsstück betiteln, dabei ist jedes T-Shirt ein Kleidungsstück, aber nicht jedes Kleidungsstück ein T-Shirt. Die Klasse Kleidungsstück hat nun bestimmte Attribute, zum Beispiel eine Farbe, eine Jahreszeit und eine Marke. Ein T-Shirt teilt diese Attribute, allerdings hat ein T-Shirt weitere zusätzliche Attribute. Das könnte beispielsweise die Option sein, ein Polo Shirt zu sein. Schauen wir uns die beiden Klassen im Code an:

In der Klasse $KleidungsstueckKleidungsstueck$ ist nichts ungewohntes zu finden: Zunächst werden die Attribute definiert, danach wird ein Konstruktor erstellt, welcher die Attribute entsprechend zuweist. Die Klasse $TShirtTShirt$ hat allerdings einige Neuerungen bekommen. Die erste Änderung ist die, dass die Klassendefinition um den Zusatz $extendsKleidungsstueckextends\; Kleidungsstueck$ ergänzt wurde. Damit teilen wir der TShirt-Klasse mit, dass sie nun von $KleidungsstueckKleidungsstueck$ erbt. Damit hat die Klasse $TShirtTShirt$ Zugriff auf alle Methoden und Attribute der Klasse $KleidungsstueckKleidungsstueck$. Danach wird innerhalb der $KlasseKlasse$ TShirt das Attribut $istPoloShirtistPoloShirt$ ergänzt. Die Klasse besitzt ebenfalls einen Konstruktor, hier findet sich auch die nächste Neuerung. Der Konstruktor erwartet alle Parameter, welche auch der Konstruktor aus der Klasse $KleidungsstueckKleidungsstueck$ benötigt und zusätzlich die eigenen Attribute aus TShirt. Die letzte wichtige Änderung ist der Aufruf von $super(\dots )super(\dots )$. Dieser macht nichts weiter, als den Konstruktor der Super-Klasse (also die Klasse von der geerbt wird) aufzurufen, deshalb müssen wir auch die geforderten Parameter des Kleidungsstueck-Konstruktors an den super Aufruf übergeben.

Das war es auch schon, du kannst nun eine Instanz der Klasse $TShirtTShirt$ erstellen und sie besitzt sowohl die Attribute aus $KleidungsstueckKleidungsstueck$, als auch das eigene Attribut $istPoloShirtistPoloShirt$.

Wie du siehst, kannst du auf die Attribute von $KleidungsstueckKleidungsstueck$ zugreifen, als wären sie Teil der $TShirtTShirt$ Klasse. Auch Methoden kannst du nach genau diesem Prinzip vererben. In der Aufgabe zu dem Teil kannst du dich daran ausprobieren.

Zusammenfassung

• Die Vererbung ermöglicht die Weitergabe von Attributen und Methoden an Unterklassen

• Diese Unterklassen können dann um weitere Attribute und Methoden ergänzt werden

• Vererbung kommt vor allem dann zum Einsatz, wenn etwas zunächst unspezifisch definiert werden soll und später genauere Eigenschaften erhält. (z.B.: Fahrzeug -> Auto; Kleidungsstueck -> T-Shirt; Tier -> Vierbeinder-> Hund)

In diesem Teil des Kurses soll es um die Behandlung von Fehlern gehen. Diese sind in der Programmierung allgegenwärtig, deshalb kümmert man sich um die Fehler, bevor sie entstehen. Zunächst gilt es dabei zwischen zwei verschiedenen Arten von Fehlern zu unterscheiden. Zum einen gibt es Compilerfehler, also Fehler, die verursachen, dass das Programm nicht kompiliert werden kann. Diese Fehler hängen oft mit einer fehlerhaften Syntax zusammen. Ein Beispiel dafür kann ein vergessenes Semikolon oder eine vergessene Klammer sein. Der „Vorteil“ von diesen Fehlern, ist der, dass sie relativ leicht zu beheben sind. In Eclipse und anderen IDE’s sind diese besonders leicht zu finden, da dir ein vergessenes Semikolon noch vor dem Kompilieren in Rot angezeigt wird. Die zweite Art von Fehlern in der Programmierung sind Laufzeitfehler. Diese Fehler sind leider etwas schwerer zu beheben, da sie oft nicht auf den ersten Blick ersichtlich sind. Auch wenn dir moderne IDE's die Zeile anzeigen, in welcher der Fehler entstanden ist, so ist trotzdem oft einige Suche nach der genauen Ursache nötig.

Schau dir beispielsweise diesen Code an:

Dieser Code erzeugt eine $java\mathrm{.}lang\mathrm{.}ArrayIndexOutOfBoundsExceptionjava.lang.ArrayIndexOutOfBoundsException$, probiere es gerne einmal aus. Der Grund ist dir bestimmt schon aufgefallen: Das Array Zahlen hat nur eine Stelle im Array, wir greifen aber auf die zweite Stelle zu, da die Zählung bei null beginnt. Das erzeugt die Fehlermeldung. Dieser Fehler lässt sich natürlich einfach vermeiden, indem wir den Index verändern. In besonderen Fällen ist vorher allerdings unklar, ob ein Fehler geworfen wird oder nicht. Dafür gibt es in Java das try-catch Konstrukt:

Zunächst wird in dem try-Block der Code geschrieben, der idealerweise ausgeführt werden soll. Der catch-Block ist dafür zuständig, eventuelle Fehler abzufangen und entsprechend zu reagieren. Dazu gibt man den Fehler an, welcher abgefangen werden soll. In unserem Fall also eine $ArrayIndexOutOfBoundsExceptionArrayIndexOutOfBoundsException$. Solltest du dir unsicher sein, welchen Fehler du abfangen willst, gibt es auch die Möglichkeit einfach alle potentiellen Fehler abzufangen, dazu benutzt du einfach anstatt der $ArrayIndexOutOfBoundsExceptionArrayIndexOutOfBoundsException$ eine normale $ExceptionException$.

Zusammenfassung

• Die Fehlerbehebung ist ein wichtiger Teil der Programmierung

• Es gibt Laufzeit- und Compilerfehler

• Laufzeitfehler treten erst dann auf, wenn das Programm schon läuft

• Compilerfehler treten bereits dann auf, wenn das Programm kompiliert wird

• Laufzeitfehler können durch ein try-catch Konstrukt abgefangen und behandelt werden

Fertig! Das war es schon. Du kennst jetzt die wichtigsten Grundlagen der Programmiersprache Java. In diesem letzten Teil des Kurses soll es darum gehen, was du mit deinem neuen Wissen anstellen kannst und wie du von hier aus am besten weiterlernen kannst. In diesem Kurs hast du gelernt, wie du die wichtigsten Grundlagen der Programmiersprache Java einsetzten kannst. Das Ziel war dabei dir einen ersten Eindruck zu geben, was die Programmierung mit Java ausmacht. Das Wissen, was du hier gelernt hast, kannst du am besten vertiefen, indem du an eigenen Projekten arbeitest. Am Anfang sind dabei besonders Konsolenbasierte Anwendungen empfehlenswert. Mit eigenen Projekten wirst du deine Java Kenntnisse sehr schnell erweitern. Natürlich wirst du dabei unzählige Male ratlos sein. In diesen Fällen helfen dir zahlreiche Seiten wie https://stackoverflow.com/ und auch hier auf Serlo gibt es noch weiterführende Inhalte zu dem Thema, schau einfach mal hier vorbei, du wirst mit Sicherheit fündig! Vor allem für den Anfang kannst du davon ausgehen, dass viele Leute vor dem gleichen Problem wie du standen und es entsprechend tausende Lösungen und Erklärungen gibt. Lass dich dabei nicht verunsichern, wenn deine Lösung einmal anders aussieht als die, die du im Internet findest. Wie du schon bei den Aufgaben in dem Kurs gelernt hast, gibt es für jedes Problem in der Programmierung unendlich viele Lösungen. Abschließend hast du also mit diesem Kurs einige wichtige Grundlagen der Java Programmierung kennengelernt, die es dir ermöglichen eigene Praxiserfahrung anhand von Projekten zu sammeln. Denn auch wenn es tausende weitere Kurse zu dem Thema gibt: Praktische Erfahrung lässt sich durch nichts ersetzen.