Erhalten Sie Zugang zu diesem und mehr als 300000 Büchern ab EUR 5,99 monatlich.
- Herausgeber: Carl Hanser Verlag GmbH & Co. KG
- Kategorie: Wissenschaft und neue Technologien
- Sprache: Deutsch
- Veröffentlichungsjahr: 2020
Einstieg in Java mit Eclipse //
- Einrichtung der Entwicklungsumgebung (Java, Eclipse)
- Grundlagen der objektorientierten Programmierung
- Einführung in Eclipse
- Beschreibung der Java-Sprachelemente (Variablen, Anweisungen, einfache Datentypen, Klassen und Objekte, Aufzählungen, Arrays, Methoden, Operatoren, Verzweigungen, Schleifen, Pakete und Module)
- Überblick über die Plattform Java (Bytecode, Laufzeitumgebung mit Garbage Collector, Interpreter und JIT-Compiler, Klassenbibliotheken)
- Beispiele und ein Bonuskapitel unter plus.hanser-fachbuch.de
Bernhard Steppan hat mit diesem Buch einen ausführlichen Einstieg in Java mit Eclipse geschrieben. Das Buch ist vor allem für Leser ohne Programmierkenntnisse geeignet.
Der erste Teil des Buches vermittelt das Java- und Eclipse-Basiswissen und führt in die objektorientierte
Programmierung ein.
Im zweiten Teil dreht sich alles um die Feinheiten der Sprache Java. Hier entstehen die ersten kleinen Java-Anwendungen. Jedes Kapitel bietet eine Mischung aus Wissensteil und praktischen Übungen und endet mit Aufgaben, die Sie selbstständig durchführen können.
Die Technologie Java bildet den Schwerpunkt des dritten Teils. Zudem werden Ihnen Klassenbibliotheken und Algorithmen vorgestellt.
Ein größeres Java-Projekt steht im Mittelpunkt des vierten Teils. Anhand einer Anwendung mit grafischer Oberfläche werden Sie hier alle Elemente der vorigen Teile kennenlernen.
Im fünften Teil nden Sie die Lösungen zu den Aufgaben im zweiten und dritten Teil des Buches.
Ein Buch für alle, die die Java-Programmierung mithilfe der Eclipse-Entwicklungsumgebung erlernen
und beherrschen wollen.
AUS DEM INHALT //
- Programmiergrundlagen
- Objektorientierte Programmierung
- Entwicklungsumgebung
- Programmaufbau
- Variablen
- Anweisungen
- Einfache Datentypen
- Klassen und Objekte
- Aufzählungen
- Arrays
- Methoden
- Operatoren
- Verzweigungen
- Schleifen
- Pakete und Module
Sie lesen das E-Book in den Legimi-Apps auf:
Seitenzahl: 647
Das E-Book (TTS) können Sie hören im Abo „Legimi Premium” in Legimi-Apps auf:
Ähnliche
Bernhard Steppan
Einstieg in Java mit Eclipse
Ihr Plus – digitale Zusatzinhalte!
Auf unserem Download-Portal finden Sie zu diesem Titel kostenloses Zusatzmaterial.
Geben Sie auf plus.hanser-fachbuch.de einfach diesen Code ein:
plus-b304v-m70ai
Der Autor:Bernhard Steppan, Wiesbaden
Alle in diesem Buch enthaltenen Informationen, Verfahren und Darstellungen wurden nach bestem Wissen zusammengestellt und mit Sorgfalt getestet. Dennoch sind Fehler nicht ganz auszuschließen. Aus diesem Grund sind die im vorliegenden Buch enthaltenen Informationen mit keiner Verpflichtung oder Garantie irgendeiner Art verbunden. Autor und Verlag übernehmen infolgedessen keine Verantwortung und werden keine daraus folgende oder sonstige Haftung übernehmen, die auf irgendeine Art aus der Benutzung dieser Informationen und des Programm-Materials – oder Teilen davon – entsteht. Ebenso übernehmen Autor und Verlag keine Gewähr dafür, dass beschriebene Verfahren usw. frei von Schutzrechten Dritter sind.Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Buch berechtigt deshalb auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne der Warenzeichen- und Markenschutz-Gesetzgebung als frei zu betrachten wären und daher von jedermann benutzt werden dürften.
Bibliografische Information der Deutschen Nationalbibliothek:Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar.
Dieses Werk ist urheberrechtlich geschützt.Alle Rechte, auch die der Übersetzung, des Nachdruckes und der Vervielfältigung des Buches, oder Teilen daraus, vorbehalten. Kein Teil des Werkes darf ohne schriftliche Genehmigung des Verlages in irgendeiner Form (Fotokopie, Mikrofilm oder ein anderes Verfahren), auch nicht für Zwecke der Unterrichtsgestaltung – mit Ausnahme der in den §§ 53, 54 URG genannten Sonderfälle –, reproduziert oder unter Verwendung elektronischer Systeme verarbeitet, vervielfältigt oder verbreitet werden.
© 2020 Carl Hanser Verlag München, www.hanser-fachbuch.de
Lektorat: Brigitte Bauer-SchwiewekCopy editing: Jürgen Dubau, Freiburg/ElbeLayout: le-tex publishing services GmbHUmschlagdesign: Marc Müller-Bremer, www.rebranding.de, MünchenUmschlagrealisation: Max KostopoulosTitelmotiv: © istockphoto.com/JonnyJim
Print-ISBN: 978-3-446-45910-6E-Book-ISBN: 978-3-446-45976-2E-Pub-ISBN: 978-3-446-46326-4
Inhalt
Titelei
Impressum
Inhalt
Vorwort
Teil I: Grundlagen
1 Programmiergrundlagen
1.1 Einleitung
1.2 Die Sprache der Maschinenwelt
1.3 Hochsprache als Kompromiss
1.4 Entwicklungsumgebung
1.4.1 Compiler
1.4.2 Editor
1.4.3 Projektverwaltung
1.5 Laufzeitumgebung
1.6 Zusammenfassung
1.7 Aufgaben
1.8 Literatur
2 Technologieüberblick
2.1 Einleitung
2.2 Überblick
2.2.1 Die Anfangszeit von Java
2.2.2 Die Reifezeit von Java
2.2.3 Die Gegenwart von Java
2.3 Warum Java?
2.3.1 Leicht lesbar
2.3.2 Objektorientiert
2.3.3 Sicher und robust
2.3.4 Leistungsfähig
2.3.5 Universell verwendbar
2.3.6 Kostenfrei
2.3.7 Quelloffen
2.3.8 Leicht portierbar
2.3.9 Java-Programme lassen sich leicht erweitern
2.3.10 Java-Programme lassen sich leicht entwickeln und testen
2.4 Was gehört zu Java?
2.4.1 Sprache Java
2.4.2 Java Virtual Machine
2.4.3 Klassenbibliotheken
2.4.4 Java-Werkzeuge
2.5 Java-Versionen
2.6 Java-Editionen
2.6.1 Java Standard Edition
2.6.2 Java Enterprise Edition
2.6.3 Java Micro Edition
2.7 Zusammenfassung
2.8 Aufgaben
2.9 Literatur
3 Objektorientierte Programmierung
3.1 Einleitung
3.2 Überblick
3.3 Objekt
3.4 Klasse
3.4.1 Attribute
3.4.2 Methoden
3.5 Abstraktion
3.6 Vererbung
3.6.1 Basisklassen
3.6.2 Abgeleitete Klassen
3.6.3 Mehrfachvererbung
3.7 Sichtbarkeit
3.8 Beziehungen
3.8.1 Beziehungen ohne Vererbung
3.8.2 Vererbungsbeziehungen
3.9 Designfehler
3.10 Umstrukturierung
3.11 Modellierung
3.12 Persistenz
3.13 Polymorphie
3.13.1 Statische Polymorphie
3.13.2 Dynamische Polymorphie
3.14 Designregeln
3.15 Zusammenfassung
3.16 Aufgaben
3.17 Literatur
4 Entwicklungsumgebung
4.1 Einleitung
4.2 Installation
4.2.1 Betriebssystem
4.2.2 Java installieren
4.2.3 Eclipse installieren
4.2.4 Beispielprogramme installieren
4.2.5 Installation überprüfen
4.3 Einführung in Eclipse
4.3.1 Überblick
4.3.2 Workbench
4.3.3 Perspektiven, Sichten und Editoren
4.3.4 Package Explorer
4.3.5 Java-Editor
4.3.6 Code-Formatierer
4.3.7 Build-System
4.3.8 Debugger
4.3.9 Modularer Aufbau
4.3.10 Eclipse-Workspace
4.3.11 Softwareaktualisierung
4.3.12 Hilfesystem
4.4 Zusammenfassung
4.5 Aufgaben
4.6 Literatur
Teil II: Sprache Java
5 Programmaufbau
5.1 Einleitung
5.2 Überblick
5.3 Sprachelemente des Programms
5.3.1 Kommentar
5.3.2 Pakete
5.3.3 Klassen
5.3.4 Methoden
5.3.5 Anweisungen
5.4 Struktur des Programms
5.5 Ablauf des Programms
5.6 Reservierte Schlüsselwörter
5.7 Zusammenfassung
5.8 Übungen
5.8.1 Eclipse starten
5.8.2 Workspace »Uebungen« auswählen
5.8.3 Dialog »New Java Project« aufrufen
5.8.4 Module abwählen und ein neues Projekt erzeugen
5.8.5 Dialog »New Java Class« aufrufen
5.8.6 Klasse »Person« erzeugen
5.8.7 Entwicklungsumgebung einrichten
5.8.8 Perspektive speichern
5.8.9 Attribut einfügen
5.8.10 Konstruktor erzeugen
5.8.11 Getter und Setter erzeugen
5.8.12 Klasse »Programmdemo« erzeugen
5.8.13 Klasse »Programmdemo« komplettieren
5.8.14 Programm starten
5.9 Aufgaben
6 Variablen
6.1 Einleitung
6.2 Überblick
6.2.1 Zweck von Variablen
6.2.2 Arten von Variablen
6.2.3 Verwendung von Variablen
6.3 Lokale Variablen
6.4 Parameter
6.5 Objektvariablen
6.5.1 Individuelle Objektvariablen
6.5.2 Objektvariable »this«
6.6 Klassenvariablen
6.7 Konstanten
6.8 Zusammenfassung
6.9 Übungen
6.9.1 Eclipse starten
6.9.2 Projekt kopieren
6.9.3 Attribut einfügen
6.9.4 Attribut umbenennen
6.9.5 Konstruktor anpassen
6.9.6 Klasse »Programmdemo« anpassen
6.9.7 Programm starten
6.10 Aufgaben
6.11 Literatur
7 Anweisungen
7.1 Einleitung
7.2 Überblick
7.2.1 Zweck von Anweisungen
7.2.2 Arten von Anweisungen
7.3 Deklaration
7.4 Zuweisung
7.4.1 Aufbau der Java-Zuweisung
7.4.2 Java-Zuweisung ungleich mathematische Gleichungen
7.4.4 Kombination aus Deklaration und Wertzuweisung
7.5 Block
7.6 Variablenaufruf
7.7 Methodenaufruf
7.8 Zusammenfassung
7.9 Übungen
7.9.1 Eclipse starten
7.9.2 Projekt kopieren
7.9.3 Anweisung einfügen
7.9.4 Klasse »Programmdemo« anpassen
7.9.5 Programm starten
7.10 Aufgaben
7.11 Literatur
8 Einfache Datentypen
8.1 Einleitung
8.2 Überblick
8.2.1 Zweck von einfachen Datentypen
8.2.2 Arten von einfachen Datentypen
8.2.3 Verwendung von einfachen Datentypen
8.3 Ganzzahlen
8.3.1 Datentyp »byte«
8.3.2 Datentyp »short«
8.3.3 Datentyp »int«
8.3.4 Datentyp »long«
8.4 Kommazahlen
8.4.1 Datentyp »float«
8.4.2 Datentyp »double«
8.5 Zeichen
8.6 Wahrheitswerte
8.7 Zusammenfassung
8.8 Übungen
8.8.1 Eclipse starten
8.8.2 Projekt kopieren
8.8.3 Attribute einfügen
8.8.4 Dateien im Editor schließen
8.8.5 Konstruktor anpassen
8.8.6 Konstruktoraufruf anpassen
8.8.7 Abfragemethode erzeugen
8.8.8 Programmausgabe anpassen
8.8.9 Programm starten
8.8.10 Startkonfigurationen aufräumen
8.9 Aufgaben
8.10 Literatur
9 Klassen und Objekte
9.1 Einleitung
9.2 Überblick
9.2.1 Zweck einer Klasse
9.2.2 Arten von Klassen
9.2.3 Definition von Klassen
9.2.4 Verwendung von Klassen
9.3 Konkrete Klasse
9.3.1 Konkrete Klasse definieren
9.3.2 Objekte einer konkreten Klasse erzeugen
9.3.3 Innere Klasse
9.3.4 Lokale Klasse
9.3.5 Anonyme Klasse
9.3.6 Vererbung
9.4 Abstrakte Klassen
9.5 Interfaces
9.6 Generics
9.6.1 Generische Klasse definieren
9.6.2 Objekte erzeugen
9.7 Zusammenfassung
9.8 Übungen
9.8.1 Eclipse starten
9.8.2 Projekt kopieren
9.8.3 Dateien schließen
9.8.4 Neue Klasse extrahieren
9.8.5 Methode »getName()« verändern
9.8.6 Attribut »name« anlegen
9.8.7 Klasse »Person« umbenennen
9.8.8 Startkonfiguration anpassen
9.8.9 Hauptprogramm »Programmdemo« ausführen
9.8.10 Konstruktor »Wesen« anpassen
9.8.11 Konstruktor »Mensch« anpassen
9.8.12 Programm »Programmdemo« erneut starten
9.9 Aufgaben
9.10 Literatur
10 Aufzählungen
10.1 Einleitung
10.2 Überblick
10.2.1 Zweck von Enums
10.2.2 Definition und Deklaration von Enums
10.2.3 Verwendung von Enums
10.3 Aufzählungsklassen
10.3.1 Konstruktor
10.3.2 Methode »value()«
10.3.3 Eigenständige einfache Enum-Klasse
10.3.4 Eigenständige erweiterte Enum-Klasse
10.3.5 Innere erweiterte Enum-Klasse
10.4 Zusammenfassung
10.5 Übungen
10.5.1 Eclipse starten
10.5.2 Projekt kopieren
10.5.3 Dateien schließen
10.5.4 Dialog »New Enum« aufrufen
10.5.5 Enum-Klasse »Anrede« erzeugen
10.5.6 Elemente einfügen
10.5.7 Konstruktor erzeugen
10.5.8 Tasks anzeigen
10.5.9 Konstruktor erweitern
10.5.10 Attribut »name« als Objektvariable einfügen
10.5.11 Methode »toString()« überschreiben
10.5.12 Methode »toString()« erweitern
10.5.13 Attribut »anrede« hinzufügen
10.5.14 Konstruktor der Klasse »Wesen« erweitern
10.5.15 Abfragemethode »getAnrede()« erzeugen
10.5.16 Konstruktor der Klasse »Mensch« erweitern
10.5.17 Klasse »Programmdemo« erweitern
10.5.18 Programm starten
10.6 Aufgaben
10.7 Literatur
11 Arrays
11.1 Einleitung
11.2 Überblick
11.2.1 Zweck von Arrays
11.2.2 Arten von Arrays
11.2.3 Verwendung von Arrays
11.3 Zusammenfassung
11.4 Übungen
11.4.1 Eclipse starten
11.4.2 Projekt kopieren
11.4.3 Dateien schließen
11.4.4 Klasse »Roboter« erzeugen
11.4.5 Klasse »Programmdemo« erweitern
11.4.6 Vorüberlegungen zum Aufbau des Arrays
11.4.7 Deklaration und Zuweisung
11.4.8 Array-Objekte erzeugen
11.4.9 Fehler mit Suchen und Ersetzen beseitigen
11.4.10 Cast einfügen
11.4.11 Weitere Teammitglieder hinzufügen
11.4.12 Programm starten
11.5 Aufgaben
12 Methoden
12.1 Einleitung
12.2 Überblick
12.2.1 Zweck von Methoden
12.2.2 Arten von Methoden
12.2.3 Definition von Methoden
12.2.4 Verwendung von Methoden
12.3 Konstruktoren
12.3.1 Standardkonstruktoren
12.3.2 Konstruktoren ohne Parameter
12.3.3 Konstruktoren mit Parametern
12.4 Destruktoren
12.5 Operationen
12.6 Abfragemethoden
12.6.1 Definition
12.6.2 Verwendung
12.7 Änderungsmethoden
12.7.1 Definition
12.7.2 Verwendung
12.8 Zusammenfassung
12.9 Übungen
12.9.1 Eclipse starten
12.9.2 Projekt kopieren
12.9.3 Dateien schließen
12.9.4 Methoden der Klasse »Wesen« erzeugen
12.9.5 Quellcode der Klasse »Wesen« kontrollieren
12.9.6 Sortierung der Klasse gegebenenfalls ändern
12.9.7 Konstruktor der Klasse »Mensch« erzeugen
12.9.8 Quellcode der Klasse »Mensch« vergleichen
12.9.9 Konstruktor in »Programmdemo« tauschen
12.9.10 Programm starten
12.10 Aufgaben
12.11 Literatur
13 Operatoren
13.1 Einleitung
13.2 Überblick
13.3 Arithmetische Operatoren
13.3.1 Positives Vorzeichen
13.3.2 Negatives Vorzeichen
13.3.3 Additionsoperator
13.3.4 Differenzoperator
13.3.5 Divisionsoperator
13.3.6 Modulo-Operator
13.3.7 Präinkrement-Operator
13.4 Vergleichende Operatoren
13.5 Logische Operatoren
13.5.1 Nicht-Operator
13.5.2 Und-Operator
13.6 Bitweise Operatoren
13.7 Zuweisungsoperatoren
13.8 Fragezeichenoperator
13.9 New-Operator
13.10 Cast-Operator
13.11 Zugriffsoperatoren
13.11.1 Punktoperator
13.11.2 Lambda-Operator
13.12 Zusammenfassung
13.13 Übungen
13.13.1 Eclipse starten
13.13.2 Projekt kopieren
13.13.3 Dateien schließen
13.13.4 Methode »ermittleStudentenstatus()« erzeugen
13.13.5 Methode »main()« verändern
13.13.6 Konstruktor der Klasse »Mensch« erzeugen
13.13.7 Konstruktor »Mensch« implementieren
13.13.8 Klasse »Programmdemo« kontrollieren
13.13.9 Programm starten
13.13.10 Startkonfiguration anpassen
13.14 Aufgaben
13.15 Literatur
14 Verzweigungen
14.1 Einleitung
14.2 Überblick
14.3 If-Verzweigung
14.4 Fragezeichenoperator-Verzweigung
14.5 Switch-Verzweigung
14.5.1 Beschränkung auf wenige Datentypen
14.5.2 Auswahl über Strings
14.5.3 Yield-Anweisung
14.5.4 Lambda-Operator
14.6 Zusammenfassung
14.7 Übungen
14.7.1 Eclipse starten
14.7.2 Projekt kopieren
14.7.3 Dateien schließen
14.7.4 Klasse »Anrede« verändern
14.7.5 Klasse »Anrede« kopieren
14.7.6 Fehlerhafte Klasse »Programmdemo« aufrufen
14.7.7 Aufzählungstyp »Geschlecht« einfügen
14.7.8 Konstruktoren der Klasse »Mensch« verändern
14.7.9 Klasse »Wesen« anpassen
14.7.10 Klasse »Wesen« kontrollieren
14.7.11 Klasse »Roboter« anpassen
14.7.12 Klasse »Mensch« anpassen
14.7.13 Klasse »Programmdemo« kontrollieren
14.7.14 Methode »ermittleAnrede()« einfügen
14.7.15 Methode »main()« ändern
14.7.16 Programm starten
14.7.17 Startkonfiguration anpassen
14.8 Aufgaben
14.9 Literatur
15 Schleifen
15.1 Einleitung
15.2 Überblick
15.2.1 Zweck von Schleifen
15.2.2 Arten von Schleifen
15.3 While-Schleife
15.4 Do-Schleife
15.5 Einfache For-Schleife
15.6 Erweiterte For-Schleife
15.7 Zusammenfassung
15.8 Übungen
15.8.1 Vorüberlegungen
15.8.2 Eclipse starten
15.8.3 Projekt kopieren
15.8.4 Dateien im Editor schließen
15.8.5 Erzeugen der Personenobjekte ergänzen
15.8.6 Redundanzen erkennen
15.8.7 Schleife erzeugen
15.8.8 Index in den Schleifenkörper übertragen
15.8.9 Schleife optimieren
15.8.10 Programm starten
15.8.11 Startkonfiguration anpassen
15.9 Aufgaben
15.10 Literatur
16 Pakete und Module
16.1 Einleitung
16.2 Überblick
16.3 Pakete
16.3.1 Klassenimport
16.3.2 Namensräume
16.4 Module
16.5 Zusammenfassung
16.6 Übungen
16.6.1 Eclipse starten
16.6.2 Projekt kopieren
16.6.3 Dateien im Editor schließen
16.6.4 Dialog »Rename Package« aufrufen
16.6.5 Paket »programmierkurs« umbenennen
16.6.6 Auswirkungen des Refactorings kontrollieren
16.6.7 Dialog »New Package« aufrufen
16.6.8 Neues Paket erzeugen
16.6.9 Restliche Klassen in ein neues Paket verschieben
16.6.10 Refactoring im »Package Explorer« kontrollieren
16.6.11 Änderungen an der Klasse »Programmdemo« kontrollieren
16.6.12 Programm starten
16.6.13 Startkonfiguration anpassen
16.7 Aufgaben
17 Fehlerbehandlung
17.1 Einleitung
17.2 Überblick
17.2.1 Motivation
17.2.2 Arten von Fehlern
17.2.3 Verwendung des Exception Handlings
17.3 Basisklasse »Throwable«
17.4 Klasse »Error«
17.4.1 Subklasse »OutOfMemoryError«
17.4.2 Subklasse »StackOverflowError«
17.5 Klasse »Exception«
17.5.1 Subklasse »RuntimeException«
17.5.2 Subklasse »IOException«
17.5.3 Eigene Exceptions
17.6 Zusammenfassung
17.7 Übungen
17.7.1 Vorüberlegungen
17.7.2 Eclipse starten
17.7.3 Projekt kopieren
17.7.4 Dateien im Editor schließen
17.7.5 Neue Java-Klasse anlegen
17.7.6 Klasse »WahlpflichtfachNichtBelegtException« kontrollieren
17.7.7 Klasse »Person« erweitern
17.7.8 Konstruktor auf fünf Parameter erweitern
17.7.9 Getter-Methode erzeugen
17.7.10 Klasse »Programmdemo« erweitern
17.7.11 Programm starten
17.7.12 Startkonfiguration anpassen
17.8 Aufgaben
17.9 Literatur
18 Dokumentation
18.1 Einleitung
18.2 Überblick
18.3 Zeilenkommentare
18.4 Blockkommentare
18.5 Dokumentationskommentare
18.6 Zusammenfassung
18.7 Übungen
18.7.1 Eclipse starten
18.7.2 Projekt kopieren
18.7.3 Dateien im Editor schließen
18.7.4 Javadoc erzeugen
18.7.5 Autorenname
18.7.6 Javadoc in Eclipse anzeigen
18.7.7 Blockkommentar erzeugen
18.7.8 Zeilenbezogenen Kommentar erzeugen
18.7.9 Tasks
18.8 Aufgaben
18.9 Literatur
Teil III: Plattform Java
19 Entwicklungsprozesse
19.1 Einleitung
19.2 Überblick
19.2.1 Zusammenhang zwischen Phasen und Aktivitäten
19.2.2 Aktivitäten
19.2.3 Werkzeuge
19.3 Planungsphase
19.3.1 Auftragsklärung
19.3.2 Anforderungsaufnahme
19.4 Konstruktionsphase
19.4.1 Analyse
19.4.2 Design
19.4.3 Implementierung
19.4.4 Test
19.5 Betriebsphase
19.5.1 Verteilung
19.5.2 Pflege
19.6 Zusammenfassung
19.7 Aufgaben
19.8 Literatur
20 Laufzeitumgebung
20.1 Einleitung
20.2 Überblick
20.3 Bytecode
20.4 Java Virtual Machine
20.4.1 Künstlicher Computer
20.4.2 Interpreter-Modus
20.4.3 JIT-Compiler-Modus
20.4.4 Hotspot-Modus
20.4.5 Garbage Collector
20.5 Bibliotheken
20.5.1 Native Bibliotheken
20.5.2 Klassenbibliotheken
20.5.3 Ressourcen und Property-Dateien
20.6 Portabilität eines Java-Programms
20.6.1 Binärkompatibler Bytecode
20.6.2 Voraussetzungen beim Portieren
20.7 Programmstart
20.7.1 Startskript
20.7.2 Nativer Wrapper
20.8 JVM-Konfiguration
20.9 Zusammenfassung
20.10 Aufgaben
20.11 Literatur
21 Klassenbibliotheken
21.1 Einleitung
21.2 Überblick
21.2.1 Einsatzbereiche
21.2.2 Wiederverwendung
21.2.3 Dokumentation
21.2.4 Spracherweiterung
21.2.5 Arten von Klassenbibliotheken
21.3 Java Standard Edition
21.3.1 Basisklassen
21.3.2 Klasse »System«
21.3.3 Threads
21.3.4 Streams
21.3.5 Properties
21.3.6 Container-Klassen
21.3.7 Abstract Windowing Toolkit
21.3.8 Swing
21.3.9 JavaBeans
21.3.10 Applets
21.3.11 Java Database Connectivity (JDBC)
21.3.12 Java Native Interface
21.3.13 Remote Method Invocation
21.4 Java Enterprise Edition
21.4.1 Entity Beans
21.4.2 Session Beans
21.4.3 Message Driven Beans
21.4.4 Schnittstellen
21.5 Java Micro Edition
21.6 Externe Klassenbibliotheken
21.6.1 Apache Software Foundation
21.6.2 Eclipse Community
21.6.3 SourceForge
21.6.4 Weitere quelloffene Software
21.6.5 Kommerzielle Software
21.7 Zusammenfassung
21.8 Aufgaben
21.9 Literatur
22 Gesetzmäßigkeiten
22.1 Einleitung
22.2 Überblick
22.3 Schreibweisen
22.4 Sichtbarkeit
22.4.1 Vier Sichtbarkeitsbereiche
22.4.2 Sichtbarkeit »private«
22.4.3 Sichtbarkeit »default«
22.4.4 Sichtbarkeit »protected«
22.4.5 Sichtbarkeit »public«
22.4.6 Fallbeispiel
22.4.7 Gültigkeitsbereich von Variablen
22.5 Auswertungsreihenfolge
22.5.1 Punkt vor Strich
22.5.2 Punkt vor Punkt
22.6 Typkonvertierung
22.6.1 Implizite Konvertierung
22.6.2 Explizite Konvertierung
22.7 Polymorphie
22.7.1 Überladen von Methoden
22.7.2 Überschreiben von Methoden
22.8 Zusammenfassung
22.9 Aufgaben
22.10 Literatur
23 Algorithmen
23.1 Einleitung
23.2 Überblick
23.2.1 Algorithmen entwickeln
23.2.2 Algorithmenarten
23.2.3 Algorithmen verwenden
23.3 Algorithmen entwickeln
23.3.1 Sortieralgorithmen
23.3.2 Grafikalgorithmen
23.4 Algorithmen verwenden
23.4.1 Sortieralgorithmen
23.4.2 Suchalgorithmen
23.5 Zusammenfassung
23.6 Aufgaben
23.7 Literatur
Teil IV: Java-Projekte
24 Swing-Programme
24.1 Einleitung
24.2 Anforderungen
24.3 Analyse und Design
24.3.1 Programmaufbau
24.3.2 Programmfunktionen
24.4 Implementierung
24.4.1 Eclipse mit dem Workspace »Uebungen« starten
24.4.2 Neues Java-Projekt »Swing-Programme« erzeugen
24.4.3 Neue Klasse »KursstatistikApp« erzeugen
24.4.4 Klasse »KursstatistikApp« implementieren
24.4.5 Neue Klasse »Hauptfenster« erzeugen
24.4.6 Klasse »Hauptfenster« implementieren
24.4.7 Klasse »CsvParser« implementieren
24.4.8 Klasse »Tabellenfilter« implementieren
24.5 Test
24.6 Verteilung
24.7 Zusammenfassung
Teil V: Anhang
25 Lösungen
zu Kapitel 1: Programmiergrundlagen
zu Kapitel 2: Technologieüberblick
zu Kapitel 3: Objektorientierte Programmierung
zu Kapitel 4: Entwicklungsumgebung
zu Kapitel 5: Programmaufbau
zu Kapitel 6: Variablen
zu Kapitel 7: Anweisungen
zu Kapitel 8: Einfache Datentypen
zu Kapitel 9: Klassen und Objekte
zu Kapitel 10: Aufzählungen
zu Kapitel 11: Arrays
zu Kapitel 12: Methoden
zu Kapitel 13: Operatoren
zu Kapitel 14: Verzweigungen
zu Kapitel 15: Schleifen
zu Kapitel 16: Pakete und Module
zu Kapitel 17: Fehlerbehandlung
zu Kapitel 18: Dokumentation
zu Kapitel 19: Entwicklungsprozesse
zu Kapitel 20: Laufzeitumgebung
zu Kapitel 21: Klassenbibliotheken
zu Kapitel 22: Gesetzmäßigkeiten
zu Kapitel 23: Algorithmen
26 Bits und Bytes
26.1 Einleitung
26.2 Zahlensysteme
26.2.1 Dezimalsystem
26.2.2 Binärsystem
26.2.3 Hexadezimalsystem
26.3 Informationseinheiten
26.3.1 Bit
26.3.2 Byte
26.3.3 Wort
26.4 Kodierung von Zeichen
26.5 Kodierung logischer Informationen
26.5.1 Und-Funktion
26.5.2 Oder-Funktion
26.5.3 Nicht-Funktion
26.6 Zusammenfassung
27 Häufige Fehler
27.1 Einleitung
27.2 Java-Fehler
27.2.1 Cannot make a static reference to the non-static field
27.2.2 Ausgabe des Werts »null«
27.2.3 NullPointerException
27.2.4 Fehlendes Break in Case-Anweisung
27.2.5 Fehlerhafter Vergleich
27.2.6 Exception ignorieren
27.2.7 NoClassDefFoundError
27.2.8 ClassNotFoundException
27.3 Eclipse-Fehler
27.3.1 Eclipse konnte nicht gestartet werden
27.3.2 Chaotische Perspektive
27.3.3 Fehlendes Fenster
27.4 Zusammenfassung
27.5 Literatur
28 Glossar
TEIL I
Grundlagen
Um Computerprogramme entwickeln zu können, müssen Sie die Grundlagen beherrschen. Das Kapitel »Programmiergrundlagen« legt die Grundlagen zum Programmieren von Java-Anwendungen. In Kapitel 2, »Technologieüberblick«, erfahren Sie, was Java mit anderen Programmiersprachen gemeinsam hat und wie sich Java von anderen Sprachen abhebt.
Abbildung 1Um Computerprogramme zu entwickeln, müssen Sie die Grundlagen beherrschen.
Danach geht es mit dem Kapitel »Entwicklungsumgebung« weiter, das die Eclipse-Entwicklungsumgebung vorstellt. Die Kapitel »Programmaufbau« und »Objektorientierte Programmierung« zeigen, wie Java-Programme aufgebaut sind und was Objektorientierung bedeutet.
Programmieren bedeutet, Computerprogramme zu schreiben. Computerprogramme bestehen aus einem oder mehreren Befehlen in einer Programmiersprache. Der Roboter Robert stellt den Studentinnen und Studenten des Programmierkurses von Professor Roth ein einfaches Java-Programm vor (Abbildung 1.1).
Abbildung 1.1Robert aus der Maschinenwelt ist der Experte für Maschinenprogramme.
Die Studentinnen und Studenten des Programmierkurses finden, dass es doch sehr viele Anweisungen für ein so einfaches Programm sind. Anna möchte von Professor Roth wissen, ob es nicht noch einfacher geht:
Abbildung 1.2Heute noch Programme abtippen, ist das wirklich noch zeitgemäß?
Auch Alexa, Cortana und Siri, sagt Professor Roth, sind nur Computerprogramme. Diese Programme wurden entwickelt, damit der Mensch den Computer über Sprache steuern kann. Alexa und Co. können aber nur die wenigen Aufgaben erledigen, für die sie speziell programmiert wurden. Möchte man, dass der Computer andere Aufgaben wie zum Beispiel eine Textverarbeitung ausführt, muss man ein spezielles Programm dafür schreiben. Diese Programme lassen sich zum Beispiel in Java entwickeln.
1.2Die Sprache der MaschinenweltWenn wir heute von Computern sprechen, so meinen wir immer Digitalcomputer. Diese Maschinen verstehen nur ihre digitale Maschinensprache. Digital bedeutet, dass der Computer für sämtliche Informationen den Binärcode verwendet. Daher besteht die Maschinensprache des Computers nur aus einer Folge von Nullen und Einsen.
Die Maschinensprache des Computers mit ihren Folgen von Nullen und Einsen ist für den Menschen jedoch nur extrem schwer verständlich. Computer direkt im Maschinencode zu programmieren, wäre daher vollkommen abwegig. Man würde sehr lange dazu benötigen, und die Wahrscheinlichkeit von Fehlern wäre hoch.
Wenn man den Computer maschinennah programmieren möchte, verwendet man dazu eine Hilfssprache. Diese Hilfssprache nennt sich Assembler-Sprache oder auch kurz Assembler. Professor Roth präsentiert seinem Programmierkurs ein einfaches Beispiel. Es gibt wie das Java-Programm zuvor lediglich die Zeichenfolge »Hallo!« auf dem Bildschirm aus (Abbildung 1.3).
Professor Roths Programmierkurs findet das Assembler-Programm ziemlich schwer verständlich. Wie konnten nur Programmierer eine so furchtbare Sprache erlernen? Die Antwort ist einfach, denn in der Anfangszeit der Computer gab es noch keine Hochsprachen wie Java. Die Programmierer mussten sich sehr genau mit den Prozessoren des Computers beschäftigen, wenn sie die Maschine in Assembler programmierten.
Abbildung 1.3Dieses Assembler-Programm gibt ebenfalls »Hallo!« aus.
Assembler-Programme sind im Vergleich zu funktional gleichwertigen Java-Programmen viel länger. Sie bestehen aus vielen kleinteiligen Befehlen, die allein genommen nur wenig bewirken. Daher benötigt man viele dieser Befehle, um ein größeres Programm zu schreiben. Dieses Programm ist speziell für einen Computertyp geschrieben. Es lässt sich schlecht auf einen anderen Computertyp übertragen.
Neben dem hohen Aufwand für die Entwicklung solcher Programme ist es ein Hauptnachteil der Assembler-Sprache, dass sie nur schwer von einem Computertyp auf einen anderen zu übertragen ist. Die kleinteiligen Befehle haben aber nicht nur Nachteile. Sie besitzen den Vorteil, dass ein guter Programmierer damit sehr schlanke und schnelle Maschinenprogramme erzeugen kann. Sie benötigen zudem oftmals weit weniger Hauptspeicher als vergleichbare Programme, die in einer Hochsprache geschrieben wurden.
1.3Hochsprache als KompromissEs scheint irgendwie verhext zu sein: Computer verstehen nur ihre spezielle Maschinensprache.Wir hingegen verstehen ohne spezielles Programmiertraining nur unsere Muttersprache und vielleicht noch die eine oder andere Fremdsprache. Wie kann man diese große Kluft zwischen der Maschinenwelt und der Welt der Menschen überbrücken?
Wir können entweder noch leistungsfähigere Programme als Alexa, Cortana und Siri entwickeln, damit die Computer alles ausführen, was wir wollen. Oder wir lernen die Sprache des Computers, wenn wir spezielle Programme für Aufgaben entwickeln möchten, die Alexa & Co. nicht beherrschen – nein, das sind nicht die einzigen Möglichkeiten, denn es gibt glücklicherweise noch einen dritten Weg.
Ein komplexes Programm in Assembler zu programmieren, ist nicht mehr zeitgemäß. Daher hat man schon sehr früh begonnen, Programmiersprachen wie Java zu entwickeln. Diese Sprachen bilden eine Brücke zwischen der (für die meisten Menschen) schwer verständlichen Maschinensprache und der (für die meisten Maschinen) schwer verständlichen menschlichen Sprache. Diese Sprachen nennen sich Hochsprachen.
Abbildung 1.4Hochsprachen sind Mittler zwischen Mensch und Maschine.
Hochsprachen sind für einen Menschen wesentlich einfacher zu erlernen und zu verstehen als die Sprache der Maschinenwelt. Aber wie funktioniert das? Wie übersetzt man eine Hochsprache in die Sprache der Maschinenwelt? Dazu hat man sich einen Trick überlegt. Dieser Trick ist ein spezielles Programm, das den Quellcode einer Hochsprache wie Java in die Sprache der Maschinenwelt übersetzt. Dieses Programm wird Compiler genannt und ist Bestandteil einer Entwicklungsumgebung.
1.4Entwicklungsumgebung1.4.1CompilerDer Compiler ist einer der Kernbestandteile einer Entwicklungsumgebung wie Eclipse. Er überträgt den Quellcode eines Java-Programms in die Sprache der Maschinenwelt. Der Quellcode ist der Text, der in den Abbildungen 1.1 und 1.3 zu sehen war.
1.4.2EditorIm Editor geben Sie den Quellcode eines Programms wie in einer Textverarbeitung ein. Ein Editor bietet darüber hinaus auch Unterstützung bei der Programmentwicklung wie zum Beispiel Ratschläge, wie man die angezeigten Fehler beheben kann.
Abbildung 1.5Editor, Compiler und Projektverwaltung der Eclipse-Entwicklungsumgebung
Java-Programme bestehen in der Regel aus einer Vielzahl von Dateien. Damit Sie den Überblick nicht verlieren, besitzt die Java-Entwicklungsumgebung eine Projektverwaltung. Sie zeigt an, welche Dateien zu einem Projekt gehören.
1.5LaufzeitumgebungJava-Programme benötigen eine spezielle Laufzeitumgebung. Mit anderen Worten: Java-Programme laufen nur mit einem zusätzlichen Programm auf Ihrem Computer. Davon merken Sie erst einmal nichts, denn die Eclipse-Entwicklungsumgebung ruft diese Laufzeitumgebung im Hintergrund auf, wenn Sie ein Java-Programm ausführen. Um zu verstehen, was es mit dieser Laufzeitumgebung auf sich hat, blättern Sie zum nächsten Kapitel. Es zeigt Ihnen, wie sich Java entwickelt hat und warum eine Java-Laufzeitumgebung überhaupt notwendig ist.
1.6ZusammenfassungProgrammieren bedeutet, Computerprogramme zu schreiben. Computerprogramme bestehen aus einem oder mehreren Befehlen in einer Programmiersprache. Diese Befehle werden in Form eines Textes verfasst. In der Programmierung heißt dieser Text Quellcode. Computer erwarten die Befehle in Maschinensprache. Wir sprechen hingegen in unserer menschlichen Sprache. Um diese Lücke zu schließen, haben Informatiker Hochsprachen entwickelt. Java ist eine dieser Hochsprachen.
Abbildung 1.6Computerprogramme bestehen aus Befehlen einer Programmiersprache.
Um ein Hochsprachen-Programm in Maschinensprache zu übersetzen, damit der Computer es ausführen kann, benötigen Sie ein Zusatzprogramm. Dieses Übersetzungsprogramm heißt Compiler. Der Compiler ist Teil der Entwicklungsumgebung. Diese besteht (unter anderem) noch aus einem Editor und einer Projektverwaltung. Mithilfe des Editors schreibt man den Quellcode eines Programms. Die Projektverwaltung verwaltet die verschiedenen Dateien, die zu einem Projekt gehören.
1.7AufgabenWie nennt sich die Programmiersprache, mit der man »maschinennah« programmiert?
Zu welcher Art von Programmiersprachen gehört Java?
Was ist ein Compiler und welche Aufgabe erfüllt er?
Wozu dient ein Editor?
Wozu ist eine Projektverwaltung innerhalb einer Entwicklungsumgebung notwendig?
Was ist eine Laufzeitumgebung?
Die Lösungen zu den Aufgaben finden Sie in Kapitel 25, »Lösungen«, ab Seite 585.
1.8LiteraturBernhard Steppan: Eine kleine Geschichte der Programmiersprachen; http://www.computerwoche.de/a/3545761
