[0:01] Herzlich willkommen zum Anwendungsentwickler-Podcast, dem Podcast rund um die Ausbildung zum Fachinformatiker für Anwendungsentwicklung.

[0:10] In der heutigen Episode gehe ich einige Fragen der Lernzielkontrolle zum Thema Java durch. Viel Spaß!

[0:20] Hallo und herzlich willkommen zur 36. Episode des Anwendungsentwickler-Podcasts.

[0:26] Mein Name ist Stefan Macke und heute gehe ich mit euch mal ein paar Fragen aus meiner Lernzielkontrolle zum Thema Java durch.

[0:33] Ihr habt das vielleicht schon in den ersten beiden Episoden zum Thema Lernzielkontrolle mitbekommen.

[0:38] Ich mache mit meinen Auszubildenden immer regelmäßig, nachdem sie bestimmte Inhalte gelernt haben, eine Lernzielkontrolle und schaue mal, ob das, was da gelernt werden sollte, auch hängen geblieben ist.

[0:48] Und dafür habe ich mir so ein paar Fragen vorbereitet, die ich immer mit ihnen durchgehe. Und heute machen wir das Ganze mal zum Thema Java.

[0:55] Wir verfolgen jetzt also so ein bisschen nach, wie meine Azubis in unserem Unternehmen das Programmieren lernen.

[1:00] Und die fangen halt bei uns mit Java an, weil es meiner Meinung nach eine gute Einstiegsprogrammiersprache ist und auch in vielen Berufsschulen und Universitäten und Hochschulen benutzt wird als Lehrsprache.

[1:11] Und heute gucken wir uns mal die Einstiegsfragen an. Also es hat noch nicht viel mit Programmierung an sich zu tun, sondern wir gucken uns mal die Eigenschaften von Java an und was man da so fragen kann.

[1:21] Einige der Fragen könnte man natürlich auch zum Beispiel in einem Fachgespräch bei der IHK-Abprüfung stellen, aber es sind halt eher so ein bisschen Einstiegsfragen, allgemeine Fragen.

[1:29] Also wenn ihr die gestellt bekommt, will ich nicht sagen, dass ihr auf eine schlechte Note hinarbeitet, aber es sind eher Einsteigerfragen.

[1:37] Also in so einem Fachgespräch, dazu hatte ich ja auch schon mal eine Podcast-Serie gemacht, da werden eher, sage ich mal, tiefergehende Fragen gestellt.

[1:44] So in Richtung, was sind Generics und so weiter. Und da geht es also nicht unbedingt darum, welche Eigenschaften Java hat, das ist vielleicht so ein bisschen Einstiegsniveau, sage ich mal.

[1:53] Aber nichtsdestotrotz muss man das natürlich als Anwendungsentwickler durchaus wissen, insbesondere natürlich zu der Sprache, mit der man täglich arbeitet.

[1:59] Und Java wird sicherlich vielen von euch bekannt sein und deswegen fangen wir damit heute mal an und ich gehe mal so ein paar Fragen durch.

[2:08] Bevor wir einsteigen mit dem Thema, habe ich aber noch einen kleinen Hinweis.

[2:11] Wenn ihr euch bis zum 14.11.2015 an meinem Newsletter anmeldet, unter anwendungsentwicklerpodcast.de slash Newsletter, dann habt ihr die Chance, an einem kleinen Gewinnspiel teilzunehmen.

[2:24] Wie ihr euch vielleicht vorstellen könnt, seitdem ich meine Website und diesen Podcast betreibe, kriege ich einen Haufen an Anfragen zum Thema Review von irgendwelchen Abschlussdokumentationen, zum Abschlussprojekt und so weiter.

[2:35] Und ich kann diese ganzen Anfragen nicht mehr beantworten. Es ist einfach so viel. Ich kann das in meiner Freizeit nicht mehr leisten.

[2:40] Ihr wisst, die ganze Website und der Podcast hier auch ist völlig kostenfrei. Ich kriege dafür also nichts und ich kann nicht meine ganze Freizeit opfern, um die ganzen Sachen zu reviewen.

[2:48] Und deswegen habe ich so als kleines Schmankerl für alle Newsletter-Abonnenten mir ein kleines Gewinnspiel ausgedacht.

[2:54] Wenn ihr mir bis zum 14.11. ein nettes Review schreibt, es muss nicht mal nett sein, es muss ehrlich sein, ein ehrliches Review zum Beispiel bei iTunes oder jetzt inzwischen auch bei Stitcher schreibt oder einem bei der Facebook-Seite einen Kommentar hinterlasst und ein Like, dann nehmt ihr Teil an dem Gewinnspiel und könnt individuelles Feedback zu eurem Abschlussprojekt von mir gewinnen.

[3:14] Die genauen Teilnahmebedingungen bekommt ihr natürlich sofort per Mail, wenn ihr euch angemeldet habt. Wenn ihr teilnehmen wollt, dann meldet euch einfach für mein Newsletter an www.anwöchsenwicklerpodcast.de.

[3:26] Und dann bekommt ihr sofort in der ersten Mail die Info, was ihr tun müsst und wie ihr teilnehmen könnt.

[3:31] Und ihr könnt euch dann aussuchen, ob ich euren Projektantrag, Projektdoku oder Projektpräsi reviewen soll.

[3:36] Ich denke mal, ich werde auf jeden Fall noch ein paar Tipps geben können, selbst wenn ihr eine gute oder sehr gute Ausweitung habt.

[3:41] Bislang habe ich überall noch was gefunden. Also von daher, wenn ihr Interesse habt, nehmt gerne teil.

[3:46] So, dann starten wir jetzt mit dem eigentlichen Inhalt der heutigen Episode.

[3:51] Es geht also erst mal so ein bisschen los mit allgemeinen Fragen.

[3:54] Und das Erste, was ich fragen würde, ist, was sind Quellcode und Maschinencode?

[4:00] Die beiden Wörter kann man auch noch ein bisschen anders nennen. Quellcode kann man auch Quelltext oder Sourcecode oder Sourcetext vielleicht nicht so.

[4:07] Aber es ist immer das Gleiche gemeint.

[4:09] Und als Einstiegsfrage sollten wir mal abgrenzen, was jetzt was ist.

[4:13] Also der Quellcode, das ist der Code, der vom Entwickler geschrieben wird.

[4:17] Also vom Softwareentwickler, vom Programmierer.

[4:19] Der tippt da etwas in den Computer ein.

[4:21] Das ist durch den Menschen lesbar.

[4:23] Logisch, sonst könnte er es ja nicht schreiben.

[4:25] Wenn er es schreiben will, muss er es auch lesen können.

[4:28] Und das ist eigentlich die Programmiersprache, mit der wir arbeiten.

[4:31] Also die Syntax der Programmiersprache, die wir verwenden, die definiert, wie dieser Quellcode aussieht.

[4:36] Demgegenüber ist der Maschinencode der Code, der von dem Computer ausgeführt wird.

[4:41] Und das ist nicht zwangsläufig dasselbe.

[4:43] In ganz vielen Programmiersprachen jedenfalls ist es nicht dasselbe.

[4:45] Denn der Maschinencode besteht, wenn man es mal runter bricht, aus Nullen und Einsen, die die CPU wunderbar einlesen, verarbeiten, ausführen kann.

[4:52] Das Problem ist nur, kein Mensch kann das verstehen.

[4:54] Verstehen vielleicht schon, wenn man sich anstrengend und ganz viel lernt.

[4:57] Aber es ist nicht so schön lesbar, wie es der Quellcode ist.

[5:00] Und diese beiden Sachen muss man abgrenzen.

[5:02] Wichtig ist, dass der Maschinencode teilweise nur auf einer einzigen Maschine ausgeführt wird.

[5:07] Oder beziehungsweise auf einem Typ dieser Maschine.

[5:09] Also es könnte zum Beispiel sein, dass ihr Maschinencode habt, der nur auf einem Intel-Prozessor läuft.

[5:15] Und anderer Maschinencode läuft vielleicht nur auf einem AMD-Prozessor.

[5:18] Also die sind sehr stark gebunden an das System, das diesen Code ausführen soll.

[5:22] Während der Quellcode halt sehr abstrakt ist.

[5:25] Das ist eine Programmier-Sprache.

[5:26] Damit beschreibe ich meine Problemlösung.

[5:28] Und der muss dann noch irgendwie übersetzt werden in einen vom Computer ausführbaren Code.

[5:33] Nämlich den Maschinencode.

[5:35] Das sind also zwei verschiedene Ebenen, die quasi das gleiche beschreiben.

[5:38] Der Maschinencode ist das, was der Computer wirklich ausführt.

[5:41] Und der Quellcode ist das nett lesbare Ding, was der Entwickler da zusammenschreibt.

[5:47] Jetzt kommen wir genau zur nächsten Frage.

[5:49] Wer übersetzt denn jetzt den Quellcode in den Maschinencode?

[5:52] Und das macht der sogenannte Compiler.

[5:54] Der Compiler, der kompiliert den Quellcode und rauskommt Maschinencode.

[5:59] Das kann man sich natürlich vorstellen, wenn wir eine Programmier-Sprache verwenden, die erstmal recht abstrakt ist.

[6:04] Und wir wollen jetzt Maschinencode rausbekommen, der auf mehreren Maschinen ausführbar ist.

[6:08] Und nicht nur auf einer einzigen. Das wäre ja irgendwie doof in der heutigen Zeit.

[6:12] Dann brauchen wir vielleicht auch mehrere Compiler, die verschiedenen Maschinencode daraus erzeugen.

[6:17] Man könnte sich jetzt also vorstellen, dass ich mit einer Programmiersprache Quellcode erzeuge.

[6:21] Und ich bräuchte dann zwei Compiler.

[6:23] Der eine produziert Maschinencode für Intel-Prozessoren und der andere produziert Maschinencode für AMD-Prozessoren.

[6:29] Das ist heutzutage nicht mehr so, aber so ungefähr könnte man sich das vorstellen.

[6:32] Quellcode ist sehr abstrakt, Maschinencode sehr konkret auf den konkreten Computer.

[6:37] Und die Übersetzung zwischen diesen beiden Codes übernimmt eben der Compiler.

[6:42] Man kann theoretisch auch versuchen, das rückwärts zu machen.

[6:45] Man kann auch einen Decompiler benutzen, der aus Maschinencode wieder Quellcode macht.

[6:49] Aber das ist nicht eindeutig.

[6:51] Ich kann zum Beispiel in meinem Quellcode den gleichen Sachverhalt auf unterschiedliche Arten und Weisen ausdrücken.

[6:55] Ganz einfaches Beispiel. Eine Schleife kann ich entweder als Vorschleife oder als While-Schleife programmieren.

[7:00] Es kommt aber im Zweifel derselbe Maschinencode raus.

[7:03] Und wenn ich den jetzt wieder zurückkompiliere, also dekompiliere, woher soll er jetzt wissen, ob es eine Vorschleife oder eine While-Schleife sein muss?

[7:10] Also man kann das nicht wieder eindeutig rekonstruieren.

[7:12] Aber es gibt Werkzeuge, die durchaus aus Maschinencode wieder Quellcode erzeugen, eben Decompiler genannt.

[7:18] Jetzt haben wir, wenn wir mit Java arbeiten, aber noch einen dritten Code, den wir uns näher anschauen sollten.

[7:24] Das ist der sogenannte Bytecode.

[7:26] Der Bytecode, das ist plattformunabhängiger Programmcode, der von einer virtuellen Maschine ausgeführt wird.

[7:33] Was das bedeutet, werden wir uns gleich noch anschauen.

[7:36] Wichtig ist, dass man heutzutage eigentlich Software programmieren will, die auf verschiedensten Plattformen läuft.

[7:41] Stellen wir uns vor, wir haben ein Windows, ein Linux, ein Mac.

[7:44] Wir haben verschiedene Endgeräte, wie zum Beispiel Mobiltelefone, Tablets, richtige Computer, Großrechner und so weiter.

[7:50] Und am schönsten wäre es natürlich, wenn wir ein Programm nur ein einziges Mal programmieren müssten, zum Beispiel in Java, in der Pomi-Sprache.

[7:56] Und könnten irgendwo auf den Knopf drücken und schwupp kommt ein Programm raus, was auf allen möglichen Plattformen gleich laufen würde.

[8:03] Das wäre toll, dann hätten wir nicht ganz so viel Aufwand und müssten vielleicht für jeden verschiedenen Computer, den wir bedienen wollen, einen individuellen Compiler anschmeißen.

[8:10] Das wollen wir eigentlich nicht haben, sondern wir wollen eigentlich etwas haben, was auf allen Plattformen läuft.

[8:15] Und das ist der Bytecode, beziehungsweise das Prinzip dahinter.

[8:19] Der Bytecode funktioniert so, dass wir auf der Plattform, auf der wir das Programm laufen lassen wollen, eine Laufzeitumgebung installieren.

[8:26] Das ist bei Java zum Beispiel das JRE. Das schauen wir uns gleich noch einmal im Detail an.

[8:31] Das muss auf diesem Betriebssystem installiert sein.

[8:33] Und wenn es das ist, dann kann ich ein beliebiges Java-Programm in Form von Bytecode nehmen und auf dieser virtuellen Maschine einfach ausführen.

[8:42] Das heißt, wenn ich meinen Quellcode kompiliere, dann kommt kein Maschinencode raus, der nur auf einem Computer laufen würde, sondern es kommt Bytecode raus, der eben plattformunabhängig ist.

[8:52] Diesen Bytecode kann ich jetzt auf beliebige Plattformen verteilen und er ist direkt lauffähig.

[8:56] Das ist das Tolle an Java, dass es eben plattformunabhängig ist.

[9:00] Und damit das funktioniert, braucht es eben dieses Konzept des Bytecodes.

[9:04] Das ist so eine Art Zwischending zwischen dem Quellcode und dem Maschinencode.

[9:07] Wenn man sich mal den Maschinencode wirklich anschauen würde, wären es ja wirklich nur Nullen und Einsen.

[9:11] Da kann also der Mensch recht wenig mit anfangen.

[9:13] Wenn man sich den Bytecode anschaut, da kann man teilweise noch was drin erkennen.

[9:17] Ihr könnt euch das mal anschauen, wenn ihr ein Java-Programm kompiliert.

[9:20] Da werden aus den Java-Dateien solche Class-Dateien.

[9:24] Und wenn ihr so eine Class-Datei mal aufmacht, dann könnt ihr tatsächlich sehen, da stehen noch so ein paar Zeichenketten drin, die man auch als Mensch lesen kann.

[9:31] Dazwischen stehen dann durchaus Steuerzeichen, mit denen man nichts anfangen kann.

[9:34] Aber es ist nicht ganz kryptisch.

[9:36] Also man kann ein bisschen was noch drin lesen.

[9:38] Das macht das nochmal deutlich, dass das so ein bisschen so ein Zwischending zwischen Quellcode und Maschinencode ist.

[9:43] Ist aber nicht dafür ausgelegt, dass Menschen ihn lesen können.

[9:47] Das ist wirklich Code, der von der Maschine, von der virtuellen Maschine in diesem Fall, ausgeführt werden soll.

[9:53] So, jetzt haben wir schon Java erwähnt.

[9:55] Dann kommen wir doch direkt mal zur Einstiegsfrage, was ist denn jetzt eigentlich Java?

[9:58] Und Java übersetzen natürlich viele Leute erst mal heutzutage mit der Programmiersprache, die Java heißt.

[10:04] Aber heutzutage muss man ein bisschen weiter gehen.

[10:07] Das ist nicht nur die Programmiersprache, war es eigentlich auch noch nie, wenn man ganz genau ist,

[10:11] sondern Java ist auch immer schon eine Programmierplattform gewesen.

[10:15] Also nicht nur eine Programmiersprache mit einer konkreten Syntax,

[10:19] sondern Java stellt auch eine Plattform bereit, auf der ich verschiedene Programme,

[10:23] die in unterschiedlichen Programmiersprachen entwickelt wurden, ausführen kann.

[10:27] Das ist das Schöne an Java. Das ist eine sehr weit verbreitete Programmierplattform.

[10:33] Das heißt, wenn ihr Java installiert, dann seht ihr es direkt bei dem Splashscreen, der da kommt,

[10:38] auf über drei Milliarden Devices läuft Java heutzutage.

[10:41] Und das ist tatsächlich so. Also es gibt irgendwie, ich will nicht so weit gehen,

[10:45] aber Kühlschränke oder Mikrowellen, die mit Java laufen quasi.

[10:48] Jedes Android-Mobiltelefon läuft auf Java, denn Android ist nichts weiter als eine Java-Plattform.

[10:54] Und auch auf zahlreichen Großrechnern oder auch auf Linux-Systemen, auf Windows, auf Mac,

[11:00] überall läuft eigentlich Java heutzutage.

[11:02] Das ist also ein großer Vorteil.

[11:04] Ihr könnt, wenn ihr in Java programmiert, Programme schreiben,

[11:07] die auf weltweit wirklich Milliarden von Geräten grundsätzlich laufen würde.

[11:11] Die verbreitetste Programmiersprache, um eben auf der Java-Plattform zu programmieren,

[11:16] ist natürlich Java selbst.

[11:18] Die Programmiersprache gibt es schon ein paar Jährchen länger,

[11:20] wird inzwischen von Oracle weiterentwickelt und vertrieben.

[11:24] Aber es gibt heutzutage auch durchaus mehrere Programmiersprachen,

[11:27] um gegen die Plattform Java zu entwickeln.

[11:31] Zum Beispiel gibt es JRuby, einen Port von Ruby auf die Java-Plattform.

[11:36] Oder es gibt Scala oder Clojure oder oder oder.

[11:39] Also es gibt zig verschiedene Programmiersprachen, die letztlich als Ergebnis Bytecode produzieren.

[11:45] So funktioniert das nämlich.

[11:47] Wenn ich eine Programmiersprache auf die Java-Plattform bringen möchte,

[11:50] dann muss ich eigentlich nur einen Compiler schreiben,

[11:52] der aus meiner Programmiersprache erzeugt,

[11:55] der dann eben auf der Java-virtuellen Maschine ausgeführt werden kann.

[11:58] Ich kann also eine beliebige Programmiersprache nehmen,

[12:00] die noch nicht auf der JRuby am Lauf fähig ist

[12:02] und muss eigentlich, in Anführungszeichen,

[12:04] nur einen Compiler schreiben, der Bytecode daraus erzeugt.

[12:07] Und schwupp, habe ich eine Programmiersprache, die gegen Java laufen kann.

[12:11] Und das haben halt schon sehr viele Programmiersprachen heute getan.

[12:14] Und weil die virtuelle Maschine eben so weit verbreitet ist,

[12:17] ist es halt auch ein schöner Anreiz für Compiler-Entwickler.

[12:20] Dann kann ich halt in einer noch tolleren, noch netteren Programmiersprache,

[12:23] die ich halt gerne mag, programmieren,

[12:25] aber habe trotzdem den Vorteil,

[12:27] dass ich die Programme auf allen möglichen Maschinen weltweit ausführen kann.

[12:31] Und dann kommen wir direkt zum nächsten Stichwort,

[12:33] nämlich was ist das JRE, das Java Runtime Environment.

[12:38] Das brauchen wir nämlich genau dafür.

[12:40] Ich hatte gerade gesagt, es muss auf jedem Endgerät etwas installiert werden,

[12:43] das dann die Java-Programme ausführt.

[12:45] Und das ist eben das JRE.

[12:47] Das ist die Laufzeitumgebung für Java-Programme.

[12:50] Die setzt sich eigentlich aus zwei wichtigen Sachen zusammen,

[12:52] nämlich einmal der JVM, der Java Virtual Machine.

[12:56] Das ist der Teil der JRE, der die Programme letztlich ausführt.

[13:00] Der lädt also quasi den Bytecode und führt den dann aus,

[13:03] übersetzt den dann in entsprechende Instruktionen,

[13:06] die zum Beispiel der Prozessor ausführen kann.

[13:08] Aber dazu sind im JRE noch andere Sachen enthalten,

[13:11] wie zum Beispiel die ganze Programm-Bibliothek.

[13:13] Was kann ich also alles mit Java machen?

[13:15] Welche Typen gibt es da zum Beispiel?

[13:17] Und wie heißen die Funktionen und so weiter?

[13:19] Das ist alles in dem JRE definiert.

[13:21] Das ist also auch sehr hart verdrahtet.

[13:23] Ich kann nicht einfach die JVM austauschen

[13:25] und gegen eine andere Klassenbibliothek laufen lassen.

[13:28] Das geht so nicht.

[13:29] Deswegen muss das so verbundelt werden, sage ich mal.

[13:31] Und das ist eben das JRE.

[13:33] Das Ding muss ich installieren auf meinem Endgerät

[13:35] und dann bin ich in der Lage,

[13:37] ein Java-Programm dort auszuführen.

[13:39] Und die JVM, das ist eben genau dieser Teil,

[13:42] der das Programm dann ausführt.

[13:43] Und ein paar Sachen sind noch zusätzlich drin,

[13:45] wie gerade gesagt, Klassenbibliotheken und so weiter.

[13:47] Und das gemeinsam ergibt das JRE.

[13:49] Darüber hinaus brauche ich aber vielleicht noch Komponenten,

[13:52] wenn ich selber Java-Programme erzeugen möchte,

[13:54] also wenn ich die programmieren will.

[13:56] Und dafür brauche ich dann das JDK,

[13:58] das Java Development Kit.

[14:00] Das ist alles das, was ich eben an Tools, an Werkzeugen benötige,

[14:04] um aus meinem Java-Quell-Code,

[14:06] den ich theoretisch auf dem Texteditor schreiben kann,

[14:08] lauffähigen Bytecode zu erzeugen.

[14:10] Nämlich insbesondere der Compiler.

[14:12] Der ist in dem JDK enthalten.

[14:14] Aber auch andere Tools, wie zum Beispiel JavaDoc

[14:16] zur Dokumentation von meinen Java-Programmen,

[14:18] das ist da mit drin.

[14:19] Deswegen ist das JDK auch deutlich größer als die JRE oder das JRE.

[14:23] Ich weiß gar nicht, wie man es am besten sagt auf Deutsch.

[14:25] Eigentlich müsste man das JRE sagen.

[14:27] Die, oder Umgebung, Environment.

[14:29] Also eigentlich die JRE. Ist auch egal.

[14:31] Auf jeden Fall, ihr wisst, was ich meine.

[14:33] JRE, JVM, JDK.

[14:35] Und das JDK enthält halt alles, um, sag ich mal, programmieren zu können.

[14:38] Und ich war gerade stehen geblieben dabei, dass das ein bisschen größer ist.

[14:41] Also wenn ich mir das mal runterlade von der Oracle-Seite,

[14:43] dann ist das JRE, das ist ein paar Megabyte groß.

[14:46] Aber das JDK, das ist heutzutage, meine ich, schon über 100 Megabyte groß.

[14:50] Da ist also durchaus noch ein bisschen mehr drin,

[14:52] als einfach nur so ein kleiner Compiler.

[14:54] Sondern alles, was man eben braucht, um Java-Programme zu erzeugen,

[14:57] zu kompilieren und so weiter.

[14:59] Das ist da mit drin.

[15:01] Alles ist übrigens kostenfrei.

[15:03] Das ganze Java-Zeug, was ihr so braucht.

[15:05] JRE, JDK und so weiter.

[15:07] Könnt ihr euch kostenfrei runterladen von Oracle.

[15:09] Und könnt direkt loslegen mit dem Programmieren.

[15:12] Ist doch klasse.

[15:13] Sehr geringe Einstiegshürde, würde ich sagen.

[15:16] Gut. Jetzt kommen wir gleich zu dem nächsten Punkt.

[15:18] Nämlich, wie programmiere ich denn jetzt in Java?

[15:20] Ich kann also grundsätzlich jedes Programm in Java mit dem Texteditor schreiben.

[15:23] Das ist also kein Problem.

[15:25] Sind einfach nur Textdateien.

[15:26] Der Quelltext, das ist ja gerade menschenlesbar.

[15:28] Hatten wir eben besprochen.

[15:30] Von daher kann ich einfach irgendeinen Texteditor aufmachen.

[15:32] Schreib ein bisschen Java-Code.

[15:33] Schmeiß den Compiler an.

[15:34] Und schwupp, kommt mein Programm da raus.

[15:36] Wenn ich das jetzt tun würde,

[15:38] müsste ich allerdings die konkrete Syntax von Java,

[15:41] also welche Klammern zum Beispiel benutzt werden,

[15:43] wie Groß- und Kleinschreibung ist,

[15:45] wie die Methoden heißen und so weiter.

[15:47] Das müsste ich alles auswendig draufhaben.

[15:49] Könnte das aber so runterprogrammieren.

[15:51] Schmeiß dann den Compiler an.

[15:52] Der heißt bei Java übrigens javac.

[15:54] Könnt ihr über die Kommandozeile einfach ausführen.

[15:56] Und schwupp, wird aus eurer .java-Datei

[15:58] eine .class-Datei.

[16:00] Und die könnt ihr dann mit Java direkt ausführen.

[16:02] Dann werdet ihr schon fertig.

[16:04] Das Problem dabei ist, dass das ziemlich aufwendig ist.

[16:06] Ich hatte gerade schon gesagt, die Syntax,

[16:08] die ist gerade für Einsteiger natürlich nicht ganz so einfach.

[16:10] Gerade Groß- und Kleinschreibungen,

[16:12] die Klammern und die Semikolons und so weiter.

[16:14] Das ist nicht so einfach.

[16:16] Und deswegen tut man eigentlich gut daran,

[16:18] wenn man sich ein bisschen Hilfe holt.

[16:19] Und mit so einem simplen Texteditor

[16:21] ist das nun nicht ganz so prickelnd.

[16:22] Da muss man wirklich alles auswendig können im Prinzip.

[16:24] Und auch Fehler muss man selber suchen.

[16:26] Deswegen sucht man sich eigentlich einen etwas besseren Editor,

[16:28] der diese Syntax beherrscht.

[16:30] Und der einen unterstützen kann.

[16:32] Der zum Beispiel nach einem Tastendruck einem vorschlagen kann,

[16:34] welche Methoden es denn gibt und wie die heißen.

[16:36] Und welche Parameter da benötigt werden.

[16:38] Oder der zum Beispiel auch Dinge vervollständigen kann.

[16:40] Wenn ich lange Variablen-Namen habe,

[16:42] dass ich die nicht austippen muss,

[16:44] sondern dass ich die einfach vervollständigt bekomme und so weiter.

[16:46] Alle diese Dinge, die bietet mir

[16:48] ein sogenanntes Integrated Development Environment

[16:50] oder kurz IDE an.

[16:52] Ich sag immer EINE IDE.

[16:54] Eigentlich müsste auch das jetzt hier wieder

[16:56] EIN, glaube ich, heißen.

[16:58] EIN, ne, EINE Umgebung.

[17:00] Naja gut, auf jeden Fall EINE IDE.

[17:02] Was macht die jetzt also?

[17:04] Die bietet mir also Möglichkeiten,

[17:06] wie ich etwas netter programmieren kann.

[17:08] Die hilft mir also dabei,

[17:10] indem sie mir zum Beispiel während ich den Code,

[17:12] meinen Quelltext eintippe, anzeigt,

[17:14] wenn ich einen Fehler gemacht habe.

[17:16] Wenn ich mich vertippt habe. Oder wenn ich einen Punkt vergessen habe.

[17:18] Oder einen Semikolon vergessen habe und so weiter.

[17:20] Dann wird das zum Beispiel gleich rot unterschlängelt

[17:22] und sagt, du hast einen Fehler gemacht. Bitte guck hier nochmal nach.

[17:24] Und automatisch wird

[17:26] von den meisten IDEs

[17:28] im Hintergrund dann auch gleich der Compiler angeschmissen.

[17:30] Das heißt, ich brauche nur meinen Quelltext zu tippen

[17:32] und bekomme sofort als Ergebnis

[17:34] ein lauffähiges Programm.

[17:36] Und meistens kann ich das sogar innerhalb der IDE direkt ausführen

[17:38] mit einem kleinen Shortcut.

[17:40] Dann wird mir das Programm direkt nach dem Kompilieren

[17:42] ausgeführt und das Ergebnis auch

[17:44] wirklich sofort in der IDE angezeigt.

[17:46] Das heißt, ich muss meine IDE gar nicht mehr verlassen,

[17:48] um von der Entwicklung

[17:50] zur Ausführung alles mit dem Programm machen zu können.

[17:52] Deswegen ist das eine integrierte Entwicklungsumgebung.

[17:54] Weil eben alles, was notwendig ist

[17:56] zum Entwickeln, dort rein integriert ist.

[17:58] Ich muss also im Zweifel

[18:00] nur ein einziges Programm starten

[18:02] und habe eigentlich alles, was ich brauche, um dann

[18:04] mein eigenes Programm zu programmieren.

[18:06] Und deswegen ist es so sinnvoll,

[18:08] so eine IDE sich zu besorgen.

[18:10] Denn das macht das Leben als Entwickler deutlich

[18:12] einfacher. Wenn ich alle selber tippen muss

[18:14] und mich an allen möglichen

[18:16] Kleinkram immer erinnern muss, dann

[18:18] dauert das sehr, sehr lange. Und die IDE

[18:20] kann mir wirklich einen Haufen Arbeit abnehmen.

[18:22] Durch Code-Vervollständigung, durch Templates

[18:24] zum Beispiel, wenn ich eine neue

[18:26] Klasse anlege, werden da bestimmt

[18:28] schon einige Zeilen Code vorgeblendet

[18:30] usw. All solche Dinge, die ich sonst

[18:32] wirklich händisch abtippen müsste,

[18:34] die kann mir so eine IDE abnehmen.

[18:36] Und eine der verbreitetsten

[18:38] IDEs im Java-Umfeld ist sicherlich

[18:40] Eclipse. Habt ihr bestimmt schon mal gehört.

[18:42] Eclipse ist, ich weiß nicht, ob es die

[18:44] verbreitetste ist, aber ich glaube fast schon

[18:46] die IDE für die

[18:48] Java-Entwicklung ist auch absolut kostenfrei

[18:50] und open-source. Könnt ihr euch so runterladen

[18:52] unter eclipse.org. Ist, ich glaube

[18:54] inzwischen 150 oder 200 MB groß,

[18:56] je nachdem, welche Version ihr nehmt.

[18:58] Aber das ist eigentlich eine perfekte IDE

[19:00] für Java. Da ist alles drin, was ihr braucht.

[19:02] Code-Vervollständigung, automatisches

[19:04] Ausführen von Programmen

[19:06] und Fehlerbehandlung

[19:08] und Test-Framework ist gleich eingebaut

[19:10] usw. Also alles, was man heutzutage braucht,

[19:12] findet ihr eigentlich in Eclipse. Und deswegen

[19:14] ist das zum Beispiel auch die IDE, die ich

[19:16] immer für meine eigene Lehre benutze

[19:18] und auch für meine Azubis. Wir entwickeln eigentlich

[19:20] komplett mit Eclipse. Man kann darüber

[19:22] stundenlang streiten, ob es vielleicht nicht noch bessere

[19:24] IDEs gibt. Es gibt für Java

[19:26] zum Beispiel auch NetBeans, direkt von Oracle.

[19:28] Oder es gibt auch IntelliJ

[19:30] als kommerzielle IDE.

[19:32] Die hat sicherlich auch Vorteile, kann bestimmt

[19:34] auch Dinge noch besser als Eclipse. Das mag alles sein.

[19:36] Aber ich glaube, Eclipse, dafür, dass es

[19:38] kostenfrei ist, kann es wirklich sehr

[19:40] sehr viel. Und ich persönlich habe noch

[19:42] keinen Grund gefunden, eine andere IDE

[19:44] zu benutzen. Gerade deswegen auch,

[19:46] weil Eclipse halt eben völlig kostenfrei

[19:48] ist und so verbreitet ist. Wenn ich mich jetzt

[19:50] zum Beispiel an IntelliJ gewöhnen würde

[19:52] und jedes Mal, wenn ich an einem anderen Rechner sitze,

[19:54] kann ich nicht vernünftig arbeiten, weil ich mich

[19:56] an IntelliJ gewöhnt habe. Aber auf den Rechnern ist

[19:58] nur Eclipse installiert. Das wäre für mich so ein großer

[20:00] Nachteil. Ich sage einfach, ich lebe

[20:02] mit Eclipse und ich lebe mit Eclipse auch gut,

[20:04] wie ich finde. Ich komme damit sehr gut klar. Und viele

[20:06] andere Entwickler auch. Von daher will

[20:08] ich gar keinen Glaubenskrieg hier anfangen. Wenn ihr

[20:10] Eclipse nicht so toll findet, dann ist das euer Ding.

[20:12] Hat auch keiner ein Problem damit.

[20:14] Ich persönlich benutze seit Jahren Eclipse

[20:16] und bin damit eigentlich auch sehr zufrieden.

[20:18] Ich habe letztens auf einer Konferenz gehört, Eclipse kann man genau dann einsetzen, wenn man genug Zeit hat, um auch die ganzen Plugins zu installieren, die es dann erst zu einer vernünftigen Entwicklungsplattform machen.

[20:28] Ich persönlich sehe das ein bisschen anders. Mit Eclipse komme ich out of the box eigentlich schon sehr gut klar.

[20:32] Sicherlich gibt es ein paar Sachen, die nicht so schön funktionieren und für die man dann Plugins installieren kann.

[20:37] Ich habe da vor einiger Zeit auch mal einen kleinen Blogartikel zugeschrieben zu meinen Lieblings-Plugins für Eclipse.

[20:42] Da könnt ihr mal reinschauen, da habe ich fünf Sachen aufgelistet, unter anderem zum Beispiel ein Plugin, was einem bei jeder Benutzung der Maus anzeigt, mit welcher Tastenkombination man dieselbe Aktion denn hätte ausführen können.

[20:54] Das trägt dazu bei, dass ihr weniger die Maus benutzt und mehr die Tastatur, also langfristig durchaus auch schneller werdet und auch vor allem gesünder arbeitet, denn die Maus ist nicht das gesündeste Eingabegerät für eure Hände.

[21:07] So, dann kommen wir zur nächsten Frage und zwar, was haben Java und .NET gemeinsam?

[21:12] Das ist auch immer was, was ich gleich zu Beginn meiner Vorlesung zum Beispiel auch immer erkläre, denn Java und .NET sind sicherlich im Enterprise-Umfeld sehr verbreitete Plattformen heutzutage und letztlich machen die beide genau das gleiche.

[21:24] Das muss man sich mal einmal vor Augen führen, denn das verbinden nicht unbedingt die meisten Leute miteinander.

[21:29] Denn beides sind Plattformen für Softwareentwicklung und die beruhen beide auf dem gleichen Prinzip, nämlich von Bytecode, auch wenn der Bytecode in .NET vielleicht ein bisschen anders heißt, aber grundsätzlich ist es das gleiche Prinzip.

[21:39] Ich habe eine Laufzeitumgebung, die ich installiere auf meinem Betriebssystem und darauf führe ich dann den Bytecode, der aus einer beliebigen Programmiersprache erzeugt wurde, aus.

[21:50] Und historisch gesehen haben beide Plattformen grundsätzlich unterschiedliche Ansätze verfolgt.

[21:54] Java verfolgte nämlich den Ansatz, dass wir eine einzige Programmiersprache benutzen, um damit mehrere Plattformen zu bedienen.

[22:02] Es ging ganz klassisch los mit Java und die JVM sollte halt auf allen möglichen Plattformen laufen, also Windows, Linux, Mac und so weiter.

[22:09] Und .NET hat genau den umgekehrten Weg versucht, nämlich die wollten eigentlich mehrere Programmiersprachen haben, aber alles auf einer Plattform laufen lassen, historisch natürlich Windows.

[22:19] Das heißt, wir wollten nur auf Windows unsere Programme laufen lassen, konnten dafür aber von Anfang an schon mit zwei Programmiersprachen arbeiten, nämlich mit C Sharp und mit Visual Basic.

[22:27] Und das ist also im Prinzip, wenn man so will, genau der umgekehrte Ansatz. Java eine Sprache, mehrere Plattformen, .NET eine Plattform, mehrere Sprachen.

[22:37] Aber heutzutage hat sich das beides so angenähert, dass man eigentlich davon ausgehen kann, dass beides eigentlich das Gleiche ist heutzutage.

[22:43] Java ist sicherlich auf noch mehr Plattformen verbreitet als .NET, aber auch .NET gibt es heute für Linux, für Mac und so weiter.

[22:50] Durch das Mono-Projekt ist es sehr weit gediehen, sage ich mal, dass man auch auf Linux heutzutage fast das gesamte .NET-Framework benutzen kann.

[23:00] Und die verschiedenen Sprachen, die da möglich sind, sind bei Java auch schon dazugekommen, habe ich gesagt, Clojure, Scala und so weiter.

[23:06] Da gibt es also zig Programmiersprachen heute, die man auf der JVM laufen lassen kann und genauso bei Microsoft von Anfang an C Sharp und Visual Basic.

[23:13] Aber auch hier gibt es zum Beispiel Iron Python, Iron Ruby. Das sind also Ports von anderen Programmiersprachen und die erzeugen halt auch den .NET-Bytecode heutzutage.

[23:21] Von daher haben beide eigentlich sehr, sehr viel gemeinsam. Es sind Programmierplattformen für verschiedene Plattformen und verschiedene Programmiersprachen.

[23:29] Und damit kommen wir jetzt zu meiner letzten Frage, die es aber noch mal so ein bisschen in sich hat, und zwar, welche Eigenschaften hat denn Java jetzt als Programmiersprache?

[23:37] Ich hatte es, glaube ich, schon mal in einer Podcast-Episode zu häufigen Fragen im Fachgespräch behandelt, dass man durchaus wissen sollte, die Programmiersprache, mit der man täglich arbeitet, was die so für Eigenschaften hat.

[23:48] Also wie man die klassifizieren oder typisieren könnte. Und bei Java würde ich erstmal anfangen damit, dass es eine GPL ist, eine General Purpose Language.

[23:57] Was bedeutet das? Es ist eine allgemeingültige Programmiersprache, mit der ich allgemeine Probleme lösen kann.

[24:02] Demgegenüber steht zum Beispiel die Domain Specific Language, die DSL, mit der nur eine domänenspezifische Problematik gelöst wird.

[24:10] Und eine GPL, damit kann ich aber alles Mögliche machen. Ich kann dort also Finanzanwendungen programmieren oder Web-Anwendungen oder weiß der Geier was.

[24:17] Ich kann einfach alles damit machen. General Purpose eben.

[24:20] Dann ist Java eine Sprache der dritten Generation, wenn man das mal so ein bisschen durchdekliniert.

[24:27] Es gibt vier verschiedene Generationen von Programmiersprachen.

[24:29] Die erste Generation, die habt ihr eigentlich schon kennengelernt, das ist der Machine Code, also Nullen und Einsen.

[24:34] Direkt auf den Prozessor zugeschnittene Nullen und Einsen, die direkt ausführbar sind.

[24:38] Die zweite Generation, das waren die Assembler-Sprachen, die sind also schon so ein bisschen abstrakter.

[24:43] Die kann der Mensch schon ein bisschen besser lesen.

[24:45] Und die dritte Generation, das ist dann sowas, was wir heutzutage haben.

[24:49] Java, C-Sharp, Ruby, Python und wie sie alle heißen.

[24:51] Das ist also eine recht abstrakte Sprache, wo ich eigentlich kaum mehr direkt an der Maschine oder an den Registern in der CPU oder sowas rumdoktore,

[25:00] sondern wo ich ganz abstrakte Konzepte verwenden kann, wie zum Beispiel Schleifen und Fallunterscheidungen und so weiter.

[25:06] Und das abstrahiert von mir weg quasi dieses ganze Zeug, was da eigentlich im Inneren der Maschine abläuft.

[25:12] Und das sind eigentlich so gut wie alle Programmiersprachen, die heute im Einsatz sind.

[25:15] Darüber hinaus gibt es noch eine 4th Generation Language, also eine 4GL-Sprache oder mehrere auch, deren Ansatz es dann ist, noch abstrakter zu werden.

[25:24] Das heißt, ich kann mit noch weniger Code noch mehr machen.

[25:27] Als Beispiel für eine 4GL-Sprache nehme ich dann mal Natural, weil ich damit jeden Tag zu tun habe.

[25:32] Das ist von der Software AG, Deutschlands zweitgrößtem Softwarehersteller nach SAP, eine Programmiersprache, die es schon über 30 Jahre gibt.

[25:39] Und da kann man zum Beispiel mit relativ wenig Zeilencode, ich sage mal mit 2-3 Zeilencode, eine komplette Datenmarkentabelle auslesen und auf die Datensätze zugreifen.

[25:48] Dafür brauche ich in Java schon ein paar mehr Zeilen.

[25:50] Wenn ihr mal überlegt, wenn ihr das schon mal gemacht habt, ihr müsst die Datenmarkenverbindung herstellen,

[25:53] dann müsst ihr irgendwie ein Select Statement absetzen, dann müsst ihr das Result Set durchlaufen und so weiter und so fort.

[25:59] Ich sage jetzt einfach mal, da kommen 10-20 Zeilencode bei raus, wenn ihr nicht irgendwelche Frameworks benutzt, die das von euch abstrahieren.

[26:05] Aber in Natural eingebaut ist zum Beispiel eine Funktion, die heißt einfach Read.

[26:09] Dann gebe ich einen Tabellennamen an und schwupp, da ist alles mit drin.

[26:12] Das ist eine Schleife, die alle Datensätze der Tabelle ausliest und die kann ich dann direkt verarbeiten.

[26:16] Und das sind wirklich zwei Zeilencode im Gegensatz zu vielleicht 20 Zeilencode in Java.

[26:21] Dafür sind die 4GL-Sprachen aber vielleicht andersweitig etwas eingeschränkt.

[26:25] Da kann man dann vielleicht bestimmte Low-Level-Operationen nicht so schön mitmachen, wie was weiß ich, irgendwelche Bit-Verschiebungen oder so.

[26:30] Das geht vielleicht mit den Sprachen dann gar nicht, weil die halt einen ganz anderen Ansatz haben.

[26:34] Die wollen einfach mit möglichst wenig Code eine lauffähige Lösung schaffen.

[26:39] Und Java ist halt eben eine Sprache der dritten Generation.

[26:43] Das heißt, ich kann alles Mögliche damit tun, muss aber bestimmte Dinge vielleicht selber abstrahieren,

[26:48] also mir zum Beispiel eigene Funktionen bauen, die bestimmte abstraktere Dinge tun,

[26:53] weil sie eben nicht direkt in der Sprache eingebaut sind.

[26:56] So, dann hatten wir schon besprochen, Java wird kompiliert.

[26:59] Es gibt auch Sprachen, die nicht kompiliert werden, zum Beispiel PHP.

[27:02] Das wird interpretiert, das heißt, der Source-Code wird nicht übersetzt, sondern wird direkt ausgeführt durch den Interpreter.

[27:08] Und das muss man durchaus voneinander abgrenzen.

[27:11] Also Java wird eben kompiliert, auch wenn kein Maschinen-Code rauskommt, sondern Byte-Code.

[27:16] Aber es wird ein Compiler benötigt, also ist es eine Compiler-Sprache.

[27:20] Dann ist Java statisch typisiert.

[27:23] Das bedeutet, dass die Datentypen unserer Variablen, Rückgabe-Werte, Parameter usw.

[27:28] schon zur Compile-Zeit festgelegt werden müssen.

[27:31] Das kennt ihr, wenn ihr schon mal mit so einer Polymer-Sprache gearbeitet habt.

[27:34] Ihr schreibt irgendwie String a gleich Hallo.

[27:37] Das heißt, das String vorne, das legt fest, dass die Variable a jetzt diesen Datentyp String hat.

[27:41] Und der kann auch nicht mehr geändert werden einfach.

[27:43] Ich kann nicht sagen, so, ich schreibe da jetzt mal ein Integer rein oder so.

[27:46] Das funktioniert nicht. Das ist statisch typisiert.

[27:49] Darum zur Compile-Zeit ist das festgelegt.

[27:52] Außerdem ist Java stark typisiert.

[27:55] Das bedeutet, ich kann auch nicht einfach so zur Laufzeit meine Typen mal ändern.

[27:58] Es gibt demgegenüber z.B. in C die Möglichkeit,

[28:01] dass ich ein Integer und ein Character einfach mal gleich benutzen kann.

[28:05] Das wird einfach implizit ineinander umgewandelt.

[28:08] Oder wenn ich z.B. ein Int habe mit dem Wert 5,

[28:11] dann wird der automatisch als Wahrheitswert True interpretiert, weil er ungleich 0 ist.

[28:15] Und solche impliziten Typ-Konvertierungen, die gibt es in Java nicht.

[28:18] Ah, nicht ganz richtig. Die gibt es schon.

[28:21] Ich kann z.B. ein Integer in eine Double-Variable reinschieben,

[28:24] weil ich dort keinen Genauigkeitsverlust habe. Umgekehrt geht es nicht.

[28:27] Ich kann also kein Double in ein Int schieben, weil mir dann die Nachkommastellen verloren gehen würden.

[28:31] Aber solche impliziten Typ-Umwandlungen gibt es halt eben nur für solche Ausnahmefälle,

[28:35] wo definitiv sichergestellt ist, dass keine Genauigkeit verloren geht.

[28:39] Und deswegen ist Java auf jeden Fall auch stark typisiert.

[28:44] Also statisch und stark typisiert.

[28:47] Außerdem, wenn man das so ein bisschen einordnen wollte, ist die Sprache C ähnlich.

[28:52] So nenne ich das jetzt mal. Das heißt insbesondere diese Klammern, die geschweiften Klammern,

[28:56] die findet man in ganz vielen Programmiersprachen, z.B. auch in C Sharp oder PHP.

[29:00] Aber in anderen Programmiersprachenfamilien gibt es die nicht.

[29:03] Z.B. in Ruby oder in Visual Basic. Da arbeitet man nicht mit den Klammern,

[29:06] sondern vielleicht mit End oder Beginn und solchen Sachen.

[29:10] Wenn ich z.B. eine Ruby anschaue und ich definiere dort eine Methode,

[29:13] dann mache ich nicht public void irgendwas, Klammer auf, Klammer zu,

[29:16] sondern ich mache halt def Funktionsname und dann end, wenn die Funktion fertig ist.

[29:20] Das heißt, ich benutze diese geschweiften Klammern gar nicht.

[29:23] Aber viele Programmiersprachen, die halt so ähnlich sind wie C,

[29:26] wo das ursprünglich eingesetzt wurde mit den Klammern, die sehen halt so aus.

[29:30] Und deswegen würde ich Java zu den C-ähnlichen Sprachen zählen, was die Syntax angeht.

[29:36] Also wie gesagt, wie die Klammern benutzt werden und so weiter.

[29:39] Und zuletzt natürlich auch ganz wichtig, das Paradigma,

[29:42] was benutzt wird bei der Programmierung mit Java ist Objektorientierung.

[29:46] Ich habe hier also keine prozedurale Programmiersprache oder eine funktionale Programmiersprache,

[29:50] sondern sie ist vom Ansatz her objektorientiert.

[29:53] Was das heißt, habt ihr sicherlich schon in einer Podcast Episode gehört,

[29:57] nämlich in den häufigen Fragen rund ums Fachgespräch.

[30:00] Da ging es natürlich schon rauf und runter um die Objektorientierung.

[30:02] Wir werden das in den nächsten Episoden zur Programmierung aber auch nochmal einmal vertiefen.

[30:07] Da gehen wir also auch Schritt für Schritt nochmal die Sachen durch, die man da vielleicht erklären können müsste.

[30:11] Und das werden wir am Beispiel von den Java-Sprachmitteln dann einmal machen,

[30:15] sodass ihr da jetzt also nichts verpassen werdet.

[30:18] Damit komme ich dann für heute zum Schluss.

[30:21] Wie immer findet ihr die Shownotes zu der heutigen Episode unter anwendungsentwicklerpodcast.de

[30:26] slash 36, also 3 6 für die 36. Episode heute.

[30:32] Da habe ich auch nochmal ein paar Wikipedia-Artikel verlinkt,

[30:35] die nochmal so ein paar Sachen genauer erklären und natürlich auch noch ein bisschen weitergehen in die Literatur.

[30:39] Insbesondere habe ich heute zwei Tipps für euch,

[30:41] nämlich einmal die Einführung in Java aus dem Rheinwerk Verlag und selbstverständlich auch die Java-Insel.

[30:47] Also Java ist auch eine Insel.

[30:49] Das Standardwerk eigentlich hatte ich in meinem letzten Podcast zu den Literaturtipps schon erwähnt.

[30:53] Die sind wieder dort verlinkt.

[30:55] Da findet ihr natürlich alles, was ihr wissen müsst rund ums Thema Java

[30:58] und sicherlich auch nochmal intensiv besprochen die Themen, die wir heute hier gehört haben.

[31:04] Grundsätzlich vielleicht nochmal einmal der Hinweis,

[31:06] wenn ihr mich und den Podcast so ein bisschen unterstützen wollt, könnt ihr,

[31:09] wenn ihr sowieso vorhabt, die Bücher zu kaufen,

[31:11] das vielleicht über meine Affiliate-Links machen, die ihr auf der Website findet

[31:14] oder einfach unter anwendungsentwicklerpodcast.de slash Amazon.

[31:18] Wenn ihr denn bei Amazon kaufen wollt, ihr könnt es auch bei Rheinwerk machen.

[31:21] Direkt zum Beispiel, das wäre dann halt anwendungsentwicklerpodcast.de slash Rheinwerk.

[31:27] Dadurch unterstützt ihr mich so ein bisschen.

[31:29] Ihr habt dadurch letztlich keinen direkten Vorteil.

[31:31] Ihr zahlt genau das gleiche wie sonst auch,

[31:33] aber ich kriege so eine kleine Provision, wenn ihr über die Links was kauft.

[31:36] Also wenn ihr wollt, dass der Podcast noch ein bisschen länger durchhält,

[31:40] sage ich mal, dass ich mir das noch ein bisschen länger leisten kann,

[31:42] dann würde ich mich freuen, wenn ihr das macht.

[31:44] Kein Zwang. Wenn ihr nicht mögt, dann nicht.

[31:46] Aber die Möglichkeit besteht dazu.

[31:48] Und das würde mich natürlich freuen.

[31:50] Wenn ihr sowieso auf der Website seid und ihr noch ein bisschen mehr lesen wollt rund um die Ausbildung,

[31:53] dann kann ich euch meinen Blogartikel von letzter Woche empfehlen.

[31:56] Da geht es um die Frage, ob die Projektbearbeitungszeit,

[31:59] also diese 70 Stunden, die ihr zur Verfügung habt,

[32:01] wirklich genau eingehalten werden muss oder nicht.

[32:04] Und in meinen Links der Woche habe ich mich um das Thema Verkürzung der Ausbildungszeit gekümmert.

[32:09] Also wenn euch die Themen interessieren, schaut doch mal rein.

[32:11] Ist natürlich auch wieder in den Shownotes verlinkt.

[32:14] Wie immer gilt, wenn ihr Feedback für mich habt oder Fragen rund um die Ausbildung,

[32:18] dann schreibt mir gerne eine Mail an mail.anwendungsentwicklerpodcast.de

[32:22] oder hinterlasst mir einen Kommentar zu dieser Episode, damit auch andere das sehen können.

[32:27] Ihr könnt mir alle möglichen Fragen stellen.

[32:29] Ich versuche mich um jede Mail oder jeden Kommentar, den ich bekomme, zu kümmern.

[32:33] Grundsätzlich für euch nochmal der Tipp.

[32:35] Wenn ihr keine Podcast Episode verpassen wollt, dann abonniert doch einfach meinen Feed.

[32:39] Das könnt ihr direkt auf der Website machen.

[32:41] Da ist das unter jeder Episode verlinkt oder auch bei iTunes oder jetzt neuerdings auch bei Stitcher.

[32:45] Bei iTunes könnt ihr unter anwendungsentwicklerpodcast.de slash iTunes den Feed erreichen

[32:50] oder unter anwendungsentwicklerpodcast.de slash Stitcher.

[32:54] Das gleiche auch für Stitcher.

[32:56] Wenn ihr mögt, könnt ihr mich auch bei Facebook besuchen unter facebook.com slash anwendungsentwicklerpodcast

[33:01] und auf Twitter bin ich auch aktiv unter dem Handel Stefan Macke.

[33:05] Zuletzt wie immer der Hinweis, wenn ihr euch in meinem Anwendungsentwickler Newsletter anmeldet,

[33:10] bekommt ihr sofort Zugriff auf meine Checklisten rund um die Artefakte eurer Projektarbeit.

[33:16] Und jetzt habt ihr wie gesagt auch nochmal einmal die Chance an meinem Gewinnspiel teilzunehmen.

[33:20] Von daher unter anwendungsentwicklerpodcast.de slash Newsletter besteht die Möglichkeit sich anzumelden.

[33:25] Wenn euch die Inhalte nicht mehr gefallen, könnt ihr euch jederzeit auch wieder austragen.

[33:29] Ihr gebt also keinerlei Verpflichtungen ein.

[33:31] Und in der nächsten Episode, das sei der letzte Hinweis für heute,

[33:35] werde ich dann natürlich das Thema Leerzielkontrolle zum Thema Programmierung etwas weiter ausführen

[33:40] mit Fokus ein bisschen auf Java.

[33:42] Aber wir fangen erstmal ganz vorne an, was ist eine Variable und so weiter und so fort

[33:46] und steigern uns dann langsam aber sicher bis hin zum Thema Objekteorientierung und sicherlich auch Polymorphie,

[33:51] sodass wir da also auch nochmal den Rundumschlag rund um die Programmierung machen.

[33:55] Bis dahin sage ich vielen, vielen Dank fürs Zuhören und bis zum nächsten Mal. Tschüss!