
Einstieg in Java mit Eclipse
Description
Alles über E-Books | Antworten auf Fragen rund um E-Books, Kopierschutz und Dateiformate finden Sie in unserem Info- & Hilfebereich.
More details
Other editions
Additional editions


Person
ISNI: 0000 0003 5544 9289
Content
- Intro
- 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.3 Ist x = y gleich y = x?
- 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
- Stichwortverzeichnis
System requirements
File format: PDF
Copy protection: Watermark-DRM (Digital Rights Management)
System requirements:
- Computer (Windows; MacOS X; Linux): Use the free software Adobe Reader, Adobe Digital Editions, or any other PDF viewer of your choice (see eBook Help).
- Tablet/Smartphone (Android; iOS): Install the free app Adobe Digital Editions or another reading app for eBooks, e.g., PocketBook (see eBook Help).
- E-reader: Bookeen, Kobo, Pocketbook, Sony, Tolino and many more (only limited: Kindle).
The file format PDF always displays a book page identically on any hardware. This makes PDF suitable for complex layouts such as those used in textbooks and reference books (images, tables, columns, footnotes). Unfortunately, on the small screens of e-readers or smartphones, PDFs are rather annoying, requiring too much scrolling.
This eBook uses Watermark-DRM, a „soft” copy protection. This means that there are no technical restrictions to prevent illegal distribution. However, there is a personalised watermark embedded in the eBook that can be used to identify the purchaser of the eBook in the event of misuse and to provide evidence for legal purposes.
For more information, see our eBook Help page.