reading

Beijing • Cambridge • Farnham • Köln • Sebastopol • Taipei • Tokyo

Die Informationen in diesem Buch wurden mit größter Sorgfalt erarbeitet. Dennoch können Fehler nicht vollständig ausgeschlossen werden. Verlag, Autoren und Übersetzer übernehmen keine juristische Verantwortung oder irgendeine Haftung für eventuell verbliebene Fehler und deren Folgen.

Alle Warennamen werden ohne Gewährleistung der freien Verwendbarkeit benutzt und sind möglicherweise eingetragene Warenzeichen. Der Verlag richtet sich im Wesentlichen nach den Schreibweisen der Hersteller. Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.

Inhalt

Einleitung

Die Programmiersprache Java liegt mittlerweile in der achten Version vor und hat nach einigen stürmischen Anfangsjahren nun einen hohen Grad an Stabilität, Performanz und Funktionalität erreicht. Es ist daher auch nicht verwunderlich, dass Java mittlerweile neben – oder sollte man sagen vor – C++ und C# die wichtigste Programmiersprache für Neuentwicklungen von kommerziellen Softwareprodukten ist und sich auch im Hochschulbereich sowie in der Abteilung Hobby und Freizeit großer Beliebtheit erfreut. Und der Trend setzt sich fort: Google hat Java als Programmiersprache für seine Android-Apps (für Smartphones mit Android-Betriebssystem) auserwählt und Java damit einen weiteren riesigen Boom beschert (Grund genug für uns, einen eigenen App-Teil in das Buch aufzunehmen.)

An wen sich dieses Buch richtet

Vor diesem Hintergrund versteht sich das vorliegende Buch als ein Lehr- und Standardwerk zur Programmierung mit Java, das sich vornehmlich an Studenten und engagierte Einsteiger wendet, sich aber auch sehr gut für fortgeschrittene Leser und Umsteiger von anderen Sprachen eignet.

Studenten – oder ganz allgemein Einsteiger, die die Java-Programmierung zwar mit Spaß, aber auch mit einer gewissen Ernsthaftigkeit betreiben möchten – werden neben den umfassenden und klar verständlichen Ausführungen vor allem die vielen Erläuterungen und Hintergrundinformationen, die Einblicke in Alltag und Methodik des Programmierens und die Einführungen in die speziellen Programmiergebiete (inklusive Android) schätzen.

Umsteiger und fortgeschrittene Leser können sich mit dem Buch weiterbilden und es (auch mithilfe des ausführlichen Index) als zuverlässiges Nachschlagewerk nutzen.

Vorkenntnisse werden keine vorausgesetzt. Für Leser, die noch über keinerlei Programmierkenntnisse verfügen, gibt es im ersten Teil eine Schnelleinführung in die wichtigsten Programmierkonzepte, verknüpft mit einem Rückblick auf die Entwicklung der modernen Programmiersprachen.

Neuerungen in Java 8

Die neueste Version der Sprache, Java 8, hat vor allem viele interne Verbesserungen und Bugfixes gebracht. Daneben gab es aber auch einige größere und kleinere Erweiterungen der Sprache und der angebotenen Bibliotheken, von denen wir folgende in das Buch aufgenommen haben:

Aufbau dieses Buchs

Das vorliegende Buch ist in mehrere Teile gegliedert, von denen sich die ersten vier vornehmlich auf die reine Java-Syntax konzentrieren, während sich die nachfolgenden Teile mit den Java-Bibliotheken, diversen weiterführenden Programmierthemen sowie der Praxis des Programmierens beschäftigen.

Teil I ist Ihr Einstieg in die Programmierung im Allgemeinen und Java im Besonderen. Wer möchte, kann sich in Kapitel 1 ein wenig über die Entstehung und Geschichte von Java informieren. In Kapitel 2 geht es dann noch weiter zurück, und wir vollziehen im Schnelldurchgang die Entwicklungen nach, die zu den modernen Programmiersprachen Java, C++ und C# geführt haben. Das Hauptaugenmerk gilt dabei allerdings weniger der Historie als vielmehr den grundlegenden Programmierkonzepten, daher ist dieses Kapitel für diejenigen Leser, die noch über keinerlei Programmiererfahrung verfügen, ein absolutes Muss. In Kapitel 3 lernen Sie dann die Programmierwerkzeuge des Java-SDK kennen und erstellen Ihr erstes eigenes Programm. In Kapitel 4 stellen wir Ihnen vorab die in Java üblichen Stilkonventionen vor.

Teil II befasst sich mit grundlegenden Sprachelementen, die man heute in fast allen strukturierten Programmiersprachen wiederfindet: von den Variablen bis zu den Kontrollstrukturen.

In Teil III befassen wir uns erstmals ernsthafter mit der objektorientierten Programmierung, d. h., wir werden Objekte nicht mehr nur verwenden, sondern untersuchen, wie man eigene Klassen zur Erzeugung von Objekten schreibt. Daneben stellen wir Ihnen in Kapitel 12 noch zwei weitere grundlegende Datentypen vor, Arrays und Aufzählungen, die in Java eng mit dem Java-Konzept verknüpft sind, und schließen mit Kapitel 13 die Grundlagen ab.

Teil IV ist den weiterführenden Konzepten der objektorientierten Programmierung gewidmet: Vererbung, Polymorphie, Schnittstellen (Interfaces), Exceptions und weiterführenden Aspekten der Programmierung mit Objekten.

Teil V nimmt Sie mit auf einen Streifzug durch die wichtigsten Utility-Klassen der Java-Bibliothek. Hier werden neben Datum, Zeit, Systemumgebung usw. auch so wichtige Themen wie Strings, Collections sowie Ein- und Ausgabe ausführlich behandelt. Darüber hinaus gibt es noch ein Kapitel zur funktionalen Programmierung mittels Lambda-Ausdrücken (Kapitel 25) und der Verwendung von Annotationen (Kapitel 26).

Teil VI behandelt die Erstellung von Anwendungen mit grafischen Benutzeroberflächen (GUI). Neben den reinen Grundlagen werden hier auch weiterführende Aspekte wie das Drucken, Drag & Drop, Grafik sowie die Verwendung von JTree und JTable angesprochen.

Teil VII behandelt weiterführende Programmiergebiete – etwa wie Sie von einem Java-Programm aus auf eine Datenbank zugreifen (Kapitel 38), wie Sie Programmcode mittels Threads parallel ausführen (Kapitel 39) oder wie Sie Webseitentext laden (Kapitel 40). Besonders interessant für Studenten dürfte auch Kapitel 41 sein, das sich etwas ausführlicher mit der Praxis und Methodik des Programmierens beschäftigt.

Teil VIII ist denjenigen Lesern gewidmet, die ihre Java-Kenntnisse auch zur Entwicklung von Android-Apps nutzen möchten.

Ergänzt wird das Buch durch umfangreiche Anhänge, die Sie sich von der Website zum Buch (siehe Hinweis weiter unten) herunterladen können.

Allgemeine Konzeption

Bücher, die sich um eine möglichst vollständige Darstellung der Java-Syntax und der Java-Bibliotheken bemühen, haben üblicherweise mit dem Problem zu kämpfen, dass sie als Lehrbücher oder gar zum Selbststudium meist nur sehr bedingt geeignet sind. Umgekehrt behandeln einführende Programmierlehrbücher meist nur einen Bruchteil der Möglichkeiten, die Java und seine Standardbibliothek bieten.

Wir erheben keineswegs den Anspruch auf Lösung dieses Dilemmas, hoffen aber, ein vernünftiges Konzept gefunden zu haben, das dem Leser beides bieten kann: ein verständliches Lehrbuch und ein gutes Nachschlagewerk.

So werden Sie in diesem Buch kaum Stellen finden, an denen Syntaxelemente oder Klassen vorgestellt werden, ohne dass nicht auch etwas über die Bedeutung oder die sinnvolle Verwendung dieser Elemente gesagt wird. Zudem nehmen wir uns immer wieder Zeit, Hintergründe zu erläutern, praktische Beispiele an die Hand zu geben oder den Blick vom Detail auf das übergeordnete Ganze zu richten. Übungen und Workshops helfen, das Gelernte zu vertiefen und praktische Erfahrungen zu sammeln, und in Teil VII gibt es dann noch ein eigenes Kapitel zur Praxis des Programmierens.

Dafür mussten wir uns bei der Vorstellung der weiterführenden Programmierthemen auf einige herausragende Gebiete konzentrieren – was uns allerdings nicht als großes Manko erscheint, da Leser, die ein Niveau erreicht haben, auf dem diese Informationen für sie interessant werden, meist gut dazu in der Lage sind, sich über die sehr ausführliche und hilfreiche Java-API-Dokumentation bzw. die entsprechende Fachliteratur und diverse Internetforen informieren zu können. Neben einer kurzen Einführung in die HTTP-Programmierung haben wir uns daher auf die Datenbankprogrammierung (einen Klassiker), die Android-Programmierung (eines der am stärksten boomenden Anwendungsgebiete) und die Thread-Programmierung (weil unabdingbar für viele professionelle Anwendungen und wichtig auch für viele Android-Apps) konzentriert.

Verwendung als Lehrbuch

Wenn Sie noch über keinerlei Programmiererfahrung verfügen, lesen Sie unbedingt zuerst die Einführung für Programmieranfänger (Kapitel 2). Ansonsten können Sie je nach Wissensstand auch mit Kapitel 3 oder 4 ff. beginnen. (Sie können aber natürlich trotzdem einen Blick in Kapitel 2 werfen; es dürfte wegen seines historischen Rückblicks auch für den einen oder anderen Leser mit Vorkenntnissen interessant sein.)

In den ersten Teilen, die sich mit der Java-Syntax befassen, gibt es am Ende jeden Kapitels einen Übungsteil. Versuchen Sie nicht, dem Drang nachzugeben, diese Übungen nur grob zu überfliegen oder ganz zu übergehen. Die Übungen sind in der Regel gut machbar,¹ da wir sie weniger als geistige Herausforderung sehen, sondern vielmehr als Möglichkeit, das Gelernte zu rekapitulieren und praktisch einzuüben.

Besonders stolz sind wir auf die Workshops, die es am Ende fast jedes Buchteils gibt. In diesen Workshops können Sie uns bei der Programmierung über die Schulter schauen oder mit uns zusammen ein etwas größeres Projekt angehen (beispielsweise ein eigenes Mastermind-Spiel oder ein Millionen-Quiz).

Verwendung als Nachschlagewerk

Wie man ein Buch als Nachschlagewerk verwendet, muss wohl kaum erklärt werden. Wir beschränken uns hier daher darauf, auf das Inhaltsverzeichnis, die Querverweise im Text, die zahlreichen Methodentabellen in den hinteren Kapiteln und den umfangreichen Index zu verweisen. (Beachten Sie im Index unteren anderem die Obereinträge API und Softwareentwicklung.)

Typografische Konventionen

Wird für wichtige Begriffe, Programm- und Dateinamen, URLs, Ordner und Verzeichnispfade, Menüs, Optionen und zur Hervorhebung verwendet.

Verwendung der Codebeispiele

Dieses Buch ist dazu gedacht, Ihnen bei der Erledigung Ihrer Arbeit zu helfen. Im Allgemeinen dürfen Sie den Code in diesem Buch in Ihren eigenen Programmen oder Dokumentationen verwenden. Solange Sie den Code nicht in großem Umfang reproduzieren, brauchen Sie uns nicht um Erlaubnis zu bitten. Zum Beispiel benötigen Sie nicht unsere Erlaubnis, wenn Sie ein Programm unter Zuhilfenahme mehrerer Codestücke aus diesem Buch schreiben. Wenn Sie allerdings einen Datenträger mit Beispielen aus O’Reilly-Büchern verkaufen oder vertreiben wollten, müssten Sie eine Genehmigung von uns einholen. Eine Frage mit einem Zitat oder einem Codebeispiel aus dem Buch zu beantworten, erfordert keine Genehmigung. Signifikante Teile von Beispielcode aus dem Buch für die eigene Produktdokumentation zu verwerten, ist dagegen genehmigungspflichtig.

Wir freuen uns über eine Quellenangabe, verlangen sie aber nicht unbedingt. Zu einer Quellenangabe gehören normalerweise Autor, Titel, Verlagsangabe, Veröffentlichungsjahr und ISBN, hier also: »Dirk Louis & Peter Müller, Java – Der umfassende Programmierkurs, O’Reilly Verlag 2014, ISBN 978-3-95561-540-6«. Sollten Sie das Gefühl haben, Ihre Verwendung der Codebeispiele könnte gegen das Fairnessprinzip oder die Genehmigungspflicht verstoßen, dann nehmen Sie bitte unter kommentar@oreilly.de Kontakt mit uns auf.

Website zum Buch

Wir haben eine Webseite zu diesem Buch eingerichtet, auf der die Codebeispiele, Errata und zusätzliche Informationen veröffentlicht werden. Sie finden die Seite unter:

Buchergänzungen und Lösungen als Download

Das vorliegende Buch wird durch umfangreiche Anhänge ergänzt, die Sie sich als PDF von der oben genannten O’Reilly-Website zum Buch herunterladen können. Hier finden Sie auch die Lösungen zu den Übungen.

Kontakt

Kommentare oder technische Fragen zu diesem Buch schicken Sie bitte per E-Mail an:

Weitere Informationen zum gesamten Angebot des O’Reilly Verlags finden Sie auf unserer Website: http://www.oreilly.de.

Wir sind auf Facebook: facebook.com/oreilly.de (https://www.facebook.com/oreilly.de)

Folgen Sie uns auf Twitter: twitter.com/OReilly_Verlag/ (https://twitter.com/OReilly_Verlag)

TEIL I

KAPITEL 1

Die Geschichte Javas – nicht die der Insel Java, sondern die der Programmiersprache Java – ist recht bewegt, und wir wollen zur Einstimmung mit einem kurzen Rückblick auf seine Entstehung beginnen.

Das Green-Projekt und die Sprache Oak

1990 war Sun Microsystems auf der Suche nach einem neuen Betätigungsfeld. Das Kern-geschäft mit Workstations¹ und Servern lief zwar gut, doch die Konkurrenz des PCs, der immer leistungsfähiger, günstiger und anwenderfreundlicher wurde, war bereits zu spüren. Um langfristig nicht ins Abseits zu geraten, wurde ein Team zusammengestellt, das eruieren sollte, welche die nächsten großen Trends in der Computertechnologie sein könnten. Die streng geheime Untersuchung, die unter dem Namen »Green«-Projekt geführt wurde, kam bald zu dem Ergebnis, dass einer der bedeutendsten Trends die zunehmende Ausstattung von elektronischen Gebrauchsgeräten mit Mikroprozessoren und deren Anbindung an das Internet sei. Ein Trend, der den PC, dieses »Abfallprodukt« der Computerentwicklung, dieses Artefakt im privaten Heim, vollkommen überflüssig machen könnte.

Die Mitarbeiter des Green-Projekts gingen nun daran, ein Produkt zu kreieren, das dem prognostizierten Trend nicht nur entsprechen, sondern selbst zum Trendsetter werden sollte: Star7, ein PDA mit Touchscreen, drahtloser Netzanbindung, PCMCIA-Schnittstelle, eigener Unix-Version, einer kleinen animierten Figur namens Duke (siehe Abbildung), die dem Anwender bei der Bedienung des Geräts Hilfestellung leisten sollte, und ... einer eigenen, plattformunabhängigen, robusten, objektorientierten Programmiersprache namens Oak².

Star7 wurde firmenintern gut aufgenommen, doch nachfolgende Versuche, das Produkt zur Marktreife zu führen, scheiterten. Sun war seiner Zeit einfach zu weit voraus. Das Projekt, für das noch 1992 eine eigene Firma, First Person Inc., gegründet wurde, zerfiel, die Mitarbeiter zerstreuten sich.

Aus Oak wird Java

Mittlerweile hatte sich im Internet einiges getan. 1993 wurde am Cern-Institut in Lausanne das World Wide Web, das »Netz im Netz«, ins Leben gerufen. Noch im gleichen Jahr entwickelte man am NCSA³ den ersten grafischen Webbrowser, den Mosaic-Browser, an dem auch der Student Marc Andreessen mitarbeitete, der ein Jahr später Netscape gründen und den legendären Netscape Navigator auf den Markt bringen sollte.

Bei Sun hatte man derweil die Entwicklung des World Wide Web und der Browser aufmerksam verfolgt. Aus Sicht von Sun stellte sich die Situation in etwa wie folgt dar: Auf der einen Seite gab es eine schnell wachsende Gemeinde von Internetanwendern, die das Web nutzten und freudig jede Entwicklung begrüßten, die es gestattete, Webseiten lebendiger und interaktiver zu gestalten. Auf der anderen Seite hatte man bei Sun eine leistungsfähige, plattformunabhängige Programmiersprache namens Oak, für die es derzeit keine rechte Verwendung gab, sowie erste Ergebnisse aus einem Projekt, das Sun zum Teil mitfinanziert hatte und das sich mit der Entwicklung einer »virtuellen Maschine« beschäftigte, die es Programmierern ermöglichen würde, ihre Anwendungen auf unterschiedlichen Architekturen und Betriebssystemen auszuführen.

Wie wäre es nun, wenn man die virtuelle Maschine in einen Browser integrieren und Oak so weiterentwickeln würde, dass Oak-Programme innerhalb dieses Browsers auf beliebigen Plattformen ausgeführt werden könnten? Browser und Programmiersprache könnte man frei im Internet zur Verfügung stellen, um einen neuen Standard zu setzen und später mit Lizenzierungen Gewinn zu erwirtschaften. Darüber hinaus würde man die Attraktivität des Internets erhöhen, was zweifelsohne wiederum den Verkaufszahlen der eigenen Workstations und Server zugutekäme, die sich durch hochwertige Netzwerktechnik und beste Vernetzbarkeit auszeichneten. Und vielleicht liebäugelte man auch schon mit der Idee des Internet-PCs, der keine Festplatte haben und seine Anwendungen aus dem Internet beziehen sollte – sozusagen ein früher Vorfahr der Cloud-Technologie.

Ein neues Team wurde zusammengestellt, dem auch James Gosling wieder angehörte. Aus Oak wurde Java (der Name »Oak« wurde bereits von einer anderen Firma für eines ihrer Produkte verwendet, und so einigte man sich in der Cafeteria, bei viel heißem Kaffee, auf den Namen Java), und 1995 wurde der erste Java-fähige Browser, HotJava, vorgestellt. Gleichzeitig kündigte Netscape-Chef Andreessen an, dass er Java für seinen Navigator, den damals unumstrittenen Marktbeherrscher, lizenzieren wird. Im Januar 1996 wurde das JDK 1.0, die erste Version der Java-Entwicklungstools, zum Download im Internet freigegeben. Der Ansturm auf das JDK war gewaltig, und es glich geradezu einem Wunder, dass der Server nicht zusammenbrach. Aber schließlich gehörte Sun ja schon immer zu den führenden Anbietern von High-End-Servern.

Java und Bill Gates

Doch nicht überall wurde Java mit Euphorie und Wohlwollen begrüßt, so zum Beispiel im Hause Microsoft.

Gerade hatten Gates und Microsoft es geschafft, den ungeliebten Konkurrenten DR DOS durch – so jedenfalls die Vorwürfe des Konkurrenten – absichtlich täuschende Produktvorankündigungen, unlautere Lizenzierungsverfahren, schwarze Listen für Betatester und versteckte Inkompatibilitäten, die verhinderten, dass Windows 3.x zusammen mit DR DOS lief, aus dem Markt zu drängen⁴, als man erkennen musste, dass man die Entwicklung des Internets verschlafen und seine Bedeutung und Bedrohung unterschätzt hatte.

Einmal erwacht, ging Microsoft in die Gegenoffensive: mit eigenem Internetportal (MSDN), eigener Webserversoftware (IIS usw.) und eigenem Webbrowser – dem Internet Explorer. Anfangs versuchte Microsoft, Java zu ignorieren, doch man erkannte bald, dass es ohne Java-Unterstützung schwierig würde, gegenüber dem Netscape-Browser Marktanteile zu gewinnen. Netscape vertrieb seinen Browser praktisch kostenfrei – lediglich gegen Entrichtung einer Registrierungsgebühr – und setzte darauf, dass sich die Popularität des Navigator indirekt auszahlen würde, beispielsweise durch erhöhte Absatzzahlen der Netscape-Serversoftware – ein Konzept, das anfangs bestens aufging.

Microsoft konterte, indem es Java lizenzierte, den Internet Explorer aufrüstete und ihn ganz offiziell kostenlos im Internet zum Download anbot. Ja, Microsoft belohnte sogar Firmen, die zur weiteren Verbreitung des Internet Explorer beitrugen. Einmal in Schwung gekommen, stellte Microsoft dann auch noch seine Serversoftware kostenlos zur Verfügung – ein Schritt, der Netscape besonders empfindlich traf. Der letzte Coup bestand darin, den Internet Explorer zusammen mit dem Betriebssystem Windows 98 auszuliefern. Dies brach dem Navigator endgültig das Genick und brachte Microsoft eine folgenschwere Klage vor Gericht ein. Wieder einmal wurden die US-Justiz auf Microsofts Geschäftsgebaren aufmerksam, und es kam zum zweiten Antitrust Case »United States v. Microsoft«, bei dem es um die Monopolstellung Microsofts ging.

Zurück zu Java. Der Browserkrieg war kaum in Gang gekommen, da eröffnete Microsoft eine zweite Front und wandte sich Java zu.

Das erste Geschoss, das Gates auf Java abfeuerte, trug die Aufschrift ActiveX und erwies sich als wenig durchschlagskräftig. ActiveX war keine eigene Programmiersprache, sondern lediglich eine Technologie zur Erstellung von Softwarekomponenten, die in Webseiten und Programme eingebettet werden konnten – vornehmlich also Konkurrenz für die beiden Java-Technologien der Java-Applets und der JavaBeans. Im Vergleich zu diesen war ActiveX jedoch kompliziert zu programmieren, plattformgebunden und unsicher in der Verwendung (zumindest für den unbedarften Websurfer, der sich ActiveX-Elemente aus Webseiten auf seine lokale Festplatte lud).

Microsofts zweites Geschoss war schon gewichtiger. Zuerst lancierte Microsoft die integrierte Entwicklungsumgebung Visual J++ für Java, dann stattete es diese Umgebung mit einer eigenen Java Virtual Machine⁵ aus. Microsoft rechtfertigte dies damit, dass die eigene Virtual Machine besser sei als die Sun-Machine und man seinen Kunden nur das Beste bieten wolle. Sun sah darin einen Versuch, den Java-Standard aufzuweichen und eine zweite zum Sun-Standard inkompatible Java-Laufzeitumgebung zu etablieren. Um die Integrität der Java-Plattform zu erhalten, strengte Sun eine Gerichtsklage an. Der Prozess verlief gut für Sun, und im Januar 2001 konnte man Microsoft einen außergerichtlichen Frieden diktieren. Microsoft durfte weiter die Sun-Java-Technologie lizenzieren und unverändert verwenden, musste aber die Weiterentwicklung seiner eigenen Microsoft Virtual Machine aufgeben und die Auslieferung bis zum Jahr 2004 gänzlich einstellen.

C# und .NET

Die eigene Java Virtual Machine war Microsoft untersagt worden, doch den Konzern traf dies nur marginal – arbeitete man doch bereits an einer neuen Virtual Machine, diesmal nicht für Java, sondern für eine eigene Programmiersprache: C#.

C# ist Java sehr ähnlich, und ebenso wie Java-Code wird C#-Code nicht in maschinenspezifische Befehle, sondern in virtuellen Objektcode übersetzt. Wenn ein C#-Programm gestartet wird, lädt die Virtual Machine (die Laufzeitumgebung) den Objektcode, wandelt ihn in maschinenspezifischen Code um und führt ihn aus.

Die »Virtual Machine« für C# heißt .NET Framework. Ähnlich wie die Java Virtual Machine besteht das .NET Framework in der Hauptsache aus Werkzeugen zum Ausführen der Programme (Interpreter, Garbage Collector usw.) sowie einer umfangreichen Klassenbibliothek, auf die der Programmierer beim Schreiben seiner Programme zurückgreifen kann.

Im Gegensatz zur Java Machine unterstützt das .NET Framework jedoch nicht nur eine, sondern eine Vielzahl von Programmiersprachen. Welche Sprachen unterstützt werden? Alle Sprachen, für die ein .NET-Compiler verfügbar ist, der den Quelltext in den virtuellen Objektcode des Frameworks übersetzt. Gehört Java auch zu diesen Sprachen? Nein, nicht soweit uns bekannt ist. Microsoft stellt aber Programme zur Verfügung, mit denen Java-Quelltext in C#-Code umgewandelt werden kann. Ist es sinnvoll, seine Java-Programme in C++-Programme umzuwandeln? Nur wenn Sie von Java auf C# umsteigen möchten.

Und sollte man auf C# umsteigen? Ist C# besser als Java? Wird C# Java verdrängen?

C# und .NET sind zweifelsohne eine starke Konkurrenz zu Java, doch sie werden Java nicht verdrängen. Beide, Java wie C#, haben ihre Vorzüge und auch ihre Nachteile, Stärken wie Schwächen, und beide werden sich im Konkurrenzkampf weiterentwickeln und reifen.

Jüngste Entwicklung, Oracle und OpenJDK

Die Programmiersprache Java ist im Grunde genommen nichts weiter als eine technische Spezifikation, die beschreibt, wie Java-Code aussehen soll. Lebendig wird diese Spezifikation erst durch eine Entwicklungsumgebung, das JDK, das dem Programmierer die Mittel an die Hand gibt, um in Java geschriebene Quelltexte in lauffähige Java-Programme umzuwandeln.

Früher oblagen Pflege und Weiterentwicklung der Sprache Java und des zugehörigen JDK ganz der Firma Sun Microsystems, in deren Auftrag die Sprache Java überhaupt erst entwickelt wurde. Doch Sun hat sich mittlerweile aus diesem Aufgabenbereich weitestgehend zurückgezogen. Bereits 2006 begann man mit der Umwandlung des JDK in ein Open Source-Projekt, wenige Jahre später wurden dann die weiteren Rechte an Java an die Firma Oracle verkauft.

Seitdem gibt es zwei wichtige Referenzimplementierungen: das OpenJDK und das Oracle JDK.

Oracle hat zugesichert, das OpenJDK weiter zu unterstützen, sodass derzeit nicht zu befürchten ist, dass die JDK-Versionen stark auseinanderdriften werden. Zudem wird das JDK für Java SE derzeit von Oracle weiter kostenfrei zum Download angeboten und darf im Rahmen der Lizenzbedingungen genutzt werden. Lediglich für diverse kommerzielle Zusatzkomponenten, die optional hinzugenommen werden können, sind Lizenzgebühren zu bezahlen.

Solange dies so bleibt, empfehlen wir die Arbeit mit dem Oracle JDK. Sofern Sie aber mit einem Betriebssystem arbeiten, auf dem eine passende Version des OpenJDK bereits vorinstalliert ist, können Sie diese natürlich ebenfalls verwenden.

KAPITEL 2

Dieses Kapitel ist für Programmierneulinge gedacht und führt anhand theoretischer Gedankenspiele und -modelle in die Grundprinzipien der Programmierung ein. Da es gleichzeitig nebenbei auch ein wenig die Entwicklungsgeschichte der modernen Programmiersprachen resümiert, dürfte es aber durchaus auch für den einen oder anderen fortgeschrittenen Leser ganz interessant sein.

Auf jeden Fall ist es ein bisschen theorielastig und aufgrund der vielen eingeführten Begriffe und Konzepte für blutige Anfänger sicherlich nicht immer leicht zu verdauen. Trotzdem kann man Einsteigern, die sich ernsthaft mit Programmierung befassen möchten, die Lektüre nur empfehlen.

Wer lieber gleich in medias res gehen möchte, der darf aber natürlich auch direkt zu Kapitel 3 springen.

Die Ansprüche sind gestiegen

Java ist eine wunderbare Programmiersprache. Sie ist modern, leistungsfähig, vielseitig, in gewisser Weise sogar ästhetisch ... Eines ist sie jedoch ganz bestimmt nicht: leicht zu erlernen. Nun, das allein wäre ja noch gar nicht mal so schlimm – schließlich erwartet ja niemand, dass eine so mächtige Sprache von einem Tag auf den anderen zu meistern ist. Während sich der hoffnungsvolle Novize jedoch in die meisten anderen Sprachen Schritt für Schritt einarbeiten kann, muss er sich in Java gleich zu Beginn mit einer Vielzahl sehr komplizierter Konzepte auseinandersetzen.

So besteht bereits das einfachste Programm, das in Java geschrieben werden kann, aus mindestens vier Zeilen, vollgepackt mit kryptischem Code:

public class Programm {
   public static void main(String[] args) {
      System.out.println("Hallo Anwender!");
   }
}

Das gleiche Programm, das übrigens nichts anderes macht, als den Benutzer mit einem freundlichen »Hallo« auf der Konsole zu begrüßen, hätte ein Basic-Programmierer Anfang der Neunziger wie folgt geschrieben:

Die erste Hürde liegt für den Java-Programmierer also extrem hoch, sodass ihm letzten Endes nur drei Möglichkeiten bleiben:

1. Er läuft unter der Hürde durch, d. h., er akzeptiert die ihm nicht verständlichen Syntaxformen des Grundgerüsts als naturgegeben und arbeitet sich danach so gut es geht schrittweise in die Sprache ein.

2. Er wartet mit dem Programmieren, bis er sich theoretisch so weit in die Sprache eingearbeitet hat, dass er sämtliche im Grundgerüst vorkommenden Konzepte verinnerlicht hat. Dann erst nimmt er die Hürde.

Den letzten Weg werden Sie jetzt einschlagen. Indem Sie in einem kurzen Abriss die historische Entwicklung der Programmiersprachen von den ersten Anfängen bis zu Java nachvollziehen, werden Sie sich mit den wichtigsten Konzepten moderner Programmiersprachen zumindest so weit vertraut machen, dass Sie das Grundgerüst verstehen und einfache Programme schreiben können.

Vom Maschinencode zu den höheren Programmiersprachen

Programmieren bedeutet, dem Rechner Befehle zu erteilen, die er ausführen kann. Früher wurden diese Befehle vom Rechenwerk ausgeführt, das in den ersten Rechenmaschinen aus dem 19. Jahrhundert noch mechanisch arbeitete. Heute ist das Herzstück des Rechners der Prozessor. Doch eines hat sich nicht geändert: Jeder Rechner/Prozessor verfügt nur über einen ganz begrenzten Satz an Befehlen, und auch diese versteht er nur, wenn sie binär, d. h. als eine Folge von Nullen und Einsen, codiert vorliegen.¹

10100001 00111111101001100110010100000001
10000011 1100000 00000000000000000000000000000011
10100011 00111111101001100110010100000001

Assembler

Da die Programmierung mit binär codierten Maschinenbefehlen äußerst mühselig und fehleranfällig ist, sann man schon früh nach Möglichkeiten, die Programmierung zu vereinfachen. Ein erster Schritt in diese Richtung war Assembler.

Assembler-Programmierung ist immer noch Programmierung auf Maschinenebene, nur dass der Programmierer die Befehle nicht mehr binär codiert, sondern in Form sogenannter Mnemonics niederschreibt.

Ein spezielles Übersetzerprogramm, das ebenso wie die Sprache Assembler genannt wird, übersetzt die Befehlsnamen (MOV, ADD ...), Registerbezeichnungen (EAX, EDX ...) Speicheradressen ([3FA66501] ...) und Zahlen (3 ...) in die zugehörigen Binärfolgen.

Das Variablenkonzept

Einfache Zahlen können zumeist direkt in die Maschinenbefehle integriert und vom Prozessor verarbeitet werden (siehe den Befehl ADD EAX, 3). Für komplexere Daten wie z. B. Zeichenfolgen (»Dies ist ein Text«) ist das nicht möglich. Sie müssen im Arbeitsspeicher abgelegt und bei Bedarf in den Prozessor geladen werden.

Auch Daten, denen im Programm eine bestimmte Bedeutung zukommt und deren Wert sich im Lauf des Programms ändern kann, müssen im Arbeitsspeicher verwahrt werden. Ein Programm, das die Mausklicks des Anwenders zählt, könnte beispielsweise einen bestimmten Bereich im Arbeitsspeicher für die Anzahl der Mausklicks reservieren. Beim Programmstart schreibt es den Wert 0 in diesen Speicherbereich. Danach lauscht es auf Mausklicks, und jedes Mal, wenn der Anwender eine Maustaste drückt, liest es den aktu-ellen Wert des Speicherbereichs in den Prozessor, addiert den Wert 1 und schreibt das Ergebnis zurück in den Speicherbereich. So werden aus an sich bedeutungslosen Zahlenwerten sinnvolle Daten!

In den obigen Maschinenbefehlen wurden die Speicheradressen, von denen Daten geladen oder in die Daten geschrieben werden sollten, stets als explizite (hexadezimale oder binäre) Adressen angegeben. Dies hat zwei gravierende Nachteile: Der Programmierer muss sich merken oder gesondert notieren, welche Daten an welchen Adressen stehen, und er ist selbst für die korrekte Speicherbelegung verantwortlich, muss also beispielsweise aufpassen, dass sich die Speicherbereiche zweier Daten nicht überlappen.

Hier schafft das Konzept der Variablen, das schnell auch in Assembler Einzug fand, Abhilfe. Statt numerischer Speicheradressen vergibt der Programmierer Namen und überlässt dem Übersetzerprogramm (im Fall der Assembler-Programmierung also dem Assembler) die Zuordnung dieser Namen zu echten Speicheradressen. Statt nichtssagender Zahlen kann der Programmierer nun Namen auswählen, die auf Art und Zweck der gespeicherten Daten hinweisen, beispielsweise mausklickZaehler, alter oder preis.

Abbildung 2-1: Variablen sind ein wenig wie Schubladen, in denen man Werte aufbewahren kann.

Hinweis

Das Beziehungsgefüge aus Name, zugehörigem Speicherort und darin abgelegten Daten wird als Variable bezeichnet. Im alltäglichen Sprachgebrauch wird die Variable aber auch häufig mit ihrem Wert, d. h. mit den in ihr abgelegten Daten, gleichgesetzt. Wenn ein Programmierer also davon spricht, dass er die Variable A zur Variablen B hinzuaddiert, meint er damit, dass der Wert in der Variablen A zu dem Wert der Variablen B hinzuaddiert wird.

Die höheren Programmiersprachen

Ende der Fünfziger, Anfang der Sechziger wurden die ersten höheren Programmiersprachen entwickelt. Anders als die Assemblersprachen, bei denen jeder Befehl der Sprache exakt einem Maschinenbefehl entspricht, arbeiten die höheren Programmiersprachen mit Anweisungen, die weitaus komplexere Operationen ausführen und in eine ganze Folge von Maschinenbefehlen übersetzt werden. Klar, dass es hierfür spezielle entsprechend leistungsfähige Übersetzerprogramme geben muss. Dabei wird je nach der prinzipiellen Arbeitsweise zwischen Compilern und Interpretern unterschieden:

• Ein Compiler liest den gesamten Quelltext des Programms (oder Programmmoduls) ein, analysiert ihn und übersetzt ihn dann in Maschinencode. Dieser Maschinen-code kann mithilfe eines weiteren Programms, des Linkers, mit anderem Maschinencode verbunden und in ein ausführbares Programm verwandelt werden (beispielsweise eine Windows-EXE-Datei). Zum Starten des Programms wird die ausführbare Programmdatei aufgerufen.

• Ein Interpreter liest den Quelltext Zeile für Zeile ein. Jede Zeile wird sofort übersetzt und direkt zur Ausführung an den Prozessor weitergereicht. Zum Ausführen des Programms muss also nur der Quelltext des Programms an den Interpreter übergeben werden.

Für jede höhere Programmiersprache gibt es einen eigenen Compiler oder Interpreter. Wortschatz und Grammatik der Programmiersprache sind in der Spezifikation der Sprache niedergeschrieben und im Compiler (oder Interpreter) implementiert. Die Sprache wird also genauso gut durch den Compiler (oder Interpreter) wie durch ihre Spezifikation definiert. Oder um es noch drastischer zu formulieren: Wenn Sie ein Programm geschrieben haben, das sich mit dem zugehörigen Compiler nicht übersetzen lässt, nutzt es Ihnen gar nichts, wenn Sie belegen können, dass Ihr Quelltext exakt den Regeln der Sprachspezifikation folgt. Letzte Instanz ist in so einem Fall der Compiler. Sie können sich bei dem Compilerhersteller beschweren, aber wenn Sie Ihr Programm übersetzen möchten, müssen Sie den Regeln folgen, die der Compiler implementiert².

Hinweis

Die obige Unterscheidung zwischen Compiler und Interpreter beschreibt die traditionellen Grundprinzipien, die mit Kompilation und Interpretation verbunden sind. Obwohl diese Grundprinzipien nach wie vor gelten, können moderne Compiler und Interpreter in einzelnen Punkten davon abweichen. (Der Java-Compiler erzeugt beispielsweise weder echten Maschinencode noch ausführbare EXE-Dateien. Dazu später in Abschnitt »Programmerstellung in Java« auf Seite 35 mehr.)

Ein einfaches Programm, das von der Konsole eine Radiusangabe einliest, den zugehörigen Kreisumfang berechnet und diesen auf der Konsole ausgibt, würde, in Basic geschrieben, wie folgt aussehen:

Beispiel 2-1: Ein Basic-Programm, wie es in den späten Achtzigern geschrieben worden sein könnte

' Programm zur Berechnung des Kreisumfangs
print "Geben Sie einen Radius ein: "
input radius
umfang = 2 * 3.1415 * radius
print "Der Kreisumfang betraegt " umfang

Das Programm beginnt damit, dass es einen Text ausgibt, der den Anwender auffordert, über die Tastatur einen Radiuswert einzutippen. Dieser wird mit dem Schlüsselwort input in die Variable radius eingelesen. (Die Variable radius wird dabei automatisch eingerichtet und mit ausreichend Speicher verbunden.) In der vorletzten Quelltextzeile wird der Kreisumfang berechnet und in der neuen Variablen umfang abgespeichert. Schließlich gibt das Programm einen kurzen erläuternden Text und den Inhalt von umfang auf der Konsole aus.

Das Beispiel zeigt nicht nur, wie einfach die Programmierung in höheren Programmiersprachen sein kann, es demonstriert auch den Einsatz einiger wichtiger Elemente, die für Quelltexte höherer Programmiersprachen typisch sind:

• Kommentare, die den Quelltext erklären und vom Programmierer eingefügt werden, damit er selbst oder andere Programmierer sich später schneller in den Quelltext einarbeiten können. Kommentare werden vom Übersetzerprogramm ignoriert (' Programm zur Berechnung des Kreisumfangs).

• Konstante Werte, die in der Programmierung als Literale bezeichnet werden ("Geben Sie einen Radius ein! ", 2, 3.1415 ...).

Beachten Sie, dass in Dezimalzahlen die Nachkommastellen durch einen Punkt – und nicht wie im Deutschen üblich durch ein Komma – abgetrennt werden!

• Variablen zum Abspeichern und Verwalten der Daten (radius, umfang).

• Operatoren zur Durchführung einfacher, grundlegender Bearbeitungsschritte wie der Multiplikation (*) oder der Zuweisung eines berechneten Werts an eine Variable (=).

• In der Sprache oder in den Standardbibliotheken der Sprache implementierte höhere Befehle, die häufig benötigte Aufgaben erledigen – beispielsweise das Einlesen von Daten über die Tastatur (input) oder die Ausgabe von Strings auf der Konsole (print).

Bildschirmausgaben und Konsolenanwendungen

Die meisten PC-Benutzer, vor allem Windows- oder KDE-Anwender, sind daran gewöhnt, dass die Programme als Fenster auf dem Bildschirm erscheinen. Dies erfordert aber, dass das Programm mit dem Fenstermanager des Betriebssystems kommuniziert und spezielle Optionen und Funktionen des Betriebssystems nutzt. Programme, die ohne fensterbasierte, grafische Benutzeroberfläche (GUI = Graphical User Interface) auskommen, können hierauf jedoch verzichten und stattdessen die Konsole zum Datenaustausch mit dem Benutzer verwenden.

Die Konsole ist eine spezielle Umgebung, die dem Programm vorgaukelt, es lebe in der guten alten Zeit, als es noch keine Window-Systeme gab und immer nur ein Programm zurzeit ausgeführt werden konnte. Dieses Programm konnte dann uneingeschränkt über alle Ressourcen des Rechners verfügen – beispielsweise die Tastatur, das wichtigste Eingabegerät, oder auch den Bildschirm, das wichtigste Ausgabegerät. Der Bildschirm war in der Regel in den Textmodus geschaltet, wurde also nicht aus Pixelreihen, sondern aus Textzeilen aufgebaut.

Unter Windows heißt die Konsole MS-DOS-Eingabeaufforderung oder auch nur Eingabeaufforderung und kann je nach Betriebssystem über START/PROGRAMME oder START/PROGRAMME/ZUBEHÖR aufgerufen werden.

Konsolenprogramme werden meist von einem Konsolenfenster aus aufgerufen, d. h., am Eingabeprompt (Ende der untersten Textzeile der Konsole) wird der Name des Programms eingetippt und mit der -Taste abgeschickt. Die Ausgaben des Programms erscheinen Zeile für Zeile darunter (sind die Zeilen der Konsole vollgetschrieben, werden sie nach oben gescrollt). Eingaben über die Tastatur werden in der aktuellen Zeile der Konsole angezeigt und nach Drücken der -Taste an das Programm weitergeleitet.

Abbildung 2-2: Ausführung eines Java-Programms auf der Windows-Konsole

Kontrollstrukturen

Maschinenbefehle werden grundsätzlich der Reihe nach – so wie sie in den Arbeitsspeicher geladen wurden oder wie der Interpreter sie an den Prozessor schickt – ausgeführt. Wo es nötig oder opportun ist, von dieser sequenziellen Ausführung abzuweichen, kann der Programmierer Sprungbefehle einbauen, die dafür sorgen, dass die Programmausführung an einer beliebigen anderen Stelle des Programms fortgeführt wird.

Höhere Programmiersprachen, auch Basic, geben die Fähigkeit, Sprünge zu vollziehen, meist auf verschiedene Weise an den Programmierer weiter:

• durch direkte Sprünge zu beliebigen Anweisungen (das zugehörige Schlüsselwort heißt in der Regel goto),

• durch spezielle Kontrollstrukturen, die der Interpreter mithilfe von Sprüngen realisiert,

• durch Funktionsaufrufe (siehe Abschnitt »Funktionen« auf Seite 22).

Die direkten Sprünge mit goto sollen uns nicht weiter interessieren. Sie führen schnell zu wirrem Spaghetticode und werden in Java daher nicht unterstützt. Wesentlich interessanter sind da schon die Kontrollstrukturen, zu denen

• die bedingte Ausführung,

• die Verzweigung und

• die Schleife

gehören.

Die bedingte Ausführung

Eine bedingte Ausführung dient dazu, zu entscheiden, ob eine nachfolgende Anweisung oder ein Anweisungsblock ausgeführt werden soll oder nicht. In den meisten Program-miersprachen wird die bedingte Ausführung mit dem Schlüsselwort if eingeleitet. In Basic hat sie folgenden Aufbau:

if (Bedingung) then
Anweisung(en)
end if

Diese Konstruktion kann man wie einen deutschen Konditionalsatz lesen:

»Wenn die Bedingung erfüllt ist, dann (und nur dann) führe die Anweisungen aus.«

verkaufszahlen < 1000verkaufszahlenififend if

Neuerungen in der Sprache	Beschrieben in Kapitel
Lambda-Ausdrücke	Kapitel 25
Neuerungen in den Java-Bibliotheken	Beschrieben in Kapitel
Neue API für Datums- und Zeitangaben	Abschnitt »Datum und Zeit« auf Seite 454