Einführung in Java mit BlueJ - s3-eu-west-1.amazonaws.com · Florian Siebler Einführung in Java...

Florian Siebler

Einführung in Java mit BlueJObjektorientierte Programmierung für Einsteiger

3

Auf einen Blick

TEIL I Grundlagen

1 Einführung ................................................................ 25

2 Installation und Konfiguration von Java und BlueJ ..... 37

3 Erste Schritte in Java ................................................. 49

4 Variablen, Datentypen und Operatoren ..................... 65

5 Bedingungen und Vergleiche ..................................... 107

6 Schleifen und Wiederholungen ................................. 133

7 Anwendungsbeispiel: Geburtstagskalender ................ 153

TEIL II Objektorientierte Programmierung

8 Grundlegende Aspekte der OOP ............................... 167

9 Vererbung und Polymorphie ..................................... 223

10 Erweiterte Konzepte der OOP ................................... 267

TEIL III Grafische Benutzeroberflächen

11 Einführung in die GUI-Programmierung ..................... 319

12 Steuerelemente und Layout ....................................... 347

13 Erweiterte Konzepte von Swing ................................. 407

TEIL IV Fortgeschrittene Themen

14 Ausnahmebehandlung – Exceptions .......................... 461

15 Collections und Generics ........................................... 487

16 Nebenläufigkeit ......................................................... 523

17 Dateien, Datenströme, Serialisieren ........................... 545

18 Netzwerke ................................................................ 583

19 Datenbanken ............................................................ 609

Inhalt

Geleitwort des Fachgutachters ...................................................... 17Vorwort ........................................................................................ 19

TEIL I: GRUNDLAGEN

1 Einführung ................................................................ 25

1.1 Was ist ein Algorithmus? ............................................ 251.2 Was haben Sie mit Algorithmen zu tun? ..................... 271.3 Beispiele für Algorithmen ........................................... 271.4 Wie arbeitet ein Computer? ........................................ 291.5 Überblick über Java und den Entwicklungsprozess ...... 311.6 Ist Java der Weisheit letzter Schluss? .......................... 321.7 Was bedeutet Objektorientierung? ............................. 331.8 Das Wichtigste auf einen Blick .................................... 351.9 Übungen .................................................................... 36

2 Installation und Konfiguration von Java und BlueJ 37

2.1 Java installieren .......................................................... 372.2 BlueJ installieren ......................................................... 392.3 BlueJ konfigurieren ..................................................... 402.4 Erste Schritte mit BlueJ ............................................... 40

2.4.1 Das erste Projekt anlegen ............................... 402.4.2 Die erste Klasse anlegen ................................. 412.4.3 Quelltext einer Klasse bearbeiten ................... 42

2.5 Weitere Features von BlueJ ......................................... 452.5.1 Projekte dokumentieren ................................. 452.5.2 Projekte drucken ............................................ 462.5.3 Programme weitergeben ................................ 46

2.6 Übungen .................................................................... 47

3 Erste Schritte in Java ................................................ 49

3.1 Der Rahmen einer Klasse ............................................ 493.2 Klassen in der Objektorientierung ............................... 51

3.2.1 Attribute ........................................................ 513.2.2 Methoden ...................................................... 52

5

Inhalt

3.2.3 Optional: Parameter und Rückgabewert ........ 543.2.4 Abschließendes zu Methoden ........................ 553.2.5 Blöcke ........................................................... 56

3.3 Ein Objekt erzeugen ................................................... 573.4 Kommentare .............................................................. 593.5 Das Wichtigste auf einen Blick ................................... 623.6 Übungen .................................................................... 63

4 Variablen, Datentypen und Operatoren .................. 65

4.1 Variablen deklarieren ................................................. 654.1.1 Bezeichner ..................................................... 664.1.2 Datentypen ................................................... 68

4.2 Arten von Variablen ................................................... 804.2.1 Finale und variable Variablen ......................... 814.2.2 Möglichkeiten der Deklaration ...................... 82

4.3 Operatoren ................................................................ 884.4 Arithmetische Operatoren .......................................... 89

4.4.1 Priorität und Assoziativität ............................. 894.4.2 Anweisungen ................................................. 914.4.3 Ein Beispiel zur Wiederholung ....................... 924.4.4 Codezeilen testen .......................................... 934.4.5 Inkrement und Dekrement ............................ 944.4.6 Division und Rest .......................................... 97

4.5 Datentypen umwandeln ............................................. 1014.6 Das Wichtigste auf einen Blick ................................... 1024.7 Übungen .................................................................... 103

5 Bedingungen und Vergleiche ................................... 107

5.1 Blöcke ........................................................................ 1075.2 Die if-Anweisung ....................................................... 1085.3 Vergleichsoperatoren ................................................. 1095.4 Mögliche Operanden bei Vergleichen ........................ 1105.5 Die Handlungsalternative else .................................... 1115.6 Logische Operatoren .................................................. 112

5.6.1 Die Und-Verknüpfung ................................... 1135.6.2 Die Oder-Verknüpfung .................................. 1155.6.3 Logische Negation ......................................... 116

5.7 Der ternäre Operator ................................................. 1175.8 Die switch-Anweisung ............................................... 117

6

Inhalt

5.9 Beispiel: Bodymaßindex (BMI) berechnen ................... 1205.10 Objekte vergleichen .................................................... 122

5.10.1 Für welche Objekte gelten die Aussagen? ...... 1225.10.2 Warum können Objekte nicht mit dem

Vergleichsoperator verglichen werden? .......... 1255.10.3 Wie man Objekte stattdessen vergleicht ........ 127

5.11 Das Wichtigste auf einen Blick .................................... 1285.12 Übungen .................................................................... 129

6 Schleifen und Wiederholungen ................................ 133

6.1 Kopfgesteuerte Schleifen – while ................................ 1336.2 Fußgesteuerte Schleifen – do … while ........................ 1346.3 For-Schleifen .............................................................. 134

6.3.1 Schleifen unterbrechen – break und continue 1376.3.2 Ein größeres Beispiel für for-Schleifen ............ 1386.3.3 Schachteln von for-Schleifen .......................... 1416.3.4 Erweiterung – die for-each-Schleife ................ 146


7 Anwendungsbeispiel: Geburtstagskalender ............ 153

7.1 Der erste Ansatz ......................................................... 1537.2 Der zweite Ansatz ....................................................... 154

7.2.1 Die Datenbasis erstellen ................................. 1557.2.2 Die Datenbasis initialisieren ........................... 1567.2.3 Mehrere Geburtstagskinder an einem Tag ...... 1577.2.4 Kalendereinträge ausgeben ............................ 158

7.3 Fazit ........................................................................... 161

TEIL II: OBJEKTORIENTIERTE PROGRAMMIERUNG

8 Grundlegende Aspekte der OOP .............................. 167

8.1 Mit Objekten eigener Klassen arbeiten ....................... 1678.2 Inhalt einer Klasse – der Klassenentwurf ..................... 1708.3 Bestandteile einer Klasse ............................................ 173

8.3.1 Datenfelder und Referenzdatentypen ............. 1738.3.2 Methoden ...................................................... 1778.3.3 Konstruktoren ................................................ 194

7

Inhalt

8.4 Das Konto-Projekt zum Abschluss bringen ................. 1998.5 Pakete importieren und statische Importe .................. 201

8.5.1 Aufgabe von Paketen ..................................... 2018.5.2 Klassen importieren ....................................... 2028.5.3 Statische Importe .......................................... 2048.5.4 Eine Eingabemöglichkeit schaffen .................. 208

8.6 Enumerations ............................................................. 2088.6.1 Lösungsansatz 1 ............................................ 2098.6.2 Lösungsansatz 2 ............................................ 2108.6.3 Lösungsansatz 3 ............................................ 212

8.7 UML und die Klassenkarte ......................................... 2158.8 Annotations ............................................................... 2178.9 Das Wichtigste auf einen Blick ................................... 2188.10 Übungen .................................................................... 220

9 Vererbung und Polymorphie .................................... 223

9.1 Ihre Aufgabe in diesem Kapitel .................................. 2239.1.1 Der erste Entwurf .......................................... 2239.1.2 Bewertung des Lösungsansatzes .................... 225

9.2 Mit Vererbung arbeiten .............................................. 2259.2.1 Eine Superklasse entwerfen ........................... 2259.2.2 Vererbung testen ........................................... 2279.2.3 Beziehungen zwischen Klassen ...................... 229

9.3 Erweiterung der Aufgabe ............................................ 2319.3.1 Eine neue Superklasse erstellen ..................... 2319.3.2 Die neue Superklasse testen .......................... 233

9.4 Typen zuweisen ......................................................... 2349.4.1 Statischer und dynamischer Typ von

Referenzvariablen .......................................... 2359.4.2 Der Cast-Operator ......................................... 2379.4.3 Prüfung der Typen ......................................... 238

9.5 Sichtbarkeit ................................................................ 2389.6 Konstruktoren ............................................................ 2409.7 Methoden überschreiben ........................................... 243

9.7.1 Wie Methoden überschrieben werden ........... 2439.7.2 Wirkung des Überschreibens ......................... 2449.7.3 Unterschiedliche Typen ................................. 2459.7.4 Beispiele für Überschreiben und Überladen ... 2469.7.5 Zugriff auf Methoden der Superklasse ............ 248

9.8 Die letzte Erweiterung der Aufgabe ............................ 249

8

Inhalt

9.9 Alle Klassen erben von der Klasse »Object« ................ 2549.9.1 Die Methode »getClass()« ............................... 2549.9.2 Die Methode »toString()« ............................... 2559.9.3 Die Methode »equals()« ................................. 2579.9.4 Die Methode »hashCode()« ............................ 262


10 Erweiterte Konzepte der OOP ................................. 267

10.1 Abstrakte Klassen ....................................................... 26710.1.1 Abstrakte Klassen erzeugen ............................ 26810.1.2 Abstrakte Methoden in abstrakten Klassen .... 26910.1.3 Ein Beispiel für abstrakte Klassen:

Zeit- und Datumsfunktionen .......................... 27210.2 Schnittstellen .............................................................. 275

10.2.1 Definition des Begriffes .................................. 27510.2.2 Ein Beispiel für die Arbeit mit Interfaces ......... 277

10.3 Wann nehmen Sie was? .............................................. 28610.4 Entwurfsmuster .......................................................... 286

10.4.1 Beispiel 1: das Observer-Pattern .................... 28710.4.2 Beispiel 2: das Singleton-Pattern .................... 29010.4.3 Patterns generieren lassen –

der PatternCoder ........................................... 29110.4.4 Sinn von Entwurfsmustern .............................. 294

10.5 Innere Klassen ............................................................ 29510.5.1 Der erste Lösungsansatz: mit

herkömmlichen Möglichkeiten ....................... 29510.5.2 Der zweite Lösungsansatz: statische

innere Klasse .................................................. 29810.5.3 Der dritte Lösungsansatz: nicht-statische

Memberklasse ................................................ 30110.5.4 Der vierte Lösungsansatz: lokale Klasse .......... 304

10.6 Exkurs: Fehler finden mit dem Debugger .................... 31010.7 Das Wichtigste auf einen Blick .................................... 314

10.7.1 Abstrakte Klassen und Schnittstellen .............. 31410.7.2 Innere Klassen ............................................... 31510.7.3 Entwurfsmuster .............................................. 31510.7.4 Debugging ..................................................... 316

10.8 Übungen .................................................................... 316

9

Inhalt

TEIL III: GRAFISCHE BENUTZEROBERFLÄCHEN

11 Einführung in die GUI-Programmierung .................. 319

11.1 Von AWT zu Swing .................................................... 32011.2 Die Vererbungshierarchie von AWT und Swing .......... 32111.3 Das erste Fenster ....................................................... 322

11.3.1 Ein Fenster erzeugen ..................................... 32211.3.2 Ein Menü aufbauen ....................................... 32311.3.3 Tastenkürzel für das Menü anlegen ................ 32511.3.4 Ein Menü mit Auswahl von Optionen ............ 327

11.4 Event-Handling .......................................................... 32911.4.1 Hierarchie der Event-Klassen und

Event-Typen .................................................. 32911.4.2 Event-Empfänger ........................................... 33311.4.3 Event-Quellen ............................................... 33311.4.4 Zwei Beispiele für das Zusammenspiel ........... 33411.4.5 Adapterklassen .............................................. 33811.4.6 So sieht es praktisch aus ................................ 339

11.5 Das Wichtigste auf einen Blick ................................... 34411.6 Übungen .................................................................... 345

12 Steuerelemente und Layout ..................................... 347

12.1 Namenskonventionen und ungarische Notation ......... 34712.2 Top-Level-Container .................................................. 348

12.2.1 Die Klasse »JFrame« ....................................... 34812.2.2 Die Klasse »JDialog« ...................................... 35012.2.3 Die Klasse »JWindow« ................................... 35212.2.4 Fazit zu Top-Level-Containern ....................... 352

12.3 Weitere Container-Klassen ......................................... 35312.3.1 Die Klassen »JComponent« und »JPanel« ....... 35412.3.2 Die Klasse »JTabbedPane« ............................. 35612.3.3 Die Klasse »JSplitPane« .................................. 35712.3.4 Die Klasse »JScrollPane« ................................ 359

12.4 Interaktionskomponenten (Teil 1) .............................. 36012.4.1 Die Klasse »JLabel« ........................................ 36112.4.2 Die Klasse »AbstractButton« und ein paar

ihrer Subklassen ............................................ 36312.4.3 Die Klasse »JList« ........................................... 368

12.5 Das MVC-Pattern ....................................................... 37212.5.1 Allgemeine Beschreibung .............................. 372

10

Inhalt

12.5.2 Wie sieht dieses Prinzip in Swing aus? ............ 38212.5.3 Besonderheit der Swing-Modelle ................... 389

12.6 Interaktionskomponenten (Teil 2) ............................... 39012.6.1 Die Klasse »JTextField« ................................... 39012.6.2 Die Klasse »JComboBox« ................................ 39212.6.3 Die Klasse »JPasswordField« ........................... 39412.6.4 Die Klasse »JTextArea« ................................... 39512.6.5 Die Klasse »JEditorPane« ................................ 39612.6.6 Die Klasse »JSlider« ........................................ 39712.6.7 Die Klasse »JSpinner« ..................................... 39912.6.8 Die Klasse »JOptionPane« .............................. 401


13 Erweiterte Konzepte von Swing .............................. 407

13.1 Layoutmanager ........................................................... 40813.1.1 Layoutmanager in der Praxis .......................... 40813.1.2 Das FlowLayout ............................................. 40913.1.3 Das BorderLayout .......................................... 41013.1.4 Das GridLayout .............................................. 41213.1.5 Das GridBagLayout ......................................... 414

13.2 Look and Feel (LaF) .................................................... 41913.3 Die Klasse »JTable« ..................................................... 422

13.3.1 Umsetzung mit Arrays .................................... 42213.3.2 Datenbasis mit »TableModel« verwalten ........ 42313.3.3 Realisierung mit »AbstractTableModel« .......... 42813.3.4 Realisierung mit »DefaultTableModel« ........... 43013.3.5 Darstellung der Daten (Rendering) ................. 43013.3.6 Tabellen sortieren .......................................... 43413.3.7 Zellen editieren .............................................. 43713.3.8 Mehr über die Arbeit mit »JTable« ................. 441

13.4 Die Klasse »JTree« ....................................................... 44213.4.1 Ein erster Versuch .......................................... 44213.4.2 Auf Ereignisse lauschen .................................. 44413.4.3 Selektionen und die Klasse »TreePath« ........... 44613.4.4 Ein eigenes Modell entwickeln ....................... 44813.4.5 Die Anzeige ändern – das Rendering .............. 453

13.5 Das Interface »Action« ................................................ 45513.6 Das Wichtigste auf einen Blick .................................... 457

11

Inhalt

TEIL IV: FORTGESCHRITTENE THEMEN

14 Ausnahmebehandlung – Exceptions ........................ 461

14.1 Was bedeutet Fehlerbehandlung? .............................. 46114.1.1 Wie Fehler abgefangen werden können ......... 46214.1.2 Nachteile des ersten Ansatzes ........................ 462

14.2 Einführung von Exception-Handling ........................... 46314.2.1 Die Exception-Klassen ................................... 46414.2.2 Der try- und der catch-Block ......................... 46414.2.3 Der finally-Block ............................................ 466

14.3 Fangen oder Weiterreichen (Catch-or-Specify) ........... 46714.4 Differenziert auf Ausnahmesituationen reagieren ....... 468

14.4.1 Eigene Exception-Typen definieren ................ 46814.4.2 Exceptions differenziert fangen ...................... 472

14.5 Runtime-Exceptions ................................................... 47514.6 Error .......................................................................... 47714.7 Die Methode »printStackTrace()« ............................... 47714.8 Assertions .................................................................. 47914.9 Neu in Java 7 ............................................................. 48014.10 Zusammenfassendes Beispiel ...................................... 481

14.10.1 Die bisherige Implementierung ...................... 48114.10.2 Die neue Implementierung ............................ 48214.10.3 Die neue Implementierung testen ................. 483

14.11 Das Wichtigste auf einen Blick ................................... 486

15 Collections und Generics ......................................... 487

15.1 Ein eigenes Array entwickeln ...................................... 48715.1.1 Die Datenbasis der Klasse »MyArray« ............ 48815.1.2 Methoden der Klasse »MyArray« ................... 48915.1.3 Weitere Methoden der Klasse »MyArray« ...... 489

15.2 Primitive Datentypen als Objekte – Wrapper-Klassen ........................................................ 49115.2.1 Autoboxing und Unboxing ............................. 49115.2.2 Hinweis zum Umgang mit

Wrapper-Klassen ........................................... 49215.3 Einführung in Generics – Typsicherheit ....................... 49315.4 Die Interfaces »List« und »Set« ................................... 496

15.4.1 Das Interface »List« ........................................ 49715.4.2 Das Interface »Set« ........................................ 503

12

Inhalt

15.4.3 Sammlungen mit »Comparable« und »Comparator« sortieren .................................. 508

15.4.4 Verwendung der Klasse »TreeSet« .................. 51315.5 Das Interface »Map« ................................................... 516

15.5.1 Eine Map erzeugen ........................................ 51615.5.2 Einer Map Werte übergeben .......................... 51715.5.3 Interne Abbildung der Daten und Iteration .... 518


16 Nebenläufigkeit ........................................................ 523

16.1 Ein erstes Beispiel ....................................................... 52316.1.1 Die Quellen des Beispieles ............................. 52416.1.2 Auswertung des Beispieles ............................. 525

16.2 Zustandsänderungen eines Threads ............................. 52716.2.1 Zustände, die ein Thread einnehmen kann ..... 52716.2.2 Änderungen des Zustandes ............................ 52716.2.3 Einen Thread beenden ................................... 52816.2.4 Die Methoden »sleep()« und »interrupt()« ...... 53016.2.5 Prioritäten von Threads festlegen ................... 53116.2.6 Eine Zeitschaltuhr – die Klasse »Timer« ........... 532

16.3 Synchronisieren von Threads ....................................... 53316.3.1 Wo liegt die Fehlerquelle? ............................. 53316.3.2 Wie kann dieses Problem umgangen werden? 537

16.4 Kommunikation zwischen Threads .............................. 54016.5 Das Wichtigste auf einen Blick .................................... 54216.6 Übungen .................................................................... 543

17 Dateien, Datenströme, Serialisieren ........................ 545

17.1 Dateibehandlung ab Java 7 ......................................... 54517.1.1 Einstiegspunkte sind »FileSystem« und

»Path« ............................................................ 54517.1.2 Eine Datei oder ein Verzeichnis bearbeiten .... 548

17.2 Exkurs: Dateibehandlung bis Java 7 ............................ 55017.3 Was sind Ströme und was kann man damit

machen? ..................................................................... 55217.3.1 Mit Byte-Streams arbeiten ............................. 55317.3.2 Character-Streams und Brückenklassen .......... 55617.3.3 BufferedReader und BufferedWriter einsetzen 559

13

Inhalt

17.4 Kurze Zusammenfassung und Ausblick ....................... 56217.5 Objekte serialisieren und deserialisieren ..................... 564

17.5.1 Die Klasse »Adressbuch« schreiben ................ 56417.5.2 Die Klasse »Freund« schreiben ....................... 56517.5.3 Die Klasse »Verwaltung« schreiben ................ 56517.5.4 Das Projekt testen ......................................... 56817.5.5 Variablen von der Serialisierung

ausnehmen .................................................... 56917.6 Mit dem FileWhisperer das Dateisystem erkunden ..... 569

17.6.1 Die Oberfläche gestalten ............................... 57017.6.2 Verzeichnisse anzeigen .................................. 57117.6.3 Die Datei-Attribute anzeigen ......................... 574

17.7 Das Wichtigste auf einen Blick ................................... 580

18 Netzwerke ................................................................ 583

18.1 Rechner verbinden ..................................................... 58318.2 Verbindung über Sockets ........................................... 584

18.2.1 IP-Adressen und Domain-Namen .................. 58518.2.2 Ports ............................................................. 586

18.3 Der Multifunktionsserver ........................................... 58718.3.1 Schritt 1 – Grundversion ................................ 58718.3.2 Schritt 2 – mehrere Aufgaben an den Server

richten ........................................................... 59318.3.3 Schritt 3 – Vorbereitung von

Multithreading .............................................. 59418.3.4 Schritt 4 – Einführung von Multithreading ..... 59718.3.5 Schritt 5 – eigene Objekte statt Strings .......... 59818.3.6 Schritt 6 – Einführung von Services ................ 60318.3.7 Schritt 7 – Funktionen in HashMap speichern 604

18.4 Anregung für eigene Projekte ..................................... 60718.5 Das Wichtigste auf einen Blick ................................... 608

19 Datenbanken ............................................................ 609

19.1 Grundlagen ................................................................ 60919.1.1 Aufbau einer Datenbank ................................ 61019.1.2 Wichtige Begriffe ........................................... 612

19.2 Installation einer Datenbank ...................................... 61219.2.1 Die Serversoftware installieren ....................... 61219.2.2 Einen Treiber installieren ............................... 614

14

Inhalt

19.3 Eine Datenbank anlegen ............................................. 61419.3.1 Die Verbindung herstellen ............................. 61519.3.2 Befehl an die Datenbank absetzen .................. 61619.3.3 Überblick über den Quelltext ......................... 618

19.4 Tabellen anlegen ........................................................ 62019.4.1 Treiber laden und Verbindung herstellen ........ 62019.4.2 Tabellen anlegen und Verbindungen

schließen ....................................................... 62119.5 Spalten anlegen .......................................................... 623

19.5.1 Datentypen von Attributen ............................ 62419.5.2 Die Primärschlüssel der Tabellen anlegen ....... 624

19.6 Daten in die Tabellen eintragen .................................. 62619.7 Daten abfragen, ändern und löschen .......................... 628

19.7.1 Daten abfragen .............................................. 62819.7.2 Tabellen verbinden ........................................ 63119.7.3 Die where-Klausel .......................................... 63219.7.4 Daten löschen und Subabfragen definieren .... 63319.7.5 Daten ändern ................................................. 634

19.8 Prepared Statement .................................................... 63519.9 Exkurs SQL-Injection .................................................. 63619.10 Weitergehende Konzepte ........................................... 64019.11 Das Wichtigste auf einen Blick .................................... 641

A Lösungen .............................................................................. 643

Index ............................................................................................ 649

15

Vorwort

Ist dieses Buch für Sie geeignet?

Als ich dieses Buch geschrieben habe, habe ich mich gefragt, wer Sie viel-leicht sein könnten. Ich stelle mir vor, dass Sie Java mit der Motivationlernen, ansprechende Desktop-Applikationen zu erstellen. Sie wollenkeinen Server programmieren und auch keine Applets erstellen. Sie wol-len keine Texte verschlüsseln, sondern sich stabile Grundlagenkennt-nisse aneignen. Daraus folgen zwei Konsequenzen: Erstens, ich blendeThemen wie Applet-Programmierung, Kryptografie und einige mehrkonsequent aus. Zweitens, ich möchte Ihnen einen Text anbieten, derIhnen hilft, Java leicht und mit Spaß zu lernen. Sie profitieren davon,dass ich mir Java vor wenigen Jahren ebenfalls selbst aneignen musste.

Daher weiß ich aus meiner eigenen Lernerfahrung, welche Fragen Siehaben, wenn Sie anfangen, Java zu lernen. Ich habe auch noch in Erinne-rung, welche Bücher mir geholfen haben, die Materie zu verstehen, undwelche nicht. Und dieses Wissen ist in dieses Buch eingeflossen: Es istgenau für Sie geschrieben und für Sie geeignet, wenn Java für Sie Neu-land ist.

Wodurch zeichnet sich diese Einführung aus?

� Sie werden mit diesem Buch keine Vokabeln lernen, sondern Muster,Strukturen und Zusammenhänge.

� Dadurch ist das Wissen, das Sie sich erwerben, nicht nur für das aktu-elle Release gültig, sondern zukunftssicher.

� Diese Einführung spricht praktische Probleme an, und vor allem sinddie Beispiele ad hoc verständlich.

� Sie lernen erst die Grundbegriffe der Java-Programmierung, bevor Siesich mit Objektorientierung beschäftigen.

Ein Weiteres möchte ich Ihnen vermitteln: wie man als Programmiererauf Probleme reagiert.

Wie Sie Probleme nicht lösen

Aus meiner Erfahrung kann ich sagen, dass es Unternehmen gibt, in de-nen die EDV-Abteilung beim Auftreten von Problemen (sprich bei jedemAbweichen von der Norm) aufspringt und wie eine Gruppe erschreckterTauben in hektische Betriebsamkeit und blinden Aktionismus verfällt.

19

Vorwort

Gerne werden erst einmal die Schuldigen gesucht, die für das Problemverantwortlich sind, gelöst wird es dadurch allerdings nicht.

Wie Sie Problemelösen

Doch – wie können Sie sich stattdessen sinnvoll einem Problem nähern?Grundsätzlich ist jedes EDV-Problem lösbar. In der EDV ist alles doku-mentiert, und alles folgt vorgegebenen Regeln. Die Aussage »der Compu-ter spinnt« ist lediglich die verkürzte Form von »der Computer verhältsich exakt so, wie er soll, nur leider fehlt mir die nötige Kenntnis (oderMotivation), sämtliche Regeln und Zusammenhänge zu verstehen«.

Ich möchte Ihnen die Gewissheit geben, dass Sie alle Probleme lösenkönnen. Sie müssen nur wissen, wo Sie nachsehen müssen. Am Anfangwerden Sie ausführlich mit Ausdrücken und Operatoren arbeiten. Hier-bei ist es immer eine gute Idee, eine Prioritätenliste zur Hand zu haben.Dann mutieren »kompliziert anmutende Probleme« sehr schnell zu »ein-fachen Sachverhalten, die eben etwas umfangreicher sind als andere«. Siewerden, wenn Sie dieses Buch durchgearbeitet haben, weder in Schock-starre noch in hektische Betriebsamkeit verfallen müssen, wenn Ihre Pro-gramme nicht so laufen, wie sie sollten.

Übrigens lohnt es sich, »Es wird etwas geschehen« von Heinrich Böll zulesen und danach das eigene Arbeitsumfeld kritisch zu betrachten.

Wie ist das Buch aufgebaut?

Ziel des Buches ist es, Ihnen einen Einstieg zu bieten, über den Sie sichmöglichst einfach in die Materie einarbeiten können. Dabei werden wirden Fokus immer mehr weiten. Das Buch ist in vier Teile geteilt:

Basics von Java Im ersten Teil (Kapitel 1 bis 7) werden Sie erfahren, welche Schlüssel-wörter und Operatoren es gibt. Sie werden lernen, Programmteile wie-derholt oder bedingt auszuführen. Dieser Teil ist einer der wichtigsten inder Java-Programmierung überhaupt – ohne diese Basics ist ein sinnvol-les Arbeiten überhaupt nicht möglich.

ObjektorientierteKonzepte

Im zweiten Teil (Kapitel 8 bis 10) werden Sie vertieft mit Klassen undobjektorientierten Konzepten arbeiten. Sie werden verstehen, wie Klas-sen aufgebaut sind und wie Objekte miteinander interagieren. Sie wer-den lernen, mit Vererbung und Schnittstellen zu arbeiten.

GrafischeBenutzer-

oberflächen

Der dritte Teil (Kapitel 11 bis 13) ist eine praktische Anwendung der ers-ten beiden Teile. Sie lernen, ansprechende Oberflächen zu programmie-ren. Dabei kommen die Konzepte zum Tragen, die Sie aus den ersten bei-

20

Vorwort

den Teilen kennen. Neu wird nur die inhaltliche Ausgestaltung – GUI-Programmierung – sein.

Praxisrelevante Bibliotheken

Der vierte Teil (Kapitel 14 bis 19) behandelt in einzelnen Kapiteln ver-schiedene Themen der Programmierung, die inhaltlich für Ihr Studiumund auch für die Praxis relevant sind. Aber auch in diesem Teil werdennur die Themen – Netzwerktechnik, Datenbanken usw. – neu sein. DiePrinzipien, die dahinterstehen, kennen Sie bereits.

Wie arbeiten Sie am besten mit dieser Einführung?

Sie werden, wenn Sie studieren oder sich Java autodidaktisch aneignenwollen, am meisten profitieren, wenn Sie den Text aufmerksam lesenund parallel dazu die Beispiele, die Sie auf der DVD finden, in BlueJ aus-führen. Die Arbeit mit den Quelltexten ist unheimlich wichtig. Program-mieren lernt man nur, indem man es macht. Zu diesem Zweck enthältdas Buch viele Übungsaufgaben in unterschiedlichen Schwierigkeitsgra-den. Und damit Sie einschätzen können, wie gut Ihre eigene Lösung ist,finden Sie im Anhang natürlich auch Musterlösungen.

Dieses Buch in der Lehre einsetzen

Zusätzliches Unterrichtsmate-rial für Dozenten

Dieses Buch ist geeignet, um in der Lehre eingesetzt zu werden. WennSie Dozent sind, können Sie ergänzendes Unterrichtsmaterial und zusätz-liche Übungsaufgaben beim Verlag anfragen. Wenden Sie sich dafür bittean die im Impressum genannte Adresse.

Didaktischer Ansatz

Die Einführung verfolgt zunächst einen prozeduralen Ansatz und führtdie objektorientierte Programmierung erst danach ein, da dies aus didak-tischen Gründen sinnvoll ist. Deutsch lernt man schließlich auch nichtdadurch, dass man als Erstes »Faust« interpretiert.

Zusätzlich zu diesem Buch empfehle ich Ihnen dringend, auch mit denQuelltexten der Klassenbibliothek zu arbeiten. Auch hier stecken eigeneErfahrungen dahinter, schließlich kochen auch Oracle bzw. Sun nur mitWasser. Viele Klassen sind sogar so einfach implementiert, dass sie schonam Anfang, also im ersten Teil, besprochen werden können. Bei den Teil-nehmern meiner Schulungen tritt immer wieder der Aha-Effekt ein,sobald ich ihnen den Hintergrund zeige. Teilweise lassen sich Sachver-halte leichter erklären, wenn Sie Ausschnitte des Quelltextes zeigen, alswenn Sie versuchen, die dahinterstehende Logik zu erklären.

21

Vorwort

Danke

Dankbar bin ich

� meiner Freundin, Martina Guth, für ihre Geduld, ihr Verständnis undihre Unterstützung. Sie hat mir den Rücken freigehalten und michimmer wieder ermutigt – danke!

� meinen Eltern, Helga und Jürgen Siebler, für ihre Liebe. Sie haben mirdie nötige Kreativität und Hartnäckigkeit in die Wiege gelegt, umgroße Projekte wie dieses Buch zu einem guten Abschluss zu bringen.

� meinen Geschwistern, Martina, Frank und (in loving memory) BirgitSiebler, die für mich sehr wichtige Menschen, gute Freunde und wert-volle Ratgeber sind bzw. waren.

� meiner engagierten Lektorin, Christine Siedle. Sie hat die Entwick-lung meines ersten Buches sehr nett, sehr umsichtig und sehr kompe-tent begleitet.

� dem Fachgutachter, Professor Oliver Haase. Er hat meine Entwürfegelesen und an vielen Stellen sehr wichtige Hinweise gegeben.

� Johannes Nowak, der mich sowohl inhaltlich als auch didaktisch mitwertvollem Input versorgt und mir viele Impulse gegeben hat.

� Andreas Rudloff (www.Rumpelbox.de), bei dem ich in zahllosen Ziga-rettenpausen verschiedene Konzepte reflektieren konnte; von seinerlangjährigen Erfahrung als Programmierer habe ich wirklich profi-tiert.

� Melanie Hirschberger (www.HuMT.de), deren Tipps und Ratschläge inSachen Layout und Grafik mir eine wertvolle Hilfe waren.

� Tobin Harris (www.yUML.me), mit dem ich einen sehr netten undproduktiven Austausch über UML und Modellierungsfragen hatteund der mir erlaubt hat, die Klassendiagramme im Buch zu verwen-den.

� Benjamin »Beni« Sigg, dessen Skripte zu JTree und JTable aufwww.Java-Forum.org meine Arbeit an Kapitel 13, »Erweiterte Kon-zepte von Swing«, inspiriert haben.

� meinen Kollegen aus Abteilung V des BfJ und meiner Chefin Frau Dr.Lau für die Unterstützung und die tolle Zusammenarbeit.

Florian Sieblerwww.blueJ-Buch.de

22

In diesem Kapitel werden Sie lernen, wie Java-Programme aufgebaut sind und welche grundlegenden Elemente es gibt.

3 Erste Schritte in Java

Sie arbeiten mit Klassen.

Im vorigen Kapitel haben Sie Ihr erstes Programm geschrieben. Diesesschauen wir uns jetzt genauer an und entwerfen eine neue, spannendereKlasse.

3.1 Der Rahmen einer Klasse

Der Quelltext des Hallo-Welt-Programms lautete:

public class Begruessung{

public static void main(String[] args){

System.out.println("Hallo Welt!");}

}

Listing 3.1 Das Projekt »Hallo Welt«

Rahmen einer Klasse

Im Ergebnis wurde lediglich ein simples Hallo Welt! auf der Konsole aus-gegeben. Lassen Sie uns im ersten Schritt analysieren, warum so vieleZeilen Programmcode erforderlich sind, um eine Zeile Text auszugeben.Beginnen wir mit dem Rahmen. Der Rahmen jeder Klasse lautet:

public class Bezeichner{

// irgendwas}

Listing 3.2 Klassenrahmen

Der Bezeichner ist der Name der Klasse; er ist identisch mit dem Namender Datei, in der der Quelltext gespeichert wird. Das Schlüsselwort class

49

Erste Schritte in Java3

drückt aus, dass der Quelltext eine Klasse enthält. Die geschweiftenKlammern markieren den Anfang und das Ende der Klasse.

Zugriffs-modifizierer

Vor dem Schlüsselwort class finden Sie ein anderes Schlüsselwort, näm-lich den Zugriffsmodifizierer public. Damit erlauben Sie der Außenwelt –BlueJ, anderen Klassen – den Zugriff auf diese Klasse. Es gibt weitereModifizierer, auf die wir im zweiten Teil dieser Einführung noch zu spre-chen kommen. Um Ihnen das Prinzip anschaulich darstellen zu können,braucht es im Vorfeld weitere Konzepte. Bitte nehmen Sie im Momenteinfach hin, dass public die beste Wahl ist.

Erforderlich: diemain-Methode

Innerhalb des Rahmens der Klasse finden Sie die main-Methode:



// irgendwas}

}

Listing 3.3 main-Methode

Methoden – so auch die main-Methode – sind Unterprogramme, indenen Sie Ihre Anweisungen hinterlegen. Die main-Methode hat einebesondere Bedeutung, wenn Ihr Programm außerhalb von BlueJ laufensoll. Die VM sucht beim Start genau diese main-Methode als Einstiegs-punkt. Sie werden die main-Methode daher später dafür verwenden, umObjekte – zum Beispiel eine grafische Benutzeroberfläche – zu erzeugen.Jetzt, im ersten Teil, werden Sie Beispiele mit noch wenigen Zeilen Codefinden, so dass diese Zeilen in der main-Methode Platz finden.

Befehle an denComputer

Innerhalb der main-Methode steht eine Anweisung; eine Anweisung istein ausführbarer Befehl an den Computer:



System.out.println("Hallo Welt!");}

}

Listing 3.4 Anweisung in der main-Methode

50

Klassen in der Objektorientierung 3.2

Was passiert hier? Java stellt Ihnen eine Methode println() zur Verfü-gung, die den Text, den Sie in der Klammer mitgeben, auf der Konsoleausgibt. Diese Methode rufen Sie mit dieser Zeile auf. Jede Anweisungmüssen Sie mit einem Semikolon beenden.

3.2 Klassen in der Objektorientierung

Lassen Sie uns jetzt einen vorsichtigen Schritt in die Objektorientierungwagen. Im ersten Kapitel haben Sie gelernt, dass Ihr Girokonto Gegen-stand der OOP sein kann, und dieses Girokonto soll jetzt auf einem sehreinfachen Niveau aufgebaut werden. Für eine Klasse benötigen Sie zweiDinge: erstens Attribute wie den Namen und den Kontostand. Zweitensbrauchen Sie Verhalten, also die Möglichkeit, auf diese Attribute einzu-wirken. Fangen wir mit den Attributen an.

3.2.1 Attribute

Was sind Variablen?

Welche Attribute möchten Sie anlegen? Oder, anders gefragt: WelcheInformationen möchten Sie speichern? Sie möchten den Kontostand,eine Zahl, speichern. Außerdem wollen Sie den Namen des Kontoinha-bers, einen Text, speichern. Die Informationen werden im Speicherabgelegt. Die sogenannten Variablen verweisen auf die Stelle im Spei-cher, an der die Information gespeichert ist, bzw. speichern die Informa-tionen direkt.

Variablen deklarieren

Um eine Variable anzulegen, in der eine Zahl gespeichert werden soll,legen Sie den Typ der Variablen fest und wählen einen Namen für dieseVariable, einen Bezeichner:

int kontostand;

Der Typ – oder auch Datentyp – bestimmt, welche Art von InformationSie in der Variablen speichern können. Das Schlüsselwort int bewirkt,dass Sie einen ganzzahligen Wert in der Variablen kontostand speichernkönnen. Weitere andere Datentypen, zum Beispiel für Dezimalzahlenoder Wahrheitswerte, werden Sie im nächsten Kapitel kennenlernen.

Mit Variablen arbeiten

Was können Sie mit der Variablen kontostand anfangen? Sie können ihrzum Beispiel einen Wert zuweisen. Die folgende Zeile, die in einer belie-bigen Methode stehen kann, weist der Variablen den Wert 50 zu:

kontostand = 50;

51


Beide Schritte können Sie auch zusammenfassen, also eine Variable beimAnlegen gleich mit einem Wert versorgen, sie initialisieren:

int kontostand = 50;

Genauso verfahren Sie mit dem Kontoinhaber. Sie legen eine Variablean, die vom Typ String statt int ist:

String kontoinhaber;

Genauso wie Sie einer int-Variablen Zahlen zugewiesen haben, weisenSie einer String-Variablen Text zu. Texte, die Sie verarbeiten, müssenvon doppelten Anführungszeichen umschlossen sein:

kontoinhaber = "Kunde König";

Und natürlich können Sie eine Variable, die Text enthalten soll, auchgleich bei der Anlage initialisieren:

String kontoinhaber = "Kunde König";

Position derVariablen

Betrachten Sie die Variablen im gesamten Zusammenhang. Wo werdendie Variablen angelegt? Da die Variablen Informationen über das Kontospeichern, werden sie üblicherweise direkt am Anfang der Klasse gespei-chert:

public class Konto{

int kontostand = 50;String kontoinhaber = "Kunde König";

}

Listing 3.5 Position der Variablendeklaration

3.2.2 Methoden

Zugriffsrecht aufVariablen

Attribute haben – genau wie Klassen – Zugriffsmodifizierer. Zwei dieserZugriffsmodifizierer möchte ich Ihnen jetzt vorstellen: public undprivate. Wenn Sie eine Variable public anlegen, kann die Außenwelt –andere Objekte – beliebig lesend und schreibend darauf zugreifen. Daswäre eine unangenehme Situation, weil das Objekt dann keine Kontrolledarüber hätte, was ein anderes Objekt mit seinen Variablen macht.

Daher gibt es das sogenannte Geheimnisprinzip, das besagt, dass Datengekapselt, also im Objekt eingeschlossen und verborgen, werden müs-sen. Dieses Geheimnisprinzip wird im zweiten Teil ganz ausführlichunser Thema sein. Um Daten zu kapseln, legen Sie die Variablen immer

52


private an; dann können nur die Klasse und deren Instanzen daraufzugreifen. Die Definition der Variablen lautet also:

public class Konto{

private int kontostand = 50;private String kontoinhaber = "Kunde König";

}

Listing 3.6 Daten in privaten Variablen kapseln

Wofür werden Methoden gebraucht?

Wie kann der Kontostand verändert werden? Oder auch: Wie kann derName geändert werden, wenn Sie heiraten und den Namen ihrer Partne-rin annehmen? Methoden beschreiben das Verhalten. Genauso, wie Sieeiner Variablen beim Anlegen einen Wert zugewiesen haben, können Sieden Wert innerhalb einer Methode zuweisen. Lassen Sie uns eineMethode entwickeln, die den Kontostand auf 50 setzt. Zunächst müssenSie sich einen Bezeichner für die Methode überlegen. Da Methoden Ver-halten beschreiben, hat es sich als praktisch erwiesen, Methodennamenmit einem Verb beginnen zu lassen. Sie wollen den Kontostand setzenkönnen, also wählen Sie den Bezeichner setKontostand(). Die Klam-mern am Ende sind zwingend. Warum? Dazu werden wir gleich nochkommen.

RückgabewertSie müssen außerdem angeben, welchen Datentyp die Methode zurück-gibt. Wenn Sie keinen Rückgabewert erwarten, geben Sie an, dass Sienichts – void – erwarten.

Zugriffs-modifizierer

Und schließlich geben Sie auch bei Methoden einen Zugriffsmodifizierermit – Sie kennen bereits public und private. Was zu den Modifizierernbei Klassen und Variablen gesagt wurde, gilt auch für Methoden: Metho-den, die public sind, können von allen anderen Objekten aus aufgerufenwerden, Methoden, die private sind, können nur von der Klasse undderen Instanzen aufgerufen werden.

MethodenkopfDer Kopf der Methode – Methodenkopf oder Methodendeklaration – siehtalso so aus:

public void setKontostand()

MethodenrumpfMachen wir Nägel mit Köpfen und geben dem Kopf der Methode aucheinen Rumpf. Der Rumpf beginnt mit einer öffnenden geschweiftenKlammer und schließt mit einer geschweiften Klammer. Zwischen diesenKlammern können – müssen aber nicht – Anweisungen stehen:

53


{// Anweisungen

}

Sie möchten, dass die Methode den Kontostand auf 50 setzt, also siehtdie Methode vollständig so aus:

public void setKontostand(){

kontostand = 50;}

Listing 3.7 Vollständige Methode

3.2.3 Optional: Parameter und Rückgabewert

Was Sie gerade gesehen haben, ist die einfachste Form einer Methode.Sinnvoll einsetzen lassen sich Methoden, wenn Sie Parameter und Rück-gabewerte vorsehen.

Methoden mit Parametern

Es ist sicher wenig sinnvoll, wenn Sie den Kontostand immer auf 50 set-zen. Lassen Sie den Anwender einen Kontostand an die Methode mitge-ben. Verwenden Sie dafür Parameter. Parameter bestehen aus einembestimmten Datentyp und einem Bezeichner. Sie werden in die rundenKlammern nach dem Methodennamen geschrieben. Innerhalb derMethode – aber tatsächlich auch nur innerhalb der Methode, an die sieübergeben wurden – können Sie auf diese Parameter zugreifen. Dannsind Sie so flexibel, dass Sie einen beliebigen Wert an die Methode über-geben können:

Methodenkopfmit Parameter

public void setKontostand(int betrag){

kontostand = betrag;}

Listing 3.8 Methodenkopf mit Parameter

Signatur einerMethode

Sie können einer Methode beliebig viele Parameter mitgeben. Der Nameeiner Methode und die Parameterliste bilden die Signatur einerMethode, im Beispiel ist also setKontostand(int betrag) die Signatur.

Methoden mit Rückgabewerten

Methoden können Rückgabewerte haben. In den Beispielen oben wurdevoid zurückgeben. Anstelle von void können Sie sich einen beliebigen

54


Datentyp zurückgeben lassen. Wenn Sie den Kontostand nicht setzen,sondern abfragen wollen, werden Sie die Methode sicher getKonto-stand() nennen wollen. Zugriff soll von überall her möglich sein, alsopublic. Der Rückgabewert ist die Zahl, die den Kontostand enthält, alsoint. Der Methodenkopf sieht so aus:

public int getKontostand()

Methode mit Rückgabewert

Wenn Sie einen Wert zurückgeben, müssen Sie innerhalb der Methodeden Befehl return aufrufen:

public int getKontostand(){

return kontostand;}

Listing 3.9 Methode mit Rückgabewert

3.2.4 Abschließendes zu Methoden

Die Klasse im Überblick

Betrachten Sie das alles im Gesamtzusammenhang:

public class Konto{

private int kontostand = 50;

public int getKontostand(){

return kontostand;}

public void setKontostand(int betrag){

kontostand = betrag;}

}

Listing 3.10 Die vollständige Klasse

Getter und SetterSie haben ein Attribut, den Kontostand. Jedes Objekt der Klasse Kontohat sein eigenes Attribut kontostand; dieses Attribut ist nur für daseigene Objekt sicht- und zugreifbar. Nach außen ist das Attribut nichtsichtbar. Die Methode, die das Attribut zurückgibt, nennt man Getteroder auch sondierende Methode. Die Methode, die den Inhalt des Attribu-tes ändert, wird Setter oder auch verändernde Methode genannt.

55


Sind Sie es leid, immer wieder System.out.println() schreiben zu müs-sen? Entwickeln Sie eine Methode, die als Parameter einen Text (Daten-typ String) erwartet und diesen Text auf die Konsole schreibt. DieMethode nennen Sie drucke. Einen Rückgabewert benötigen Sie nicht(void). Schließlich kann die Methode auch private sein:

private void drucke(String text){

System.out.println(text);}

Listing 3.11 Eigene Methode zum Ausgeben von Text

Weiteres Attributhinzufügen

Mit diesem Wissen sollte es für Sie leicht sein, das Attribut kontoinhaberzu implementieren. Der zugehörige Getter nutzt die Methode drucke,indem er sie mit dem Namen des Kontoinhabers als Parameter – einemText – aufruft. Listing 3.12 gibt den Quelltext der Klasse gekürzt wieder:

public class Konto{

private String kontoinhaber = "Kunde König";

public String getKontoinhaber(){

drucke(kontoinhaber);return kontoinhaber;

}

public void setKontoinhaber(String name){

kontoinhaber = name;}

}

Listing 3.12 Quelltext der Klasse »Konto« (Auszug)

Den vollständigen Quelltext der Klasse finden Sie im Ordner Beispiele\Kapitel_03\Konto auf der Begleit-DVD des Buches.

3.2.5 Blöcke

Ein Block ist die Zusammenfassung von keinem, einem oder vielenBefehlen. Blöcke beginnen wie Methodenrümpfe mit einer öffnendengeschweiften Klammer und enden mit einer schließenden geschweiftenKlammer. Sie können Blöcke innerhalb von Methoden anlegen:

56

Ein Objekt erzeugen 3.3


System.out.println("Vor dem Block");{

System.out.println("Im Block");}System.out.println("Nach dem Block");

}

Listing 3.13 Blöcke anlegen

Blöcke gruppieren verschiedene Anweisungen und sind selbst eineAnweisung. Es kann sinnvoll sein, Code nur unter bestimmten Bedin-gungen auszuführen. Sehr oft werden Sie auch die Notwendigkeit haben,den Code im Block wiederholt auszuführen. Wie das geht und wann dasnützlich ist, werden Sie in den nächsten drei Kapiteln sehen.

3.3 Ein Objekt erzeugen

Die Klasse in Aktion

Sie haben in den vorigen Abschnitten dieses Kapitels gesehen, wie eineKlasse aufgebaut ist und wie Sie mit Variablen und Methoden arbeiten.Um das Thema anschaulich werden zu lassen, lassen Sie sich Objekte die-ser Klasse erzeugen. Öffnen Sie BlueJ, und laden Sie das Projekt Konto.Setzen Sie einen rechten Mausklick auf das Symbol der Klasse Konto, undwählen Sie new Konto(). Mit diesem Befehl erzeugen Sie ein neuesObjekt (siehe Abbildung 3.1).

Abbildung 3.1 Ein neues Objekt erzeugen

57


Objekte erzeugen Im folgenden Dialog werden Sie aufgefordert, einen Namen für dasObjekt anzugeben. Nennen Sie es alice, siehe Abbildung 3.2.

Bezeichner fürObjekte

Erstellen Sie ein weiteres Objekt, das Sie bob nennen. Beide Objekte –alice und bob – finden Sie in der Objektleiste, siehe Abbildung 3.3.

Methoden einesObjektes

ausführen

Setzen Sie einen rechten Mausklick auf eines der Objekte. Wählen Sie imKontextmenü getKontoinhaber(). Da Sie den ursprünglichen Wert nochnicht geändert haben, gibt BlueJ Ihnen den Initialwert Kunde Königzurück, wie Sie in Abbildung 3.4 sehen können.

Abbildung 3.2 Einen Bezeichner für das Objekt eingeben

Abbildung 3.3 Zwei Objekte – Instanzen – der Klasse »Konto«

Abbildung 3.4 Rückgabewert anzeigen lassen

58

Kommentare 3.4

Setzen Sie wieder einen rechten Mausklick auf das Objekt alice. WählenSie im Kontextmenü setKontoinhaber(String kontoinhaber). BlueJfordert Sie im folgenden Dialog auf, den Namen des Kontoinhabers ein-zugeben – vergessen Sie nicht die umschließenden Anführungszeichen(Abbildung 3.5).

Sie können sich mit getKontoinhaber() erneut den Namen anzeigen las-sen. Vergleichen Sie die Ausgabe mit der entsprechenden Ausgabe desanderen Objektes; Sie werden feststellen, dass die Methode nur dasAttribut der eigenen Instanz geändert hat.

3.4 Kommentare

Bessere Über-sichtlichkeit

In der Anfangszeit sind Ihre Programme übersichtlich und einfach. Aberspätestens, wenn Sie diese Einführung durchgearbeitet haben, werdendie Quelltexte umfangreicher und komplizierter. Programme, die Sie inder Praxis erstellen, umfassen viele tausend Zeilen Quelltext. Da ist esschwierig, den Überblick zu behalten. Außerdem werden Sie selbst beiüberschaubaren Programmen schon nach kurzer Zeit nicht mehr genauwissen, was Sie mit dieser oder jener Methode oder Klasse erreichenwollten.

Zudem können Sie nicht davon ausgehen, dass Sie alleine Programmeerstellen und pflegen werden. Sie werden in einem Team eingebundensein, wo jeder Programmierer auf Informationen des jeweils anderenangewiesen sein wird.

Das sind genug Gründe, um einen Quelltext lesbar zu machen, wobeiKommentare ein wesentlicher Aspekt sind. Sie können Ihren Quelltextmit drei Arten von Kommentaren versehen.

Abbildung 3.5 Den Namen des Kontoinhabers eingeben

59


Einzeilige Kommentare

EinzeiligeKommentare

Einzeilige Kommentare werden durch doppelte Schrägstriche // einge-leitet. Alles, was danach in dieser Zeile steht, wird vom Compiler igno-riert. Weiter oben im Kapitel habe ich Kommentare in den Quelltextgesetzt:

System.out.println(text); // Variable text wird gedrucktpublic static void main(String[] args){

// irgendwas}// Ein Kommentar kann auch am Anfang einer Zeile beginnen

Listing 3.14 Drei einzeilige Kommentare

Kommentarblöcke

Kommentarblöcke Kommentarblöcke werden durch /* eingeleitet und müssen mit */ been-det werden. Alles was zwischen Anfang und Ende steht, wird als Kom-mentar gewertet und beim Kompilieren ignoriert.

/*Hier steht ein langer Kommentar, der sich über mehrereZeilen erstrecken kann.

* BlueJ setzt an den Anfang einer Zeile innerhalb des* Kommentarblockes ein Sternchen; das verbessert zwar die* Übersichtlichkeit, ist aber nicht vorgeschrieben*/

Listing 3.15 Kommentarblock

Dokumentationskommentare

Dokumentations-kommentare

Dokumentationskommentare werden durch /** eingeleitet und mit */beendet. Dokumentationskommentare sind die wichtigsten, die es gibt.Sie werden in die Dokumentation aufgenommen, die Java automatischfür Sie erstellt.

/**Die Klasse Begruessung.java macht Folgendes: ...Beschreibung der Funktion

* Sternchen am Zeilenanfang sind möglich, aber auch hier* nicht erforderlich*/

Listing 3.16 Dokumentationskommentar

60

Kommentare 3.4

Aufbau eines Dokumentations-kommentars

Dokumentationskommentare werden vor eine Klasse, vor Variablen undvor eine Methode gesetzt. Wenn Sie eine Methode kommentieren,machen Sie gegebenenfalls noch Anmerkungen zu Parametern und Rück-gabewerten. Hierfür verwenden Sie @param und @return:

/*** Gibt den Kontoinhaber zurück* @return Name des Kontoinhabers*/public String getKontoinhaber(){

drucke(kontoinhaber);return kontoinhaber;

}

/*** Setzt den Namen des Kontoinhabers* @param name Name des Kontoinhabers*/public void setKontoinhaber(String name){

kontoinhaber = name;}

Listing 3.17 Aufbau eines Dokumentationskommentars

Die fertige Dokumentation

Wenn Sie den Quelltext gerade editieren, tippen Sie [Strg]+[J]. Jetztwird die Dokumentation angezeigt, die auszugsweise so aussieht wie inAbbildung 3.6.

Abbildung 3.6 Die Dokumentation der Methoden der Klasse

61


Sinn derDokumentation

Ein Programmierer, der die Klasse verwenden möchte, muss sich jetztnicht mehr mit dem Quelltext beschäftigen. Er kann mit einem Blick indie Dokumentation sehen, was die Methode macht, welche Parameterund welche Rückgabewerte sie erwartet.

Wirkungder Zugriffs-modifizierer

3.5 Das Wichtigste auf einen Blick

� Java-Programme bestehen aus Klassen.

� Variablen enthalten Informationen, unter anderem Zahlen und Texte.

� Auf Variablen greifen Sie niemals direkt zu, sondern über Methoden.

� Methoden enthalten die eigentliche Programmlogik.

� Jedes Programm muss unbedingt eine main-Methode haben.

� Die main-Methode ist der Einstiegspunkt für die JVM.

� Sie können – müssen aber nicht – einer Methode einen oder mehrereParameter mitgeben.

� Eine Methode kann – muss aber nicht – an den Aufrufer eine Infor-mation zurückgeben.

� Für die Klasse, für Variablen und für Methoden gibt es Zugriffsmodi-fizierer.

� Modifizierer regeln, wer auf die Klasse zugreifen darf.

� Quellcode wird mit Kommentaren lesbar aufgebaut.

� Es gibt einzeilige Kommentarzeilen, Kommentarblöcke und Doku-mentationskommentare.

Einmal scharf nachgedacht

Sie haben eine Methode drucke(String text) geschrieben, die aufgerufenwird, wenn der Name des Kontoinhabers abgefragt wird. Dennoch erscheintdiese Methode nicht in der Dokumentation. Auch mit BlueJ haben Sie kei-nen Zugriff auf diese Methode. Warum nicht? Grund hierfür ist, dass dieMethode private ist. Dieser Zugriffsmodifizierer bewirkt, dass von außen –Sie mit BlueJ – niemand zugreifen kann. Zugriff ist nur durch andere Metho-den der Klasse – im Beispiel getKontoinhaber() – möglich. Daher muss dieseMethode auch nicht in die Dokumentation aufgenommen werden.

62

Übungen 3.6

3.6 Übungen

1. Erweitern Sie die Konto-Klasse um folgende Variablen: Überziehungs-kredit und Kontobevollmächtigter.

2. Ändern Sie den Zugriffsmodifizierer der Methode drucke(Stringtext) in public. Erstellen Sie die Dokumentation neu, sehen Sienach, was sich geändert hat. Rufen Sie die Methode mit BlueJ auf.

3. Ändern Sie den Zugriffsmodifizierer der Variablen kontostand. Siesoll auch public sein. Erstellen Sie die Dokumentation neu, undsuchen Sie die Änderung.

4. Erstellen Sie eine Klasse Mensch. In ihr sollen folgende Informationengespeichert werden: Vorname und Geburtsname. Beide Informatio-nen sind Texte, also String-Typen.

5. Legen Sie für die Klasse Mensch die Dokumentation an, und erstellenSie verschiedene Objekte dieser Klasse.

63

Hier im zweiten Teil steigen Sie tiefer in die Objektorientierung ein. Beginnen wir in diesem Kapitel mit der Frage, was alles in einer Klasse zu finden ist.

8 Grundlegende Aspekte der OOP

Wenn Sie sich bis hierher durchgearbeitet haben, wissen Sie schon eineganze Menge:

� Sie kennen den grundlegenden Aufbau einer Klasse.

� Sie deklarieren und belegen Variablen.

� Sie gehen sicher mit Operatoren um.

� Sie wissen, wie man Informationen vergleicht.

� Sie führen Blöcke gezielt wiederholt aus.

Und Sie haben bereits einen Vorgeschmack auf objektorientierte Kon-zepte bekommen, während Sie mit Strings gearbeitet haben.

8.1 Mit Objekten eigener Klassen arbeiten

Vom Objekt zur Klasse

Sie haben in den vorigen Kapiteln Variablen vom Typ String angelegt. InKapitel 5, »Bedingungen und Vergleiche«, haben Sie gesehen, dass Javaeine Klasse kennt, die String heißt. Der Datentyp String lässt sich alsoauf eine Klasse String zurückführen. In der Dokumentation haben Sieetliche Methoden gefunden, die die Klasse String definiert, und die vonden Instanzen dieser Klasse ausgeführt werden konnten – beispielsweisekonnten Sie mit den Bordmitteln des Strings einen Text in Großbuchsta-ben umwandeln.

Von der Klasse zum Objekt

In Kapitel 3, »Erste Schritte in Java«, hatten wir eine andere Blickrich-tung. Wir sind nicht von Objekten ausgegangen und haben die Klasseerforscht, sondern sind von einer Klasse ausgegangen, die Sie selbstangelegt haben: der Klasse Konto. Die Methoden, die Sie deklarierthaben, konnten von allen Objekten dieser Klasse ausgeführt werden.

167

Grundlegende Aspekte der OOP8

Sie fragen sich vielleicht, ob daraus der Schluss gezogen werden kann,dass Strings und Konten für Java das Gleiche sind. Und genau das ist derFall; die Klasse Konto – genauer jede Klasse, die Sie definieren – istgenauso ein Datentyp wie die Klasse String, die Java mitbringt.

Das Projekt»Konto_1«

Das folgende Beispiel soll Ihnen zeigen, wie Sie mit selbst definiertenDatentypen arbeiten können. Öffnen Sie das Projekt Konto_1, das Sie aufder beigelegten DVD finden. Darin gibt es die Klasse Konto, die Sie in Lis-ting 8.1 im Auszug sehen:

public class Konto{

private int kontostand = 50;private String kontoinhaber = "Kunde König";

public void einzahlen(int betrag){

kontostand += betrag;}

public void setKontoinhaber(String name){

kontoinhaber = name;}// ...

}

Listing 8.1 Die Klasse »Konto« (Auszug)

Methode»ueberweisen()«

In der Klasse gibt es eine Methode einzahlen(), der Sie den Betrag über-geben, der eingezahlt werden soll. Diese Methode ändert den Konto-stand des eigenen Objektes. Wenn Sie Geld auf ein anderes Konto über-weisen möchten, müssen Sie die Methode einzahlen() eines anderenObjektes aufrufen. Die Frage ist also, wie ein Objekt die Methode einesanderen Objektes aufrufen kann. Hierzu legen Sie eine Methodeueberweisen() an. Als Parameter übergeben Sie der Methode ein Objektvom Typ Konto und den zu überweisenden Betrag. Innerhalb derMethode wird die Methode einzahlen() eines anderen Objektes vomTyp Konto aufgerufen. Das fremde Objekt und dessen Methode verbin-den Sie mit einem Punkt. Der Kontostand des eigenen Objektes wird umden überwiesenen Betrag reduziert:

public void ueberweisen(Konto fremdesKonto, int betrag){

168

Mit Objekten eigener Klassen arbeiten 8.1

fremdesKonto.einzahlen(betrag);kontostand -= betrag;

}

Listing 8.2 Kontostand wird reduziert.

Die Klasse testenUm die Klasse zu testen, übersetzen Sie sie und erstellen zwei Objektedavon – nennen Sie eines alice und eines bob, so wie Sie es in Abbil-dung 8.1 sehen können.

Objekte als Para-meter an Metho-den übergeben

Setzen Sie einen rechten Mausklick auf das Konto alice, und zahlen SieGeld auf ihr Konto ein. Lassen Sie sich nun von beiden Konten den jewei-ligen Kontostand anzeigen. Rufen Sie jetzt die Methode ueberweisen()auf. Ein Dialog wird angezeigt, in dem Sie aufgefordert werden, zweiWerte einzugeben: das empfangende Konto und den Betrag. In das Feldfür das empfangende Konto tragen Sie den Bezeichner des Objektes ein.In Abbildung 8.2 sehen Sie, welche Werte ich bei meinem Test in dasDialogfeld eingetragen habe.

Lassen Sie sich nun erneut die Kontostände anzeigen. Sie sehen, dass dasGeld wie gewünscht auf dem Konto-Objekt bob angekommen ist.

Abbildung 8.1 Zwei Objekte vom Typ »Konto«

169


Zusammenfas-sung und Ausblick

Ihre eigenen Klassen können also genauso Datentypen sein wie dieDatentypen, die Java mitbringt. Sie werden, wenn Sie ein Programmschreiben, sehr viele Klassen – komplexe Datentypen – entwickeln. Imdritten Teil dieser Einführung werden noch grafische Benutzerober-flächen hinzukommen. Dadurch ändert sich zwar der Grad an Komplexi-tät und Abstraktion, aber das Prinzip ist immer das gleiche: Unabhängigvom Abstraktionsgrad und unabhängig von der Komplexität bestehenJava-Applikationen immer aus einer Vielzahl von Objekten, die mitein-ander interagieren.

8.2 Inhalt einer Klasse – der Klassenentwurf

Refactoring Die Aussage des letzten Abschnittes war, dass Sie Klassen entwerfen, umeigene Datentypen zu erhalten. Der richtige Entwurf einer Klasse spieltdabei eine große Rolle. Wir werden jetzt das Konto-Projekt überarbeitenund den Aufbau der Klasse ändern, um einen besseren Klassenentwurfzu bekommen. Dabei werden Konto- und Kundendaten getrennt wer-den, so dass wir gleich zwei Klassen haben. Die Aktivität, ein bestehen-des Projekt zu überarbeiten, ohne die Funktionalität zu verändern, wirdRefactoring genannt.

Abbildung 8.2 Parameter für die Methode »überweisen()« eingeben

170

Inhalt einer Klasse – der Klassenentwurf 8.2

Kohäsion einer Klasse

Jede Klasse hat einen eigenen Verantwortungsbereich und soll eine ein-zige Aufgabe erfüllen: Wenn Sie eine Klasse haben, die »Konto« heißt,werden Sie darin Daten zum Konto erwarten. Eine Klasse, die »Kunde«heißt, ist für die Daten verantwortlich, die erforderlich sind, um einenKunden zu verwalten. Wenn jede Einheit in einem System eine klar defi-nierte Aufgabe hat, spricht man von hoher Kohäsion. Der Begriff Kohä-sion bezieht sich nicht nur auf Klassen, sondern auch auf Methoden: Wassoll eine Methode alles tun? Eine Methode führt eine einzige klar defi-nierte Aufgabe aus.

Instanzvariablen

DatenkapselungDatenfelder werden immer als private deklariert, so dass nur die Klasseselbst bzw. Instanzen der Klasse darauf zugreifen können. Was ist derSinn? Ein Objekt stellen Sie sich am besten wie Ihren Computer vor. IhrComputer hat verschiedene Schalter und Leitungen. Sie als Anwenderwerden jedoch nicht wissen wollen, wie die einzelnen Schalter und Lei-tungen zueinander in Beziehung stehen. Sie möchten wissen, dass derComputer bootet, wenn Sie den Rechner anschalten. Der Computerher-steller hat Ihrem Wunsch Rechnung getragen. Er stellt Ihnen einen Schal-ter zur Verfügung, mit dem Sie den Computer starten. Was dann imInneren stattfindet, wenn der Rechner hochfährt, darf ruhig das Geheim-nis des Herstellers bleiben. Das gleiche Prinzip liegt bei Objekten vor. Siedeklarieren private Datenfelder und können deren Werte über öffentli-che Methoden lesen und verändern. In diesen Methoden werden in derPraxis viele Plausibilitätsprüfungen vorgenommen, von denen derAnwender nichts mitbekommt.

Sie werden gleich eine Klasse Konto entwerfen, in der der Kontostandenthalten ist. Wenn ein Kunde eine Überweisung ausführen möchte,wird erst einmal geprüft, ob überhaupt Geld auf dem Konto ist. Hätte derKunde direkten Zugang auf seinen Kontostand, könnte die Bank diesePrüfung nicht durchführen, und sie würde mehr Geld auszahlen, als siejemals eingenommen hat. Das Prinzip, dass Daten nur von der Klasse

Zur Erinnerung

In Kapitel 4, »Variablen, Datentypen und Operatoren«, hatte ich Ihnen vierArten von Variablen vorgestellt: Parameter, lokale Variablen, Klassen- undInstanzvariablen. Klassen- und Instanzvariablen werden auch Datenfeldergenannt.

Von der Klasse Kunde werden später viele Objekte erzeugt. Jedes dieserObjekte wird eigene – individuelle – Attribute haben: Jedes Objekt hat eineneigenen Vornamen, einen eigenen Nachnamen usw. Wir haben es hier mitInstanzvariablen zu tun.

171


selbst bzw. von Instanzen der Klasse gelesen und verändert werden kön-nen, nennt man Datenkapselung oder Geheimnisprinzip.

Ein Beispiel füreine Plausibilitäts-

prüfung

Folgendes Beispiel mit dem Code aus dem letzten Abschnitt soll das Prin-zip verdeutlichen:



Es ist bei dieser Umsetzung immer noch möglich, einen negativen Betrageinzuzahlen, was einer Abbuchung gleich käme. Eine Plausibilitätsprü-fung könnte sein, dass zuerst geprüft wird, ob der einzuzahlende Betragpositiv ist:


if(betrag >= 0){


}

Listing 8.3 Plausibilitätsprüfung

Kopplung Die Klassen Kunde und Konto sind, da jede Klasse ihren eigenen Verant-wortungsbereich hat, unabhängig voneinander. Jede Klasse hat ihreDaten gekapselt. Die daraus erzeugten Objekte können nur über Zugriffs-methoden, zum Beispiel ueberweisen(), miteinander kommunizieren.Man sagt dazu, die Klassen sind lose gekoppelt. Anders wäre es, wenn dieKlassen nicht lose gekoppelt wären. Ein Objekt der Klasse Kunde hättedann lesenden und schreibenden Zugriff auf das Datenfeld kontostand.Das würden Sie aus zwei Gründen nicht wollen: Zum einen wäre derGrundsatz der Datenkapselung verletzt, zum anderen hätte jede Ände-rung der Klasse Konto sehr umfangreiche Auswirkungen auf die KlasseKunde. Wenn das Datenfeld kontostand von int auf double geändertwürde, müsste jeder Zugriff auf dieses Datenfeld überprüft und getestetwerden. Die Auswirkungen sind jedoch überschaubar, wenn ein Objektder Klasse Kunde nur über eine Schnittstelle, zum Beispiel die Methodeueberweisen(), auf das Datenfeld einwirkt.

Vorteile einesguten Klassen-

entwurfs

Lose Kopplung und hohe Kohäsion sind ein Hinweis darauf, dass derKlassenentwurf gelungen ist. Was ist der Vorteil eines guten Klassenent-wurfs? Mit diesem Ansatz wird Ihr Quellcode leichter les- und wartbar,Änderungen und Erweiterungen können einfacher realisiert werden.

172

Bestandteile einer Klasse 8.3

Wenn beispielsweise künftig bei den Kundendaten auch die E-Mail-Adresse des Kunden hinterlegt werden soll, muss die bereits getesteteund lauffähige Klasse Konto nicht mehr berührt werden. Umgekehrt kön-nen die Kundendaten unverändert übernommen werden, wenn derKunde ein weiteres Konto eröffnet oder einen Bausparvertrag abschließt.

8.3 Bestandteile einer Klasse

Woraus bestehen Klassen?

Objektorientierung bildet die Gegenstände der realen Welt ab. EinObjekt hat einen Zustand – die Menge aller Attribute – und Methoden,die auf seine Attribute einwirken.

Eine Java-Klasse braucht also mindestens Datenfelder, um die Attributezu speichern, und Methoden, die das Verhalten der Klasse und derObjekte beschreiben. Hinzu kommen Konstruktoren. Konstruktorensind spezielle Methoden, die ausgeführt werden, wenn das Objekterzeugt wird.

8.3.1 Datenfelder und Referenzdatentypen

Datenfelder sind Variablen, die außerhalb eines Blockes und außerhalbeiner Methode deklariert werden. Was Variablen sind und wie man mitVariablen umgeht, wurde in Kapitel 4, »Variablen, Datentypen und Ope-ratoren«, ausführlich beschrieben. Das Thema wird in diesem Abschnittzu einem kleinen Teil wiederholt. Der Fokus liegt hier auf dem Umgangmit Referenzdatentypen.

Öffnen Sie das Projekt Konto_2 von der beiliegenden DVD. Im Unter-schied zum vorigen Projekt finden Sie jetzt zwei Klassen vor: die KlasseKunde und die Klasse Konto. Die Klasse Kunde hat drei Datenfelder: dieVariable weiblich, die das Geschlecht des Kunden angibt. Außerdemgibt es eine Variable vom Typ String, in der der Name des Kundengespeichert wird, und schließlich eine Variable vom selbst definiertenTyp Konto, in der eine Referenz auf das girokonto gespeichert wird:

Attribute eines Kunden

public class Kunde{

private boolean weiblich = false;private String name = new String();private Konto girokonto = new Konto();

}

Listing 8.4 Rahmen der Klasse »Kunde« mit zwei Datenfeldern

173


Sie haben damit einen primitiven Datentyp, das Geschlecht und zweikomplexe Datentypen.

Inhalt einerVariablen

Bei primitiven Datentypen werden die Werte in der Variablen direktgespeichert. Die beiden komplexen Datentypen habe ich mit newString() bzw. new Konto() initialisiert. Wenn Sie eine Variable mit newString() initialisieren, wird in einem besonderen Bereich des Speichers,dem Heap, ein Objekt angelegt, das eine leere Zeichenkette speichert.Die Referenz, also die Information, wo das Objekt zu finden ist, wird andie Variable zurückgeliefert.

Referenz auf einObjekt

Lassen Sie uns dieses Prinzip am Beispiel des Kontos genauer betrachten.Sie legen ein Feld an, das mit new Konto() initialisiert wird. BlueJ zeigtmit einem Verwendungspfeil im Projektfenster an, dass die Klasse Kundevon der Klasse Konto Gebrauch macht (siehe Abbildung 8.3).

In der Klasse Konto ist ein einziges Datenfeld deklariert:

public class Konto{

private int kontostand = 50;// ... gekürzt

}

Listing 8.5 Einzelnes Datenfeld

Abbildung 8.3 Projektfenster mit Verwendungspfeil

174


Darstellung in BlueJ

Betrachten Sie, wie BlueJ diesen Zusammenhang darstellt. Erzeugen Sieein Objekt vom Typ Kunde, und inspizieren Sie es. Wenn Sie das Daten-feld girokonto anklicken und auf Inspizieren klicken, öffnet sich einweiteres Dialogfenster, das die Datenfelder des referenzierten Konto-Objektes anzeigt (siehe Abbildung 8.4). Im Beispiel wird nur der Konto-stand angezeigt, der mit 50 initialisiert wurde. Sie können auf dieseWeise einen Blick in die Objekte werfen, die sich auf dem Heap befin-den.

Referenzvariablen inspizieren

Objekte werden auf dem Heap gespeichert. Sie schwimmen da rum, wiedie Fische in einem Aquarium. Das Objekt, in das Sie mit dem Inspektorhineingeblickt haben, ist genau so ein Fisch. Es reicht nicht, dass Sie dieFelder des Objektes mit dem Inspektor betrachten; Sie möchten die Mög-lichkeit haben, die Felder zu verändern und die Methoden des Objektesaufzurufen. Java bietet Ihnen keine Handhabe, das Objekt direkt anzu-sprechen. Sie können seine Datenfelder und Methoden nur indirekt überdie Variable erreichen. Zwischen der Variablen und dem Objekt gibt es

Abbildung 8.4 Datenfelder inspizieren

175


eine Verbindung, die sogenannte Referenz. Die Referenz wird in Abbil-dung 8.5 durch den abgeknickten Pfeil symbolisiert.

Referenz löschen Können Sie diese Referenz eigentlich auch löschen? Angenommen, derKunde löst das Konto auf, dann können Sie mit dem Befehl

girokonto = null;

die Referenz löschen. Das Objekt, das mit dieser Referenz verbundenwar, ist jetzt nutzlos. Wenn eine Referenz einmal gelöscht wurde, kannein Objekt nicht mehr erreicht oder wieder referenziert werden.

Garbage Collector Objekte, die ohne Referenz auf dem Heap sind, sind wie Fische, die amEnde ihrer Lebenszeit Rückenschwimmen an der Wasseroberflächeüben. Sie nehmen unnötig Platz weg und müssen daher entfernt werden.Der Fischzüchter hat einen Gehilfen, der, wenn er ein wenig Zeit hat, dietoten Fische aus dem Aquarium herausfischt und in der Toilette runter-spült. Java hat auch einen Gehilfen, den Garbage Collector, der, wenn ergerade Zeit hat, Objekte ohne Referenz vom Heap herunterfegt.

Vielleicht kennen Sie aus anderen Programmiersprachen den Grundsatz,dass Sie als Programmierer auch für die Verwaltung des Speicherberei-ches verantwortlich sind. Das ist in Java anders. Sie arbeiten ausschließ-lich mit Variablen. Java sorgt selbst für sein Speichermanagement.

Das Schlüsselwort »static«

Klassenvariablen Datenfelder können zu einem Objekt gehören, sie können aber auch aneine Klasse gebunden sein. Daten, die für alle Objekte Gültigkeit haben,werden üblicherweise als Klassenvariablen angelegt. Hier kommt dasSchlüsselwort static zum Tragen:

public class Mensch{

Abbildung 8.5 Symbol für eine Referenz

176


private static String species = "Homo sapiens";// ...

}

Listing 8.6 Klassenvariable anlegen

InstanzvariablenDatenfelder, die nicht static sind, gehören zu einem bestimmtenObjekt; jedes Objekt der Klasse Mensch hat ein eigenes Datenfeld alter:


private static String species = "Homo sapiens";private int alter = 0;// ...

}

Listing 8.7 Jedes Objekt hat ein eigenes Datenfeld »alter«.

8.3.2 Methoden

Umfangreiche Anforderungen zerlegen Sie in kleine handhabbare Ein-heiten. Das betrifft nicht nur die Aufteilung von Programmen in einzelneKlassen, sondern auch die Zerlegung von Problemen in kleinere Teilpro-bleme innerhalb einer Klasse. Teilprobleme einer Klasse werden inMethoden gelöst. Dabei hat jede Methode ihren eigenen Verantwor-tungsbereich: Eine Methode wandelt eine Zeichenkette in Großbuchsta-ben um, eine andere Methode teilt einen String in unterschiedliche Teileusw.

Die allgemeine Struktur von Methoden

Formaler Metho-denaufbau

In Kapitel 3, »Erste Schritte in Java«, hatte ich Methoden kurz angespro-chen. Lassen Sie uns das Thema jetzt auf den Punkt bringen und detail-lierter betrachten. Wenn Sie sich die Methoden, die Sie bisher deklarierthaben, betrachten, fällt Ihnen sicher die allgemeine Struktur einerMethodendeklaration auf:

[Modifizierer] Rückgabewert Bezeichner (Parameter){

// Anweisungen}

Sie haben einen Bezeichner, eine Liste von Parametern, einen Rückgabe-wert und einen Modifizierer. Bezeichner und Parameterliste bilden dieSignatur der Methode. Die Signatur und der Rückgabewert bilden den

177


Methodenkopf. Lassen Sie uns die einzelnen Bestandteile, Parameter,Rückgabewert und Bezeichner, besprechen. Fangen wir mit den Parame-tern an.

Parameter – was einer Methode übergeben werden kann

Parameter einerMethode

Sie können beliebig viele Parameter mit beliebigem Typ an eine Methodeübergeben. In diesem Abschnitt verlassen wir das Konto-Beispiel. Siedeklarieren eine Methode, der zwei Ganzzahlen übergeben werden.Innerhalb der Methode werden diese Zahlen addiert, und das Ergebniswird an den Aufrufer zurückgegeben. Für die Rückgabe des Wertes istdas Schlüsselwort return zuständig – die return-Anweisung wird gleichnoch genauer besprochen. Konzentrieren wir uns im Moment nur aufdie Parameter.

public class UeberladungBeispiel{

public int addiere(int a, int b){

int c = a + b;return c;

}}

Listing 8.8 Parameter übergeben

UnterschiedlicheDatentypen

Damit haben Sie die Methode addiere() definiert, der zwei Ganzzahlenübergeben werden können. Wenn Sie nun zwei Gleitkommazahlenaddieren möchten, ist diese Methode offensichtlich unbrauchbar. Sielegen also eine weitere Methode mit gleichem Bezeichner an, ändernaber die Parameterliste, wie in Listing 8.9 gezeigt:


public int addiere(int a, int b){

int c = a + b;return c;

}

public double addiere(double a, double b){

double c = a + b;

178


return c;}

}

Listing 8.9 Neue Methode mit anderer Parameterliste

Methoden-überladung

Sie werden vielleicht stutzig und fragen, ob es überhaupt erlaubt ist, zweiMethoden mit gleichem Bezeichner zu deklarieren. Erlaubt ist es, zweioder mehr Methoden mit gleichem Bezeichner zu erstellen, solange dieMethoden unterschiedliche Signaturen haben. Die Methode ist jetztüberladen. BlueJ wird Ihnen diese Klasse, ohne zu meckern, kompilierenund ausführen. Während der Laufzeit entscheidet die VM, welche derbeiden Methoden addiere() ausgeführt wird.

Überladung verlangt unter-schiedliche Argumentlisten.

Zulässig sind folgende Überladungen:

� Die Methoden unterscheiden sich in der Anzahl der Parameter:public int addiere(int a, int b) { }

public int addiere(int a, int b, int c) { }

� Die Methoden unterscheiden sich im Typ der Parameter:public double addiere(int a, int b) { }

public double addiere(int a, double b) { }

� Die Methoden unterscheiden sich in der Reihenfolge der Parameter:public double addiere(double a, int b) { }


Alle Methoden, die hier aufgeführt sind, könnten innerhalb einer Klassedeklariert werden – sie haben unterschiedliche Signaturen.

Unzulässige Überladungen

Keine zulässigen Überladungen liegen in folgenden Fällen vor:

� Der Rückgabewert ist ein anderer, aber die Parameterliste ist gleich:public double addiere(int a, int b) { }

public int addiere(int a, int b) { }

� Die Reihenfolge der Parameter ist eine andere, der Datentyp der Para-meter bleibt aber gleich:public int addiere(int a, int b) { }

public int addiere(int b, int a) { }

� Die Parameter haben lediglich unterschiedliche Bezeichner:public int addiere(int a, int b) { }

public int addiere(int c, int d) { }

179


Folgende zwei Methoden hingegen sind zulässig überladen:public double addiere(double a, int b) { }


Gleiche Namenvon Variablen

Das heißt, dass Sie beide Methoden in einer Klasse deklarieren können.Was passiert, wenn die Klasse bereits Variablen mit gleichem Bezeichnerhat?


private double a;private double b = 3.1415;private double c = addiere(5, b);

public double addiere(int a, double b){

double c = a + b;return c;

}// ...

}

Listing 8.10 Variablen mit gleichem Bezeichner

Überschatten vonDatenfeldern

Die Parameter a und b überschatten die Datenfelder a und b; genausoüberschattet die lokale Variable c das Datenfeld c. Solange die Methodeausgeführt wird, kennt Java die Datenfelder nicht, sondern nur die lokaleVariable bzw. die Parameter. Das heißt, dass lokale Variablen und Para-meter Vorrang vor Datenfeldern mit gleichem Bezeichner haben.

Gültigkeit vonParametern

Parameter haben nur innerhalb der Methode Gültigkeit, an die sie über-geben wurden; sie sind nur dort sichtbar. Lokale Variablen leben nur

Näheres zum Begriff »Parameter«

Der Begriff Parameter ist nicht ganz eindeutig. Wenn Sie eine Methode vonaußen betrachten, sprechen Sie von Argumenten, also: Sie als Aufrufer, alsNutzer einer Methode übergeben ihr ein Argument. Anders sieht es aus,wenn Sie die Methode von innen betrachten, sprich was die Methode internmit dem Argument macht. Dann ist der richtige Begriff der des Parameters.Das heißt, Sie übergeben der Methode ein Argument; die Methode arbeitetmit diesem Parameter. Gemeint ist aber dieselbe Information. Teilweise fin-den Sie auch die Begriffe formaler Parameter für Parameter und aktuellerParameter für Argument.

180


innerhalb des Blockes bzw. der Methode, in dem bzw. in der sie dekla-riert wurden.

Welche Information an einen Parameter übergeben wird

Warum sind die Variablen des Aufrufers von den Variablen der Methodeunabhängig, obwohl sie gleiche Bezeichner haben? Gibt es hierfür eineErklärung? Betrachten Sie zur Klärung dieser Fragen die Zeile, in der dieMethode addiere() aufgerufen wird:

double c = addiere(5, b);

Übergabe von Werten an Parameter

Hier werden die Zahl 5 und die Variable b an die Methode übergeben.Um genau zu sein: Nicht die Variable b wird übergeben, sondern derWert, der in der Variablen b gespeichert ist, also die Zahl 5, wird in denParameter kopiert.

Wie sieht das bei komplexen Datentypen aus? Zum Einstieg ein Beispiel:Sie definieren in der main-Methode ein Array von Zahlen. Diesem Arraywerden in aufsteigender Reihenfolge die Zahlen von 1 bis 5 zugewiesen.Danach wird das Array als Parameter an die Methode aendern() überge-ben. Innerhalb dieser Methode werden die einzelnen Array-Elementejeweils mit 2 multipliziert. Nachdem die Methode aendern() ausgeführtwurde, geben Sie die Elemente des Arrays einzeln auf der Konsole aus.Was wird ausgedruckt?

Übergabe von Array-Objekten

public class ArrayBeispiel{


int[] zahlen = new int[]{1, 2, 3, 4, 5};

aendern(zahlen);

for (int i : zahlen){

System.out.println(i);}

}

private static void aendern(int[] parameter){

for(int j = parameter.length – 1; j >= 0; j--){

parameter[j] = 2 * (j + 1);

181


}}

}

Listing 8.11 Array übergeben

Analyse desBeispiels

Auf der Konsole werden die Zahlen 2, 4, 6, 8, und 10 ausgegeben. Waspassiert da? Sie legen ein Array mit bestimmten Werten an: int[] zahlen= new int[]{1, 2, 3, 4, 5}; Auf dem Heap befindet sich ein Array-Objekt, das die Zahlen speichert. Die Variable zahlen hält eine Referenzauf das Objekt. Wenn Sie die Methode aendern() aufrufen und dabeizahlen als Parameter übergeben, kopieren Sie die Referenz in den Para-meter. Es gibt also jetzt zwei Variablen, die das gleiche Objekt referenzie-ren. Das ist so, als ob zwei Holzkreuze Fäden zu ein und derselben Mari-onette hielten. Die Einstellungen, die Sie mit dem einen Holzkreuzvorgenommen haben, werden durch das andere wieder geändert.

Java arbeitet also sehr konsequent: Wenn Sie eine Methode aufrufen unddabei eine Variable als Parameter mitgeben, wird immer der Inhalt derVariablen in den Parameter kopiert. Wenn Sie eine Variable mit elemen-tarem Datentyp übergeben, wird der Wert dieser Variablen kopiert.Wenn Sie eine Variable mit komplexem Datentyp übergeben, wird dieReferenz kopiert.

Übergabe vonString-Objekten

Jetzt möchte ich Ihnen eine Besonderheit vorstellen. Die Klasse Stringstellt ebenfalls einen komplexen Datentyp zur Verfügung. Probieren wiraus, ob der gleiche Quelltext sich auf diesen Datentyp übertragen lässt. Inder folgenden Klasse passiert das Gleiche wie im vorigen Beispiel: Sielegen eine String-Variable an und initialisieren sie mit einem beliebigenText. Danach übergeben Sie diese Variable an eine Methode, innerhalbderer der String in Großbuchstaben umgewandelt wird. Wenn dieMethode vollständig ausgeführt wurde, geben Sie den Text auf der Kon-sole aus. Nehmen wir die Argumentation von oben und sagen: »Ich über-gebe der Methode eine Kopie der Referenz. Es gibt nun zwei Variablen,die das gleiche String-Objekt referenzieren: das Datenfeld und den Para-meter. Innerhalb der Methode wird auf dem Parameter eine Methodeaufgerufen. Wenn ich die Methode verlasse, sollte der String in Groß-buchstaben vorliegen.«

Der zugehörigeBeispielcode

public class StringBeispiel{


182


String text = "Hallo, schöne Java-Welt!";

aendern(text);

System.out.println(text);}

private static void aendern(String parameter){

parameter = parameter.toUpperCase();}

}

Listing 8.12 String-Objekt an Methode übergeben

Analyse des Beispiels

Was wird auf der Konsole ausgegeben? Auf der Konsole wird derursprüngliche Text in gemischten Groß- und Kleinbuchstaben ausgege-ben. Was stimmt da nicht? Warum verhalten sich Strings und Arraysunterschiedlich? Die Antwort ist in der Klasse String zu suchen. String-Objekte sind unveränderlich, im Fachbegriff auch immutable genannt.Das bedeutet, dass jede Änderung an der Variablen ein neues Objekt aufdem Heap erzeugt: Wenn Sie also den String ändern – durch den AufruftoUpperCase() beispielsweise –, wird auf dem Heap ein neues Objektangelegt und der Variablen parameter zugewiesen. Die Variablenparameter und text halten jetzt zwei unterschiedliche Referenzen.

Parameter der main-Methode – Kommandozeilenparameter

Programmen Parameter mitgeben

Sie werden gelegentlich die Notwendigkeit haben, an ein ProgrammParameter zu übergeben: Wenn Sie auf der DOS-Konsole dir *.txt ange-ben, werden alle Dateien im aktuellen Verzeichnis mit der Endung .txtangezeigt. Der Zusatz *.txt ist ein Parameter für das Programm dir. Wiekönnen Sie einem Java-Programm Parameter mitgeben? Wenn Sie einProgramm außerhalb von BlueJ laufen lassen möchten, muss mindestenseine Klasse eine main-Methode haben. Diese main-Methode – das kennenSie aus den vorigen Kapiteln – hat folgende Schnittstelle:

Parameter der main-Methode

public static void main(String[] args)

Als Parameter wird ein Array von Strings mit dem Bezeichner argserwartet. Auf dieses Array kann innerhalb der main-Methode zugegriffenwerden:

public class KommandozeilenParameter{

183



for(String temp : args){

System.out.println("Parameter: " + temp);}

}}

Listing 8.13 Kommandozeilenparameter

Übergabe einesString-Arrays

Wenn Sie Listing 8.13 in BlueJ mit void main(String[] args) ausführen,werden Sie aufgefordert, einen Parameter einzugeben (siehe Abbildung8.6). Dieser Parameter muss ein String-Array sein. Geben Sie ihn so ein,wie Sie in Kapitel 4, »Variablen, Datentypen und Operatoren«, ein Arrayinitialisiert haben, zum Beispiel {"ein Parameter", "noch ein

Parameter", "letzter Parameter"}. Die Parameter stehen Ihnen alsString-Array args innerhalb der Klasse zur Verfügung. Wenn Sie Ihr Pro-gramm außerhalb von BlueJ laufen lassen, übergeben Sie Kommando-zeilenparameter an Ihr Programm, die auf gleiche Weise ausgewertetwerden.

Abbildung 8.6 Ein Programm mit Parametern aufrufen

184


VarArgs – variable Argumentanzahl

Variable Argu-mentanzahl

Sie können ein Programm mit einer beliebigen Anzahl von Parameternaufrufen. Sie können aber auch eine Methode aufrufen, die ein Arrayvon int-Zahlen erwartet:

public static int addiere(int[] zahlen){

int ergebnis = 0;for(int temp : zahlen){

ergebnis += temp;}return ergebnis;

}

Listing 8.14 Array von Zahlen an Methode übergeben

Ein Array als Parameter

Wenn Sie diese Methode aufrufen, übergeben Sie ihr ein Array von Zah-len, also zum Beispiel {1, 2, 3, 4} (siehe Abbildung 8.7).

Syntax von »varArgs«

Da in der Praxis sehr oft die Notwendigkeit gegeben ist, ein Array an eineMethode zu übergeben, gibt es seit Java 5 eine abgekürzte Schreibweise,die varArgs, variable Argumentanzahl. Sie schreiben den Datentyp desArrays, dann drei Punkte und schließlich den Bezeichner:

public static int addiere(int ... zahlen){

int ergebnis = 0;for(int temp : zahlen){

ergebnis += temp;}return ergebnis;

}

Listing 8.15 Array übergeben mit varArgs

Abbildung 8.7 Ein Array von Zahlen als Parameter mitgeben

185


Arbeiten mit»varArgs«

Intern wird varArgs als Array umgesetzt, weshalb Sie die for-each-Schleife weiter verwenden können. Die drei Punkte ersetzen die Array-Deklaration jedoch nicht einfach; Sie sind nun frei, ein bis beliebig vieleint-Zahlen an die Methode zu übergeben, ohne die Argumente als Arraydeklarieren zu müssen:

public void teste(){

int c = addiere(1, 2, 3, 4);System.out.println(c);

}

Listing 8.16 Beliebig viele int-Zahlen übergeben

Wenn Sie zusätzlich zu varArgs weitere Parameter vorsehen, mussvarArgs der letzte Parameter sein:

public static double addiere(double b, int ... zahlen){

double result = b;for(int temp : zahlen){

result += temp;}return result;

}

Listing 8.17 varArgs als letzter Parameter

Das Schlüsselwort »this« und der Punktoperator

Problemstellung Die Klasse Kunde enthält die Instanzvariable name vom Typ String. Die-ses Datenfeld ist als private deklariert:

public class Kunde{

// ... gekürzt ...private String name = new String();public void setName(String pName){

name = pName;}

}

Listing 8.18 Bezeichner für Parameter und Datenfeld finden

186


Hier gibt es ein Problem.

Sie arbeiten bei dieser Implementierung mit zwei Variablen – der In-stanzvariablen name und dem Parameter pName. Dadurch, dass ich denParameter pName genannt habe, umgehe ich folgendes Problem:

public class Kunde{

private String name = new String();// ...public void setVorname(String name){

name = name;}

}

Listing 8.19 Bezeichner von Parameter und Datenfeld sind gleich.

Das Datenfeld wird in diesem Beispiel überschattet. Das hat zur Folge,dass das Datenfeld name innerhalb der Methode nicht bekannt ist. Über-schatten ist nach der Konvention nur innerhalb von Konstruktoren undMethoden zulässig, die ein Feld initialisieren.

Schlüsselwort »this«

Wenn Sie in einem solchen Fall einen Parameter haben, der den gleichenNamen hat wie ein Feld – was manchmal sehr praktisch ist –, setzen Siedie Referenz this vor die Variable, und verbinden Sie this und denBezeichner mit einem Punkt, dem Punktoperator:

public void setName(String name){

this.name = name;}

Das Schlüsselwort this ist eine Referenz auf das aktuelle Objekt, sozusa-gen der erhobene Zeigefinger, mit dem das Objekt auf sich selbst deutetund sagt: Meinem Datenfeld wird der Wert des Parameters zugewiesen.Sie können den Zeigefinger weglassen, wenn eindeutig ist, welcheMethode oder welche Variable bzw. welches Feld angesprochen werdensoll. Java denkt sich den Zeigefinger dann selbst dazu. Daher funktio-nierte die ursprüngliche Zuweisung name = pName – das Datenfeld wirdhier nicht überschattet.

PunktoperatorDer Punktoperator verbindet die Referenz – this oder eine andere Refe-renz – und das aufzurufende Element. In den vorigen Kapiteln haben Sieeinen String in Großbuchstaben umgewandelt:

String hallo = "Hallo";hallo = hallo.toUpperCase();

187


Hier verbindet der Punktoperator die Referenzvariable hallo mit derMethode toUpperCase().

Was kann eine Methode zurückgeben?

Rückgabewerteeiner Methode

Genauso spannend wie die Frage, was an eine Methode übergeben wer-den kann, ist die Frage, was von ihr zurückgeliefert wird. Methoden sindkeine Anweisungen, sondern Ausdrücke. Das heißt, dass eine Methodeeinen Rückgabewert hat. Der Typ des Rückgabewertes kann entwedervoid – nichts – sein oder ein elementarer bzw. ein komplexer Datentyp.Der Typ wird im Methodenkopf festgelegt. Da eine Methode ein Aus-druck ist, muss sie einen eindeutig bestimmten Wert mit einem eindeu-tigen Datentyp zurückgeben.

Bedingte undunbedingte

return-Anweisung

Die letzte Anweisung jeder Methode, die einen anderen Typ als voidzurückgibt, muss eine return-Anweisung sein. Sie können zwar einereturn-Anweisung in einen if-Block schreiben, allerdings muss auch indiesem Fall die letzte Anweisung der Methode eine return-Anweisungsein, die entweder im else-Zweig oder ohne Bedingung ausgeführt wer-den wird. Nach einem return darf kein weiterer Quelltext stehen.

Der Wert nach return muss dem Datentyp entsprechen, den Sie imMethodenkopf vorgesehen haben. Das heißt, dass zum Beispiel dieMethode public int addiere(int a, int b) mit einem zurückgegebenenint-Wert enden muss.

Betrachten Sie folgenden Code-Ausschnitt in Listing 8.20:

public int getSumme(){

int a = 2, b = 5;int c = a + b;

if (a + b > c){

return a + b; // erstes return}// return; // zweites returnreturn c; // drittes return// System.out.println(c);

}

Listing 8.20 Verschiedene return-Anweisungen

188


Analyse des Beispiels

Sie finden hier drei return-Anweisungen. Die erste return-Anweisungwird bedingt ausgeführt. Der Code ist nur kompilierbar, wenn an ande-rer Stelle eine weitere – unbedingte – return-Anweisung steht. Der Com-piler achtet darauf, dass in jedem Fall ein eindeutiger Wert zurückgege-ben wird. Die zweite return-Anweisung kann nicht kompiliert werden,weil ein eindeutiger int-Wert erwartet wird; ein return ohne Ausdruckvom Typ int ist daher unzulässig. Nach der Anweisung return c endetdie Methode. Die letzte Zeile System.out.println(c) wird also niemalsausgeführt werden; und damit wird der Code nicht übersetzt.

Rückgabetyp ist »void«

Was wird der Programmcode in Listing 8.21 machen?

public void druckeWennPositiv(int x){

if (x <= 0)return;

System.out.println(x);}

Listing 8.21 Eine Methode hat den Rückgabewert »void«.

Als Parameter übergeben wird einen int-Wert – als Rückgabewert wirdvoid erwartet. Die Methode kann also ohne return-Anweisung beendetwerden. Wenn x null – also Zahl 0 – oder negativ ist, wird die Methodemit der return-Anweisung ohne Rückgabewert beendet. Andernfallswird die println-Methode aufgerufen und der Parameter auf dem Bild-schirm ausgegeben.

Bezeichner einer Methode

Bezeichner von Methoden

Der Bezeichner einer Methode muss immer ein Verb sein, dasbeschreibt, was geschehen soll:

� public void drucke(String text)

� public int addiere(int a, int b)

� public void setName(String name)

� public String getName()

� usw.

Bezeichner von Methoden mit Booleschem Rückgabewert

Bezeichner von Methoden, deren Rückgabewert ein Boolescher Wert ist,beginnen nach der Konvention mit is. Folgende Methode prüft, ob eineeingegebene Zahl gerade oder ungerade ist. Falls der Rest einer Divisiondurch 2 ungleich 0 ist, ist die Zahl ungerade, sonst gerade:

189


public boolean isOdd(int wert){

if(wert % 2 != 0)return false;

elsereturn true;

}

Listing 8.22 Methode mit Booleschem Rückgabewert

Umsetzungin der Praxis

Leicht lesbarerQuelltext

Beim Aufruf der Methode können Sie nun sehr elegant codieren:

if (isOdd(3))[Anweisung]

Ihr Quelltext entspricht dann einem hölzern klingenden Englisch, aber erist leichter les- und nachvollziehbar. Übrigens ist es nicht einheitlich, obdie Eigenschaft, die geprüft werden soll – hier odd – auf Deutsch oder aufEnglisch bezeichnet wird. Daher gibt es Programmierer, die bezeichnendie Methode isOdd(), und es gibt Programmierer, die bezeichnen dieMethode isUngerade(). Im Netz finden Sie Beispiele sowohl für die eineals auch für die andere Schreibweise. Beide Lösungen haben ihre Berech-tigung. Wichtig ist nur, dass der Bezeichner mit is beginnt.

»Methode« vs.»Funktion« und

»Prozedur«

Wie wird diese Methode in der Praxis umgesetzt?

Der Prüfung auf Ungleichheit generiert einen Booleschen Wert, der dannwahr ist, wenn der Wert auf der linken Seite ungleich dem auf der rechtenSeite ist. Sonst ist das Ergebnis der Prüfung falsch. Es spricht nichts dagegen,diesen Ausdruck so zurückzugeben:

public boolean isOdd(int wert){ return wert % 2 != 0;}

Zum Begriff »Methode«

Von anderen Programmiersprachen kennen Sie vielleicht die Begriffe Funk-tion und Prozedur. Funktionen haben einen Rückgabewert, Prozeduren kei-nen. Diesen Unterschied kennt Java nicht – es gibt nur Methoden. Die einenhaben einen Rückgabewert, die anderen nicht, aber sprachlich unterschie-den wird hier nicht. In einigen Lehrbüchern gibt es die Begriffe sondierendeMethode für rein lesenden Zugriff und verändernde Methode für lesendenund/oder schreibenden Zugriff.

190


Das Schlüsselwort »static« bei Methoden

Statische Methoden

Genau wie Datenfelder können Methoden an ein Objekt oder eine Klassegebunden sein. Ein statisches Datenfeld kann entweder von einerObjektmethode oder von einer Klassenmethode gelesen und verändertwerden (siehe Listing 8.23). Ein nicht-statisches Datenfeld kann nur voneiner Objektmethode gelesen und verändert werden.


private static String species = "Homo sapiens";private int alter = 0;// ... gekürzt ...// statische Methode:

Beispiel statische Methode

public static void aendereSpecies(){

species = "Homo oeconomicus";}

// möglich auch nicht-statische Methode:public void veraendereSpecies(){


// nur nicht-statische Methode zulässig:public void altern(){

alter++;}

}

Listing 8.23 Statische Methode deklarieren und verwenden

Sie können den Unterschied zwischen statischen und nicht-statischenMethoden sehen, wenn Sie einen rechten Mausklick auf die Klasse oderein Objekt setzen. Eine statische Methode ist nur im Kontextmenü derKlasse, eine nicht-statische Methode ist nur im Kontextmenü einesObjektes verfügbar.

Sichtbarkeit von Methoden

Gültigkeit von Methoden

Wer konnte noch auf Datenfelder zugreifen? Private Datenfelder dürfennur von der Klasse selbst bzw. deren Instanzen gelesen und geschriebenwerden. Öffentliche Datenfelder (Deklaration public) sind im Inspektor

191


von BlueJ, dann aber auch von anderen Objekten bzw. Klassen sichtbar.Bei Methoden ist das genauso. Wenn Sie eine Methode als privatedeklarieren, können nur die Klasse selbst und deren Instanzen sie aus-führen – private Methoden werden im Kontextmenü eines Objektesnicht angezeigt.

Praktische Anwendung: rekursive Methoden

Rekursive Metho-den – formaleBeschreibung

Rekursive Methodenaufrufe sind keine Besonderheit von Java – man fin-det sie in fast allen Programmiersprachen. Rekursion bedeutet, dass eineMethode sich selbst aufruft. Innerhalb der Methode gibt es eineAbbruchbedingung, die verhindert, dass eine Methode sich endlos oftaufruft.

Lassen Sie uns ein Beispiel aus der Mathematik nehmen: die Fakultät.Gesucht ist 5!:

5! = 5 * 4! = 5 * 4 * 3! = 5 * 4 * 3 * 2! = 5 * 4 * 3 * 2 * 1 = 120

Die Aufgabe besteht also darin, die eingegebene Zahl so lange mit ihremVorgänger, ihrem Vorvorgänger usw. zu multiplizieren, bis die zu multi-plizierende Zahl 1 ist. Ein erster Ansatz könnte so wie in Listing 8.24 aus-sehen:

Ein nicht-rekur-siver Ansatz

public class Fakultaet{

public static void main (String[] args){

System.out.println(berechneFakultaet_nr(5));}

private static long berechneFakultaet_nr(int zahl){

long ergebnis = 1;for (int i = zahl; i >= 1; i--)

ergebnis *= i;return ergebnis;

}}

Listing 8.24 Fakultät berechnen – erster Ansatz

192


Die rekursive Lösung

Wie sieht der rekursive Ansatz aus? Listing 8.25 zeigt den Beispielcodean. Das Programm startet in der main-Methode. Dort soll das Ergebnisvon berechneFakultaet(5) auf der Standardausgabe gedruckt werden.Dieser Methodenaufruf hat die höchste Priorität und wird zuerst aufge-löst. Die Methode berechneFakultaet() prüft im ersten Schritt, ob diezu multiplizierende Zahl kleiner oder gleich 0 ist. Wenn das zutrifft, wird1 zurückgegeben, sonst wird die zu multiplizierende Zahl mit der Fakul-tät der nächstkleineren Zahl multipliziert; diese Prüfung auf 0 ist dasAbbruchkriterium, da eine Multiplikation mit 0 immer 0 als Ergebnishat.

Beispielcode rekursive Lösung

public class Fakultaet{

public static void main (String[] args){

System.out.println(berechneFakultaet(5));}

private static long berechneFakultaet(int zahl){

if (zahl <= 0)return 1;

elsereturn zahl * berechneFakultaet(zahl – 1);

}}

Listing 8.25 Fakultät berechnen – rekursiver Ansatz

Was passiert in jedem Schritt? Tabelle 8.1 gibt einen Überblick.

Rekursion auflösen

Methodenaufruf Rückgabewert

berechneFakultaet(5) 5 * berechneFakultaet(4)

berechneFakultaet(4) 5 * 4 * berechneFakultaet(3)

berechneFakultaet(3) 5 * 4 * 3 * berechneFakultaet(2)

berechneFakultaet(2) 5 * 4 * 3 * 2 * berechneFakultaet(1)

berechneFakultaet(1) 5 * 4 * 3 * 2 * 1 * berechneFakultaet(0)

berechneFakultaet(0) 5 * 4 * 3 * 2 * 1 * 1 = 120

Tabelle 8.1 Die einzelnen Schritte der Rekursion

193


8.3.3 Konstruktoren

Was passiert beider Objekt-erzeugung?

Lassen Sie uns genauer anschauen, was passiert, wenn ein Objekt erzeugtwird. Was passiert, wenn Sie mit Konto girokonto = new Konto() eineVariable anlegen? Der Operator new reserviert Speicherplatz für einneues Objekt vom Typ Konto auf dem Heap. Danach ruft er den Kon-struktor der Klasse auf und übergibt die Referenz an die Variable, hiergirokonto.

Sinn von Konstruktoren

Aufgabe einesKonstruktors

Was ist ein Konstruktor? Ein Konstruktor ist eine spezielle Methode, dienur bei der Objekterzeugung aufgerufen werden kann, so heißt wie dieKlasse und keinen Rückgabewert hat. Im Konstruktor werden in derRegel die Attribute initialisiert und das Objekt in einen gültigen Zustandversetzt.

Wenn Sie keinen eigenen Konstruktor anlegen, erstellt Java den Stan-dardkonstruktor. Der Standardkonstruktor hat keine Parameter undführt, wenn er von Java angelegt wird, keine Anweisungen aus. Siehaben den Standardkonstruktor bereits aufgerufen, als Sie einen rechtenMausklick auf eine Klasse im Projektfenster von BlueJ gesetzt haben undim Kontextmenü zum Beispiel new Konto() ausgewählt haben.

Öffnen Sie das Projekt Konto_3 von der beiliegenden DVD. In der KlasseKonto finden Sie den parameterlosen Konstruktor, der eine Erfolgsmel-dung auf der Konsole ausgibt. Wenn Sie nun ein Konto anlegen, wirdgleich nach der Objekterzeugung die Erfolgsmeldung aus Listing 8.26ausgegeben:

public class Konto{


Der parameterloseKonstruktor

public Konto(){

System.out.println("Das Konto wurde eröffnet");}// ... gekürzt

}

Listing 8.26 Parameterlosen Konstruktor deklarieren

Parameter an Konstruktoren übergeben

Der Kontostand wird mit 10 initialisiert. Sie möchten aber bei Anlage desKontos die Möglichkeit haben, auch einen anderen Wert an den Kon-

194


struktor zu übergeben. Dafür können Sie als Parameter einen Wert anden Konstruktor übergeben. Sie überladen den Konstruktor genauso wieSie weiter oben Methoden überladen haben:

public class Konto{


public Konto(){

System.out.println("Das Konto wurde eröffnet");}

Parameter an einen Konstruk-tor übergeben

public Konto(int betrag){

System.out.println("Das Konto wurde eröffnet");kontostand = betrag;

}// ... gekürzt

}

Listing 8.27 Konstruktor mit einem Parameter deklarieren

Verketteter Konstruktorenaufruf mit »this()«

Einen anderen Konstruktor aufrufen

Problematisch ist an dieser Lösung, dass doppelter Code vorkommt. DieErfolgsmeldung wird in beiden Konstruktoren aufgerufen. Sehr vielschöner wäre es, wenn Code, der auf jeden Fall ausgeführt werden muss,im Standardkonstruktor stehen würde und der Konstruktor, dem Sieeinen Parameter übergeben können, diesen Standardkonstruktor aufruft,so wie in Listing 8.28 zu sehen. Einen anderen Konstruktor rufen Sie mitdem this(); auf. Dieser Aufruf muss die erste Anweisung innerhalbeines Konstruktors sein:

public class Konto{


public Konto(){

System.out.println("Das Konto wurde eröffnet");}

public Konto(int betrag){

195


Beispiel Konstruk-toraufruf

this();kontostand = betrag;

}// ... gekürzt

}

Listing 8.28 Beispiel für verketteten Konstruktoraufruf

In gleicher Weise legen Sie in der Klasse Kunde einen Konstruktor an, derals Parameter eine Zeichenkette mit dem Namen und einen Wahrheits-wert erwartet:

public class Kunde{

// ... gekürztprivate boolean weiblich = false;private String name = new String();

public Kunde(String name, boolean weiblich){

this.name = name;this.weiblich = weiblich;

}// ... gekürzt

}

Listing 8.29 Konstruktor mit mehr als einem Parameter deklarieren

AutomatischeAnlage einesKonstruktors

Java legt für die Klasse Kunde nun keinen Standardkonstruktor mehr an:Sobald der Programmierer einen eigenen Konstruktor (mit Parameteroder nicht) angelegt hat, sieht Java sich nicht mehr in der Pflicht, denStandardkonstruktor anzulegen. Sie müssen nun, um eine Instanz derKlasse Kunde zu erzeugen, Parameter angeben. Den Aufruf des Konstruk-tors zeigt Abbildung 8.8.

Konstruktoren überladen

Konstruktorenüberladen

Das Prinzip der Überladung erlaubt, dass Sie die Reihenfolge der Parame-ter ändern. Sie möchten Ihrem Auftraggeber die Möglichkeit geben,neue Kunden auch mit folgendem Konstruktor zu erzeugen:

public Kunde(boolean weiblich, String name){

this.name = name;this.weiblich = weiblich;

}

Listing 8.30 Neue Kunden erzeugen

196


Auch hier kommt doppelter Code vor, was sehr unschön ist. Sie könnenParameter aber auch an this() übergeben, so dass Sie den KonstruktorKunde(String name, boolean weiblich) aufrufen und hierbei die Para-meter in der »richtigen« Reihenfolge angeben:

public Kunde(boolean weiblich, String name){

this(name, weiblich);}

Listing 8.31 Kunden erzeugen ohne Code-Dopplung

Mögliche Fehlerquellen

Mögliche Fehlerquellen

Was wäre, wenn man eine Methode deklarierte, die einen Rückgabewerterzwingt und genauso heißt wie die Klasse?

public void Konto(){

[Anweisung]}

Am Rückgabewert erkennt Java, dass es sich hier um eine »gewöhnliche«Methode und nicht um einen Konstruktor handelt.

Ließe sich ein Konstruktor auch manuell aufrufen?

Abbildung 8.8 Den Konstruktor der Klasse »Kunde« aufrufen.

197



Konto girokonto_1 = Konto.Konto();// oder:Konto girokonto_2 = girokonto_2.Konto();Konto girokonto_3 = girokonto.this();

}

Listing 8.32 Unzulässige Aufrufe des Konstruktors

Der Konstruktor wird im Zusammenhang mit der Objekterzeugungdurch den new-Operator automatisch aufgerufen.

Das Schlüsselwort »static«

Statische Blöcke Datenfelder und Methoden können an ein Objekt (nicht-statisch) odereine Klasse (statisch) gebunden sein. Wie ist das bei Konstruktoren? DaKonstruktoren immer bei Erzeugung eines Objektes ausgeführt werden,kann es keine statischen Konstruktoren geben. Dennoch besteht die Not-wendigkeit, Anweisungen ausführen zu können, die nicht zu einembestimmten Objekt gehören. Hierfür kennt Java die statischen Initialisie-rungsblöcke. Statische Initialisierungsblöcke werden ausgeführt, wenn dieKlasse in die virtuelle Maschine geladen wird. Sie sind keine statischenKonstruktoren, versetzen aber die Klasse in einen gültigen Zustand,indem Sie beispielsweise Klassenvariablen initialisieren. Insofern lässtsich ihre Aufgabe mit der von Konstruktoren vergleichen. Sie könnenbeliebig viele statische Blöcke anlegen – sie werden der Reihe ihres Auf-tretens nach ausgeführt, wenn die Klasse geladen wird:

Beispielcodestatischer Block


private static String species;// ... gekürzt ...// statischer Initialisierungsblockstatic{


}

Listing 8.33 Statischen Block deklarieren und ausführen

198

Das Konto-Projekt zum Abschluss bringen 8.4

8.4 Das Konto-Projekt zum Abschluss bringen

Öffnen Sie das Projekt Konto_4 von der beiliegenden DVD. Ich habe einpaar Änderungen vorgenommen. Die Methode setKontostand() benö-tigen Sie nicht mehr; in diesem abschließenden Beispiel werden Einzah-lungen und Abbuchungen durch entsprechende Methoden vorgenom-men.

Geld abhebenWenn Sie Geld abheben, darf der Kontostand nicht ins Minus rutschen.Legen Sie eine Variable vom Typ boolean an. Ihr Wert wird später anden Aufrufer zurückgegeben, um ihm zu sagen, ob erfolgreich Geld abge-hoben werden konnte. Danach testen Sie, ob durch die Buchung derKontostand ins Minus rutschen würde. Wenn nicht, wird die Buchungwie gewünscht durchgeführt.

public boolean abheben(double betrag){

boolean erfolgreich = false;if(kontostand – betrag >= 0){

kontostand -= betrag;erfolgreich = true;

}return erfolgreich;

}

Listing 8.34 Methode »abheben()«

Geld erhaltenJeder Kunde soll in der Lage sein, Geld zu erhalten. Hierfür gibt es dieMethode erhalteGeld(). In ihr wird zuerst geprüft, ob der Betrag, der inEmpfang genommen werden soll, positiv ist. Ist dies nicht der Fall, wirdder Vorgang mit einer entsprechenden Meldung beendet, andernfallswird der Betrag auf das Konto überwiesen.

public void erhalteGeld(int betrag){

if(betrag <= 0){

System.out.println("Ich kann kein Geld sehen.");}else{

girokonto.einzahlen(betrag);}

}

Listing 8.35 Methode »erhalteGeld()«

199


Geld überweisen Eine Überweisung soll in zwei Schritte unterteilt werden:

� Der Kunde hebt Geld von seinem eigenen Konto ab.

� Der Kunde zahlt das Geld auf das Konto eines anderen ein.

Arbeitsweise derMethode

Nur, wenn das Konto beim Abheben zurückmeldet, dass genug Geld vor-handen ist, wird die Einzahlung auf das fremde Konto vorgenommen.

public void ueberweisen(Kunde empfaenger, int betrag){

if(girokonto.abheben(betrag)){

empfaenger.erhalteGeld(betrag);}else{

System.out.println("Die Überweisung konnte nichtdurchgeführt werden.");

}}

Listing 8.36 Methode »ueberweisen()«

Die Klassen testen Klicken Sie im Menü des Konsolenfensters Methodenaufrufe proto-

kollieren an – dieses Protokoll ist für Sie jetzt interessant. Führen Siefolgende Schritte durch:

� Legen Sie in BlueJ zwei Objekte an: alice und bob.

� Lassen Sie beide sich vorstellen.

� alice zahlt Geld auf ihr Konto ein.

� alice überweist bob Geld.

Ausgabe derKonsole

Anschließend sollte Ihre Konsole folgenden Text anzeigen:

[ new Kunde(true, "Alice") ]Das Konto wurde eröffnet[ Kunde result = (new instance of Kunde) ][ new Kunde(false, "Bob") ]Das Konto wurde eröffnet[ Kunde result = (new instance of Kunde) ][ alice.vorstellen() ]Guten Tag, ich heiße Alice.[ bob.vorstellen() ]

200

Pakete importieren und statische Importe 8.5

Guten Tag, ich heiße Bob.[ alice.erhalteGeld(100) ][ alice.ueberweisen(bob, 50) ]

8.5 Pakete importieren und statische Importe

Die Aufgabe in diesem Abschnitt

Lassen Sie uns ein Beispiel für den Einsatz von Klassenattributen und-methoden besprechen. Die Aufgabe lautet: Sie sollen ein Array von20 int-Zahlen sortiert auf der Konsole ausgeben.

8.5.1 Aufgabe von Paketen

Wofür braucht man Pakete?

Bevor Sie diese Aufgabe angehen können, sollte ich Ihnen das Prinzip derPakete und ihres Imports zeigen. Fangen wir mit der Frage an, was einPaket ist. Sie werden, wenn Sie später als Programmierer arbeiten, auchgroße Projekte zu betreuen haben. Nichttriviale Projekte lassen sich nichtmehr übersichtlich in einer Handvoll Klassen aufteilen. Sie werden statt-dessen sehr viele Klassen haben, deren Aufgaben sich in bestimmte Kate-gorien einteilen lassen, meinetwegen sind x Klassen für die Oberflächezuständig und weitere y Klassen stellen die reine Anwendungslogik dar.Dabei decken z Klassen einen bestimmten Teilbereich des Projektes ab.Das klingt ziemlich verworren und unübersichtlich. Um Ordnung zuschaffen, gibt es Pakete. Pakete fassen Klassen zusammen, die fachlichzusammengehören.

Pakete bilden die Verzeichnis-struktur ab.

Pakete werden auf Verzeichnisebene durch unterschiedliche Unterord-ner dargestellt. Wenn Sie in das Installationsverzeichnis von Java gehen,finden Sie dort eine Datei, die source.zip heißt. Entpacken Sie diese undbetrachten Sie ihre Unterstruktur. Sie finden unter anderem einen Ord-ner, der java heißt. Unterhalb von diesem Ordner gibt es weitere Unter-ordner, vergleichbar der in Abbildung 8.9.

Diese Ordner repräsentieren in Java die Pakete. In ihnen sind die Klassenzu finden, die Ihnen zur Verfügung stehen. Die Ordnerstruktur lässtRückschlüsse darauf zu, was in den jeweiligen Unterordnern zu findenist: Da gibt es Klassen für die Dateibehandlung, für Datenbanken, fürGUIs usw.

201

Index

@Deprecated 218@Override 244

A

Abstract Window Toolkit 320AbstractButton (Klasse) 363AbstractTableModel (Klasse) 428, 576Abstrakte Klassen 268AccessibleJList (Klasse) 390Action (Interface) 455ActionEvent (Klasse) 340Adapterklassen 338Aggregation 229Algorithmus 25

Aufgabe 25Ausgangsparameter 26Durchführbarkeit 26Effizienz 26Eindeutigkeit 25Eingangsparameter 26Endlichkeit 26finden 28

Annotations 217, 218Anonyme Klasse 307Anweisung 50, 91API-Dokumentation 123ArgoUML 215Argument 180Arithmetische Operatoren 89Array

eindimensionales 72mehrdimensionales 74

ArrayList (Klasse) 496Assembler 29Assertions 479Assoziation 229

bidirektionale 250unidirektionale 250

Assoziativität 90Attribut 33, 51, 612, 623Aufzählungen 208Ausdrücke

Boolesche 108einfache 88

Ausdrücke (Forts.)komplexe 88

Ausnahmebehandlung 463Auto(un)boxing 427, 491AutoCommit 622AWT 320

Event-Handling 329Event-Quellen 333Low-Level-Events 330Peer-Klassen 320Semantische Events 332

B

Befehlssatz des Computers 29Bezeichner 49, 66

Methode 189Beziehungen zwischen Klassen 229Bidirektionale Assoziation 250Binär 90Binden, spätes 245Bindungsrichtung 90Bit 29Block 107

anlegen 56BlueJ

Debugger 310Direkteingabe 93Installation 39Klasse anlegen 41Klassenkarte 215Konfiguration 40Objekte erzeugen 57Objektleiste 58Programme weitergeben 46Projekt anlegen 40Projekt drucken 46Quelltext editieren 42

bluej.defs 40boolean (Datentyp) 71Boolescher Ausdruck 108Border (Interface) 354BorderLayout 410Boxing � Auto(un)boxingbreak 137

649

Index

Brückenklassen (Streams) 553, 556BufferedReader (Klasse) 559BufferedWriter (Klasse) 559ButtonGroup (Klasse) 329byte (Datentyp) 69Bytecode 30Byte-Stream 553

C

Calendar (Klasse) 274case-sensitive 66Casting 238Cast-Operator 101, 237catch 464Catch-or-Specify 467char (Datentyp) 72Character-Stream 553Checkbox 327Class (Klasse) 615Client 587Collection (Interface) 496Collection-API 487Collections (Klasse) 500Collections Framework 496ComboBoxModel (Interface) 393Commit 622Comparable (Interface) 508, 510, 512Compiler 30Component (Klasse) 321Computer, Arbeitsweise 29Connection (Interface) 615Constraints 414, 612Container (Klasse) 321Controller 380createCalendar() 274

D

Daemon-Thread 531Date (Klasse) 272Datei-Attribute 574Datenbank 612Datenbanksystem, relationales 610Datenbanktabelle 610Datenfeld 171, 173Datenkapselung 52, 171, 172Datentyp 51, 66

Attribute (SQL) 624

Datentyp (Forts.)boolean 71byte 69char 72Definition 68Double 427double 69eindimensionales Array 72explizite Umwandlung 101float 69implizite Umwandlung 101int 69komplexer 72, 74, 78long 69mehrdimensionale Arrays 74nicht-numerischer 71numerischer 69Referenz 173Referenzvariable 125short 69String 52, 78Überblick 80umwandeln 101

DBMS 612DefaultCellEditor (Klasse) 438DefaultMutableTreeNode (Klasse) 442DefaultTableModel (Klasse) 430Deklaration

Methoden 177Variablen 65

Dekrement 94Deprecated 218Deserialisieren 564Dialog

modaler 350nicht-modaler 350

DirectoryStream (Interface) 577Division

Ganzzahlen 97Gleitkommazahlen 100

Doclets 218Dokumentation

Doclets 218erstellen 45

Domain Name Service 585Domain-Namen 585Doppelter Code 225double (Datentyp) 69do-while-Schleife 134

650

Index

DriverManager (Klasse) 615Drucken 46

E

else 111EntrySet 519Entwurfsmuster 286

enum pattern 212Erich Gamma 286Gang of Four (GoF) 286MVC-Pattern 372, 383, 419Observer-Pattern 287PatternCoder 291Singleton-Patterns 290

Enumerations 208equals() 127Error 477Error (Klasse) 463Ersetzbarkeitsprinzip 235Event-Empfänger 333Event-Handling 329Event-Listener 333EventObject (Klasse) 329Event-Quellen 333Exception 464

checked 475unchecked 476

Exception (Klasse) 463Exception-Handling 463Explizite Typumwandlung 101

F

Fakultät 192false 71, 108Feld

nicht-statisches 83, 84statisches 83, 84

Feld (Array) 72File (Klasse) 550FileReader (Klasse) 558Files (Klasse) 548FileSystem (Klasse) 545FileSystems (Klasse) 545FileWhisperer 569FileWriter (Klasse) 557finally 466float (Datentyp) 69

FlowLayout 409FocusEvent (Klasse) 331for-each-Schleife 146Foreign Key 612for-Schleife 134

Laufvariable 135Prüfung 135, 137schachteln 141Update 135

Fremdschlüssel 612FTP 583

G

Gamma, Erich 286Ganzzahl 51, 70Garbage Collector 176Geheimnisprinzip 52, 172Generalisierung 230Generics 493, 509Geschäftslogik 372, 377, 384getClass() 254getSimpleName() 254Getter 55Gleichheitszeichen 92GregorianCalendar (Klasse) 275GridBagLayout 414GridLayout 412Gültigkeit von Methoden 191Gültigkeit von Parametern 180

H

Hashcode 262hashCode() 262HashMap (Klasse) 516HashSet (Klasse) 504Hat-ein-Beziehung 229Hauptmenü 323Heap 125, 175High-Level-Stream 563Hochsprachen 30Host-Namen 585Hüllklassen 491

I

if-Anweisung 108immutable 183

651

Index

Implizite Typumwandlung 101import 203import static 207Import, statischer 204InetAddress (Klasse) 586Initialisierung von Variablen 52Initialisierungsblock 198Inkrement 94Innere Klassen 295

anonyme 307lokale 304nicht-statische Memberklassen 301statische 298

InputEvent 330InputStream 552InputStreamReader (Klasse) 557Installation

BlueJ 39Java 37

instanceof-Operator 238Instanzvariablen 171int (Datentyp) 51, 69Interface 275Interpreter 30IP-Adresse 585ISO-OSI 584Ist-ein-Beziehung 229ItemEvent 336Iterable (Interface) 497Iterator (Interface) 497

J

JavaBytecode 44Installation 37Klassenbibliothek 31Kritik 32Standard Edition 32typisiert 101Versionen 32

Java 7BasicFileAttributes (Interface) 575,

578BasicFileAttributeView (Interface)

574Bezeichner mit beliebigen Zeichen 67Binärsystem 70Diamond Operator 495

Java 7 (Forts.)DirectoryStream (Interface) 577DosFileAttributes (Interface) 575DosFileAttributeView (Interface) 574Exception-Handling 480Files (Klasse) 561, 575Rautentyp 495Strings in switch 118try-with-resource 480, 554, 618Unterstriche in Literalen 71

Java Database Connectivity 614Java Development Kit 31Java Foundation Classes 320Java Platform 32Java Runtime Environment 31Java Virtual Machine 31java.lang.Thread.State 527java.nio.file.attribute 574java.util.EventObject 329java.utils 207JButton (Klasse) 339, 363JCheckBox (Klasse) 366JCheckBoxMenuItem (Klasse) 327JComboBox (Klasse) 392, 393JComponent (Klasse) 321, 354JDBC 614JDialog (Klasse) 322, 350JDK 31JEditorPane (Klasse) 396JFC 320JFrame (ContentPane) 349JFrame (GlassPane) 349JFrame (Klasse) 322, 339, 348JFrame (LayeredPane) 349JFrame (RootPane) 349JLabel (Klasse) 339, 361JList (Klasse) 368JMenu (Klasse) 324JMenuBar (Klasse) 323, 324JMenuItem (Klasse) 324join() (Thread) 528JOptionPane (Klasse) 401JPanel (Klasse) 339, 354JPasswordField (Klasse) 394JRadioButton (Klasse) 368JRadioButtonMenuItem (Klasse) 328JRE 31JScrollPane (Klasse) 359JSlider (Klasse) 397

652

Index

JSpinner (Klasse) 399JSplitPane (Klasse) 357JTabbedPane (Klasse) 356JTable (Klasse) 422

AbstractTableModel (Klasse) 428DatumsEditor 439DefaultCellEditor (Klasse) 438DefaultTableModel (Klasse) 430Editor 437Rendering 430Selektion 441Spaltenmodell 441Tabellenkopf 441TableColumn (Klasse) 441TableModel (Interface) 423TableRowSorter (Klasse) 434

JTextArea (Klasse) 395JTextField (Klasse) 390JToggleButton (Klasse) 365JTree (Klasse) 442, 448

Blatt 442DefaultMutableTreeNode (Klasse) 442Kindknoten 442Knoten 442Rendering 453Selektion 445TreeCellRenderer (Interface) 453TreeModel (Interface) 448TreePath (Klasse) 446TreeSelectionListener (Interface) 445Unterknoten 442Vaterknoten 442

JVM 31JWindow (Klasse) 322, 352

K

KeyEvent (Klasse) 330, 331KeyStroke 325Klasse 34

anlegen 41anonyme 307Bestandteile 173Bezeichner 42, 49innere 295Kohäsion 171lokale 304Object 254statische innere 298

Klasse (Forts.)Variablen 171

Klasse Objectequals() 257toString() 256

Klassenbeziehungen 229Aggregation 229Assoziation 229Generalisierung 230Komposition 229Spezialisierung 230Vererbung 229

Klassenbibliothek 31Klassendesign, schlechtes 225Klassenentwurf 170, 172Klassenname 202Klassenvariable 83Klassenvariablen 176Kohäsion 171Kölling, Michael 31Kommandozeilenparameter 183Kommentare 59

Blöcke 60Dokumentation 60einzeilige 60

Komplexe Datentypen 72Konkatenieren 158Konstruktoren

Parameter 194parameterlose 194Sinn 194statische Blöcke 198Sub- und Superklassen 240Überladung 196verketteter Aufruf 195

Kopfgesteuerte Schleife 133Kopplung 172

L

LaF 419Layoutmanager 408

BorderLayout 410Constraints 414FlowLayout 409GridBagLayout 414GridLayout 412Interface 408Vererbungshierarchie 408

653

List (Interface) 497ListDataEvent (Klasse) 388ListDataListener (Interface) 384, 387Listener 333ListModel (Interface) 383Literal 66, 88Locale (Klasse) 274localhost 585Logische Operatoren 112

Wahrheitstabelle Oder 115Wahrheitstabelle Und 113

Logisches Nicht 116Logisches Oder 115Logisches Und 113Lokale Klassen 304

Zugriffsrechte 306Lokale Variable � Variablelong (Datentyp) 69Look and Feel 419Low-Level-Events 330Low-Level-Stream 563

M

main-Methode 50Mehrdimensionales Array 74Mehrfachvererbung 230, 284Member-Klassen 295Methoden 52

abstrakte 269Argument 180Aufgabe 177Bezeichner 189Deklaration 53, 177Funktion 190Gültigkeit 191Kopf 53, 178main 50Parameter 54, 178, 180Parameterliste 178Prozedur 190rekursive 192Rückgabewert 53, 54, 188Rumpf 53Sichtbarkeit 191Signatur 54, 177sondierende 55, 190überladen 179überschreiben 243

Methoden (Forts.)VarArgs 185verändernde 55, 190

MIME-Typ 579Modaler Dialog 350Modifizierer

Attributzugriff 52Klassenzugriff 50Methodenzugriff 53private 52public 50, 52

Modulo-Operator 98Moe 42MouseEvent 330Multithreading 523MVC-Pattern 372, 419

Beispiel 383Controller 372, 380Model 372, 377, 379, 383View 372, 379, 385

MySQL 612

N

Namenskonventionen 67Nebenläufigkeit 523Netbeans 408Nicht-modaler Dialog 350Nicht-numerischer Datentyp 71null 127Numeral 66, 88Numerischer Datentyp 69Nutzt-ein-Beziehung 229

O

Object (Klasse) 254getClass() 254hashCode() 262

Objekterzeugen 57, 194Verhalten 33Zustand 33

Objektgraph 566Objektorientierte Analyse und Design

215Objektorientierte Programmierung 33Objektorientierung 33

Attribute 33, 51

Index

Objektorientierung (Forts.)Datenkapselung 52, 172equals() 127Geheimnisprinzip 52, 172Klasse 34Objekte vergleichen 127Verhalten 33, 52Zustand 33

Observable (Klasse) 288Observer (Interface) 287ODBC 620OOAD 215OOP 33Operanden 89Operatoren 88

arithmetische 89Assoziativität 89, 90binär 90binäre 117Cast 101, 237Definition 89, 113Division und Rest 97instanceof 238logische 112Logisches Nicht 116Logisches Oder 115Logisches Und 113Modulo 98Operanden 89Priorität 89, 110Punktoperator 186ternäre 117unäre 90, 117Vergleich 109Zuweisung 91, 92

OSI 584OutputStream 552OutputStreamWriter (Klasse) 558

P

Paket 201Parallelität 526Parameter 54, 85

aktueller 180formaler 180Gültigkeit 180Methode 178

Parameterliste 178

Parameterloser Konstruktor 194Pascalsches Dreieck 77, 141Path 38Path (Interface) 545, 546PatternCoder 291Peer-Klassen 320Plausibilitätsprüfung 171Polymorphie 234Port 586Postdekrement 94Postinkrement 94Prädekrement 94Präinkrement 94Prepared Statement 635Primärschlüssel 612Primary Key 612println() 51Priorität, Operatoren 89private 52Programme weitergeben 46Programmiersprachen

Assembler 29Bytecode 30Compiler 30Hochsprachen 30Interpreter 30

Programmierung, objektorientierte 33Projekt

dokumentieren 45drucken 46

protected 239Protokoll 583public 50, 52Punktoperator 186, 187

Q

Quasi-Parallelität 526Quelltext 30

editieren 42

R

Refactoring 170Referenz 125Referenzdatentypen 173Referenzvariable 125

dynamischer Typ 235statischer Typ 235

655

Index

Rekursive Methoden 192Relationales Datenbanksystem 610Reserviertes Wort 67ResultSet (Interface) 628ResultSetMetaData (Interface) 630return-Anweisung 188Rollback 623Rückgabewert 53, 54

Methode 188Runnable (Interface) 523RuntimeException (Klasse) 463

S

Schachtelungstiefe innerer Klassen 299

SchleifenAbbruch 136Abbruch mit continue 138break 136do … while 134for 134for-each 146fußgesteuerte 134Prüfung 135, 137Update 135

Schnittstelle 275Semantische Events 332Separator 324Serialisieren 564Server 587Set (Interface) 503Setter 55short (Datentyp) 69Sichtbarkeit 238

von Methoden 191SimpleDateFormat (Klasse) 272sleep() (Thread) 528SMTP 583Socket 585Sondierende Methode 55sort (Klasse Collections) 509Spalten 612Spätes Binden 245Spezialisierung 230Sprachkonventionen

Boolesche Variablen 108finale Variablen 81Klammern bei if-else 112

Sprachkonventionen (Forts.)Variablen 68

SQL 616AUTO_INCREMENT 625CREATE DATABASE 616CREATE TABLE 622, 624Datentypen 624DELETE FROM 633DROP DATABASE 616IN 633INNER JOIN 631INSERT INTO 626SELECT 628SELECT ... FROM 628UPDATE 634WHERE 632

SQL-Injection 636Stack-Trace 479Standard Edition 32Standardausgabe (System.out) 555Standardeingabe (System.in) 553Statement (Interface) 616static (Schlüsselwort) 176, 198

Methoden 191Statische Importe 204Statische innere Klasse 298Statischer Initialisierungsblock 198Streams 552

High Level 563Low Level 563

String � DatentypStröme 552Superklasse 225Swing 320switch

break 119case 118default 120Definition 117

Symmetrie-Gebot 258synchronized (Schlüsselwort) 537

T

Tabellen sortieren 434TableColumn (Klasse) 441TableColumnModel (Interface) 441TableModel (Interface) 423

AbstractTableModel (Klasse) 428

656

Index

TableModel (Interface) (Forts.)addTableModelListener() 427DefaultTableModel (Klasse) 430getColumnClass() 427getColumnCount() 424getColumnName() 425getRowCount() 424getValueAt() 426isCellEditable() 425removeTableModelListener() 427setValueAt() 426

TableRowSorter (Klasse) 434Tastenkürzel, Menü 325TCP/IP 583

Schichten 584this (Schlüsselwort) 186Thread

BLOCKED 527Daemon 531NEW 527RUNNABLE 527TERMINATED 527TIMED_BLOCKED 527WAITING 527Zustandsänderung 527

Thread (Consumer_Producer) 540Thread (Klasse) 523Thread-Scheduler 526Thread-Synchronisierung 537Throwable (Klasse) 463, 618Timer (Klasse) 532TimerTask (Klasse) 532TimeZone 274TimeZone (Klasse) 273Tooltips 355toString() 255toUpperCase() 183Transitivitäts-Gebot 258TreeModel (Interface) 448, 571

addTreeModelListener() 449getChild() 451, 452getChildCount() 450, 452getIndexOfChild() 452getRoot() 449isLeaf() 450removeTreeModelListener() 449valueForPathChanged() 449

TreePath (Klasse) 446TreeSelectionListener (Interface) 445

TreeSet (Klasse) 513Trennlinie 324true 71, 108try 464Tupel 612Typisiert 101Typsicherheit 493Typumwandlung

explizite 101implizite 101

U

ÜberladungKonstruktoren 196unzulässige 179

Übersetzer 30Übertragungsprotokoll 583UDP 583Umgebungsvariablen 38UML 215Unär 90Unboxing � Auto(un)boxingUnidirektionale Assoziation 250Unified Modeling Language 215URL (Datenbank) 615

V

VarArgs 185Variable

Datentyp 51Deklaration 51, 65, 66dynamischer Typ 235finale 81initialisieren 52Instanzvariablen 82, 84Klassenvariablen 83Konstante 81lokale 84Namenskonventionen 67nicht-statisches Feld 84Parameter 85statischer Typ 235statisches Feld 84überschatten 180variable 81

Verändernde Methode 55Vererbung 225, 229

657

Index

Vererbungshierarchie 232Vergleichsoperatoren 109

Priorität 110Verhalten 33, 52Verketteter Konstruktorenaufruf 195Verteilen von Programmen 46Vielgestaltigkeit 234Voll qualifizierter Klassenname 202Voll-Duplex 583

W

Wahrheitstabellelogisches Oder 115logisches Und 113

Wahrheitswerte 71Well Known Ports 586while-Schleife 133WindowEvent 334

WindowEvent (Klasse) 331Wrapper-Klassen 491

Y

yield() (Thread) 528

Z

Zeichenketten 52Zeitscheibe 526Zugriffsmodifizierer

Attribute 52Klassen 50Methoden 53

Zugriffsrechte 238, 239Zustand 33Zuweisungsoperator 91, 92

658

Einführung in Java mit BlueJ - s3-eu-west-1.amazonaws.com · Florian Siebler Einführung in Java...

Documents

Transcript of Einführung in Java mit BlueJ - s3-eu-west-1.amazonaws.com · Florian Siebler Einführung in Java...