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

Click here to load reader

  • date post

    01-Apr-2018
  • Category

    Documents

  • view

    216
  • download

    3

Embed Size (px)

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

  • Florian Siebler

    Einfhrung in Java mit BlueJObjektorientierte Programmierung fr Einsteiger

  • 3

    Auf einen Blick

    TEIL I Grundlagen

    1 Einfhrung ................................................................ 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 Benutzeroberflchen

    11 Einfhrung 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 Nebenlufigkeit ......................................................... 523

    17 Dateien, Datenstrme, Serialisieren ........................... 545

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

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

  • Inhalt

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

    TEIL I: GRUNDLAGEN

    1 Einfhrung ................................................................ 25

    1.1 Was ist ein Algorithmus? ............................................ 251.2 Was haben Sie mit Algorithmen zu tun? ..................... 271.3 Beispiele fr 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 Rckgabewert ........ 543.2.4 Abschlieendes zu Methoden ........................ 553.2.5 Blcke ........................................................... 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 Mglichkeiten der Deklaration ...................... 82

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

    4.4.1 Prioritt und Assoziativitt ............................. 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 Blcke ........................................................................ 1075.2 Die if-Anweisung ....................................................... 1085.3 Vergleichsoperatoren ................................................. 1095.4 Mgliche Operanden bei Vergleichen ........................ 1105.5 Die Handlungsalternative else .................................... 1115.6 Logische Operatoren .................................................. 112

    5.6.1 Die Und-Verknpfung ................................... 1135.6.2 Die Oder-Verknpfung .................................. 1155.6.3 Logische Negation ......................................... 116

    5.7 Der ternre Operator ................................................. 1175.8 Die switch-Anweisung ............................................... 117

    6

  • Inhalt

    5.9 Beispiel: Bodymaindex (BMI) berechnen ................... 1205.10 Objekte vergleichen .................................................... 122

    5.10.1 Fr welche Objekte gelten die Aussagen? ...... 1225.10.2 Warum knnen 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 Fugesteuerte Schleifen do while ........................ 1346.3 For-Schleifen .............................................................. 134

    6.3.1 Schleifen unterbrechen break und continue 1376.3.2 Ein greres Beispiel fr for-Schleifen ............ 1386.3.3 Schachteln von for-Schleifen .......................... 1416.3.4 Erweiterung die for-each-Schleife ................ 146

    6.4 Das Wichtigste auf einen Blick .................................... 1506.5 bungen .................................................................... 151

    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 Kalendereintrge 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 Eingabemglichkeit schaffen .................. 208

    8.6 Enumerations ............................................................. 2088.6.1 Lsungsansatz 1 ............................................ 2098.6.2 Lsungsansatz 2 ............................................ 2108.6.3 Lsungsansatz 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 Lsungsansatzes .................... 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 Prfung 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 fr 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

    9.10 Das Wichtigste auf einen Blick .................................... 2649.11 bungen .................................................................... 265

    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 fr abstrakte Klassen:

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

    10.2.1 Definition des Begriffes .................................. 27510.2.2 Ein Beispiel fr 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 Lsungsansatz: mit

    herkmmlichen Mglichkeiten ....................... 29510.5.2 Der zweite Lsungsansatz: statische

    innere Klasse .................................................. 29810.5.3 Der dritte Lsungsansatz: nicht-statische

    Memberklasse ................................................ 30110.5.4 Der vierte Lsungsansatz: 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 BENUTZEROBERFLCHEN

    11 Einfhrung 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 Tastenkrzel fr 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-Empfnger ........................................... 33311.4.3 Event-Quellen ............................................... 33311.4.4 Zwei Beispiele fr 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

    12.7 Das Wichtigste auf einen Blick .................................... 40412.8 bungen .................................................................... 405

    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 knnen ......... 46214.1.2 Nachteile des ersten Ansatzes ........................ 462

    14.2 Einfhrung 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 Einfhrung 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

    15.6 Das Wichtigste auf einen Blick .................................... 52015.7 bungen .................................................................... 521

    16 Nebenlufigkeit ........................................................ 523

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

    16.2 Zustandsnderungen eines Threads ............................. 52716.2.1 Zustnde, 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 Prioritten 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, Datenstrme, 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 Strme und was kann man damit

    machen? ..................................................................... 55217.3.1 Mit Byte-Streams arbeiten ............................. 55317.3.2 Character-Streams und Brckenklassen .......... 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 Oberflche 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 Einfhrung von Multithreading ..... 59718.3.5 Schritt 5 eigene Objekte statt Strings .......... 59818.3.6 Schritt 6 Einfhrung von Services ................ 60318.3.7 Schritt 7 Funktionen in HashMap speichern 604

    18.4 Anregung fr 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

    schlieen ....................................................... 62119.5 Spalten anlegen .......................................................... 623

    19.5.1 Datentypen von Attributen ............................ 62419.5.2 Die Primrschlssel der Tabellen anlegen ....... 624

    19.6 Daten in die Tabellen eintragen .................................. 62619.7 Daten abfragen, ndern und lschen .......................... 628

    19.7.1 Daten abfragen .............................................. 62819.7.2 Tabellen verbinden ........................................ 63119.7.3 Die where-Klausel .......................................... 63219.7.4 Daten lschen 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 Lsungen .............................................................................. 643

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

    15

  • Vorwort

    Ist dieses Buch fr Sie geeignet?

    Als ich dieses Buch geschrieben habe, habe ich mich gefragt, wer Sie viel-leicht sein knnten. 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 verschlsseln, sondern sich stabile Grundlagenkennt-nisse aneignen. Daraus folgen zwei Konsequenzen: Erstens, ich blendeThemen wie Applet-Programmierung, Kryptografie und einige mehrkonsequent aus. Zweitens, ich mchte 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 Bcher mir geholfen haben, die Materie zu verstehen, undwelche nicht. Und dieses Wissen ist in dieses Buch eingeflossen: Es istgenau fr Sie geschrieben und fr Sie geeignet, wenn Java fr Sie Neu-land ist.

    Wodurch zeichnet sich diese Einfhrung aus?

    Sie werden mit diesem Buch keine Vokabeln lernen, sondern Muster,Strukturen und Zusammenhnge.

    Dadurch ist das Wissen, das Sie sich erwerben, nicht nur fr das aktu-elle Release gltig, sondern zukunftssicher.

    Diese Einfhrung spricht praktische Probleme an, und vor allem sinddie Beispiele ad hoc verstndlich.

    Sie lernen erst die Grundbegriffe der Java-Programmierung, bevor Siesich mit Objektorientierung beschftigen.

    Ein Weiteres mchte ich Ihnen vermitteln: wie man als Programmiererauf Probleme reagiert.

    Wie Sie Probleme nicht lsen

    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 verfllt.

    19

  • Vorwort

    Gerne werden erst einmal die Schuldigen gesucht, die fr das Problemverantwortlich sind, gelst wird es dadurch allerdings nicht.

    Wie Sie Problemelsen

    Doch wie knnen Sie sich stattdessen sinnvoll einem Problem nhern?Grundstzlich ist jedes EDV-Problem lsbar. In der EDV ist alles doku-mentiert, und alles folgt vorgegebenen Regeln. Die Aussage der Compu-ter spinnt ist lediglich die verkrzte Form von der Computer verhltsich exakt so, wie er soll, nur leider fehlt mir die ntige Kenntnis (oderMotivation), smtliche Regeln und Zusammenhnge zu verstehen.

    Ich mchte Ihnen die Gewissheit geben, dass Sie alle Probleme lsenknnen. Sie mssen nur wissen, wo Sie nachsehen mssen. Am Anfangwerden Sie ausfhrlich mit Ausdrcken und Operatoren arbeiten. Hier-bei ist es immer eine gute Idee, eine Priorittenliste 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 mssen, wenn Ihre Pro-gramme nicht so laufen, wie sie sollten.

    brigens lohnt es sich, Es wird etwas geschehen von Heinrich Bll 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 sichmglichst einfach in die Materie einarbeiten knnen. 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 Schlssel-wrter und Operatoren es gibt. Sie werden lernen, Programmteile wie-derholt oder bedingt auszufhren. Dieser Teil ist einer der wichtigsten inder Java-Programmierung berhaupt ohne diese Basics ist ein sinnvol-les Arbeiten berhaupt nicht mglich.

    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-

    oberflchen

    Der dritte Teil (Kapitel 11 bis 13) ist eine praktische Anwendung der ers-ten beiden Teile. Sie lernen, ansprechende Oberflchen 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 fr Ihr Studiumund auch fr 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 Einfhrung?

    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-fhren. Die Arbeit mit den Quelltexten ist unheimlich wichtig. Program-mieren lernt man nur, indem man es macht. Zu diesem Zweck enthltdas Buch viele bungsaufgaben in unterschiedlichen Schwierigkeitsgra-den. Und damit Sie einschtzen knnen, wie gut Ihre eigene Lsung ist,finden Sie im Anhang natrlich auch Musterlsungen.

    Dieses Buch in der Lehre einsetzen

    Zustzliches Unterrichtsmate-rial fr Dozenten

    Dieses Buch ist geeignet, um in der Lehre eingesetzt zu werden. WennSie Dozent sind, knnen Sie ergnzendes Unterrichtsmaterial und zustz-liche bungsaufgaben beim Verlag anfragen. Wenden Sie sich dafr bittean die im Impressum genannte Adresse.

    Didaktischer Ansatz

    Die Einfhrung verfolgt zunchst einen prozeduralen Ansatz und fhrtdie objektorientierte Programmierung erst danach ein, da dies aus didak-tischen Grnden sinnvoll ist. Deutsch lernt man schlielich auch nichtdadurch, dass man als Erstes Faust interpretiert.

    Zustzlich zu diesem Buch empfehle ich Ihnen dringend, auch mit denQuelltexten der Klassenbibliothek zu arbeiten. Auch hier stecken eigeneErfahrungen dahinter, schlielich kochen auch Oracle bzw. Sun nur mitWasser. Viele Klassen sind sogar so einfach implementiert, dass sie schonam Anfang, also im ersten Teil, besprochen werden knnen. 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 erklren, wenn Sie Ausschnitte des Quelltextes zeigen, alswenn Sie versuchen, die dahinterstehende Logik zu erklren.

    21

  • Vorwort

    Danke

    Dankbar bin ich

    meiner Freundin, Martina Guth, fr ihre Geduld, ihr Verstndnis undihre Untersttzung. Sie hat mir den Rcken freigehalten und michimmer wieder ermutigt danke!

    meinen Eltern, Helga und Jrgen Siebler, fr ihre Liebe. Sie haben mirdie ntige Kreativitt und Hartnckigkeit in die Wiege gelegt, umgroe Projekte wie dieses Buch zu einem guten Abschluss zu bringen.

    meinen Geschwistern, Martina, Frank und (in loving memory) BirgitSiebler, die fr 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 Entwrfegelesen 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 seinerlangjhrigen Erfahrung als Programmierer habe ich wirklich profi-tiert.

    Melanie Hirschberger (www.HuMT.de), deren Tipps und Ratschlge 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 fr die Untersttzung 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 Schlsselwort class

    49

  • Erste Schritte in Java3

    drckt aus, dass der Quelltext eine Klasse enthlt. Die geschweiftenKlammern markieren den Anfang und das Ende der Klasse.

    Zugriffs-modifizierer

    Vor dem Schlsselwort class finden Sie ein anderes Schlsselwort, nm-lich den Zugriffsmodifizierer public. Damit erlauben Sie der Auenwelt BlueJ, anderen Klassen den Zugriff auf diese Klasse. Es gibt weitereModifizierer, auf die wir im zweiten Teil dieser Einfhrung noch zu spre-chen kommen. Um Ihnen das Prinzip anschaulich darstellen zu knnen,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:

    public class Bezeichner{

    public static void main(String[] args){

    // 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 auerhalb von BlueJ laufensoll. Die VM sucht beim Start genau diese main-Methode als Einstiegs-punkt. Sie werden die main-Methode daher spter dafr verwenden, umObjekte zum Beispiel eine grafische Benutzeroberflche 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 ausfhrbarer Befehl an den Computer:

    public class Bezeichner{

    public static void main(String[] args){

    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 Anweisungmssen 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. Fr eine Klasse bentigen Sie zweiDinge: erstens Attribute wie den Namen und den Kontostand. Zweitensbrauchen Sie Verhalten, also die Mglichkeit, auf diese Attribute einzu-wirken. Fangen wir mit den Attributen an.

    3.2.1 Attribute

    Was sind Variablen?

    Welche Attribute mchten Sie anlegen? Oder, anders gefragt: WelcheInformationen mchten Sie speichern? Sie mchten den Kontostand,eine Zahl, speichern. Auerdem 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 whlen einen Namen fr dieseVariable, einen Bezeichner:

    int kontostand;

    Der Typ oder auch Datentyp bestimmt, welche Art von InformationSie in der Variablen speichern knnen. Das Schlsselwort int bewirkt,dass Sie einen ganzzahligen Wert in der Variablen kontostand speichernknnen. Weitere andere Datentypen, zum Beispiel fr Dezimalzahlenoder Wahrheitswerte, werden Sie im nchsten Kapitel kennenlernen.

    Mit Variablen arbeiten

    Was knnen Sie mit der Variablen kontostand anfangen? Sie knnen 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

  • Erste Schritte in Java3

    Beide Schritte knnen 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, mssenvon doppelten Anfhrungszeichen umschlossen sein:

    kontoinhaber = "Kunde Knig";

    Und natrlich knnen Sie eine Variable, die Text enthalten soll, auchgleich bei der Anlage initialisieren:

    String kontoinhaber = "Kunde Knig";

    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 Knig";

    }

    Listing 3.5 Position der Variablendeklaration

    3.2.2 Methoden

    Zugriffsrecht aufVariablen

    Attribute haben genau wie Klassen Zugriffsmodifizierer. Zwei dieserZugriffsmodifizierer mchte ich Ihnen jetzt vorstellen: public undprivate. Wenn Sie eine Variable public anlegen, kann die Auenwelt andere Objekte beliebig lesend und schreibend darauf zugreifen. Daswre eine unangenehme Situation, weil das Objekt dann keine Kontrolledarber htte, 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 ms-sen. Dieses Geheimnisprinzip wird im zweiten Teil ganz ausfhrlichunser Thema sein. Um Daten zu kapseln, legen Sie die Variablen immer

    52

  • Klassen in der Objektorientierung 3.2

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

    public class Konto{

    private int kontostand = 50;private String kontoinhaber = "Kunde Knig";

    }

    Listing 3.6 Daten in privaten Variablen kapseln

    Wofr werden Methoden gebraucht?

    Wie kann der Kontostand verndert werden? Oder auch: Wie kann derName gendert 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, knnen Sieden Wert innerhalb einer Methode zuweisen. Lassen Sie uns eineMethode entwickeln, die den Kontostand auf 50 setzt. Zunchst mssenSie sich einen Bezeichner fr die Methode berlegen. Da Methoden Ver-halten beschreiben, hat es sich als praktisch erwiesen, Methodennamenmit einem Verb beginnen zu lassen. Sie wollen den Kontostand setzenknnen, also whlen Sie den Bezeichner setKontostand(). Die Klam-mern am Ende sind zwingend. Warum? Dazu werden wir gleich nochkommen.

    RckgabewertSie mssen auerdem angeben, welchen Datentyp die Methode zurck-gibt. Wenn Sie keinen Rckgabewert erwarten, geben Sie an, dass Sienichts void erwarten.

    Zugriffs-modifizierer

    Und schlielich geben Sie auch bei Methoden einen Zugriffsmodifizierermit Sie kennen bereits public und private. Was zu den Modifizierernbei Klassen und Variablen gesagt wurde, gilt auch fr Methoden: Metho-den, die public sind, knnen von allen anderen Objekten aus aufgerufenwerden, Methoden, die private sind, knnen nur von der Klasse undderen Instanzen aufgerufen werden.

    MethodenkopfDer Kopf der Methode Methodenkopf oder Methodendeklaration siehtalso so aus:

    public void setKontostand()

    MethodenrumpfMachen wir Ngel mit Kpfen und geben dem Kopf der Methode aucheinen Rumpf. Der Rumpf beginnt mit einer ffnenden geschweiftenKlammer und schliet mit einer geschweiften Klammer. Zwischen diesenKlammern knnen mssen aber nicht Anweisungen stehen:

    53

  • Erste Schritte in Java3

    {// Anweisungen

    }

    Sie mchten, dass die Methode den Kontostand auf 50 setzt, also siehtdie Methode vollstndig so aus:

    public void setKontostand(){

    kontostand = 50;}

    Listing 3.7 Vollstndige Methode

    3.2.3 Optional: Parameter und Rckgabewert

    Was Sie gerade gesehen haben, ist die einfachste Form einer Methode.Sinnvoll einsetzen lassen sich Methoden, wenn Sie Parameter und Rck-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 dafr Parameter. Parameter bestehen aus einembestimmten Datentyp und einem Bezeichner. Sie werden in die rundenKlammern nach dem Methodennamen geschrieben. Innerhalb derMethode aber tatschlich auch nur innerhalb der Methode, an die siebergeben wurden knnen Sie auf diese Parameter zugreifen. Dannsind Sie so flexibel, dass Sie einen beliebigen Wert an die Methode ber-geben knnen:

    Methodenkopfmit Parameter

    public void setKontostand(int betrag){

    kontostand = betrag;}

    Listing 3.8 Methodenkopf mit Parameter

    Signatur einerMethode

    Sie knnen 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 Rckgabewerten

    Methoden knnen Rckgabewerte haben. In den Beispielen oben wurdevoid zurckgeben. Anstelle von void knnen Sie sich einen beliebigen

    54

  • Klassen in der Objektorientierung 3.2

    Datentyp zurckgeben lassen. Wenn Sie den Kontostand nicht setzen,sondern abfragen wollen, werden Sie die Methode sicher getKonto-stand() nennen wollen. Zugriff soll von berall her mglich sein, alsopublic. Der Rckgabewert ist die Zahl, die den Kontostand enthlt, alsoint. Der Methodenkopf sieht so aus:

    public int getKontostand()

    Methode mit Rckgabewert

    Wenn Sie einen Wert zurckgeben, mssen Sie innerhalb der Methodeden Befehl return aufrufen:

    public int getKontostand(){

    return kontostand;}

    Listing 3.9 Methode mit Rckgabewert

    3.2.4 Abschlieendes 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 vollstndige Klasse

    Getter und SetterSie haben ein Attribut, den Kontostand. Jedes Objekt der Klasse Kontohat sein eigenes Attribut kontostand; dieses Attribut ist nur fr daseigene Objekt sicht- und zugreifbar. Nach auen ist das Attribut nichtsichtbar. Die Methode, die das Attribut zurckgibt, nennt man Getteroder auch sondierende Methode. Die Methode, die den Inhalt des Attribu-tes ndert, wird Setter oder auch verndernde Methode genannt.

    55

  • Erste Schritte in Java3

    Sind Sie es leid, immer wieder System.out.println() schreiben zu ms-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 Rckgabewert bentigen Sie nicht(void). Schlielich 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 Attributhinzufgen

    Mit diesem Wissen sollte es fr Sie leicht sein, das Attribut kontoinhaberzu implementieren. Der zugehrige 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 gekrzt wieder:

    public class Konto{

    private String kontoinhaber = "Kunde Knig";

    public String getKontoinhaber(){

    drucke(kontoinhaber);return kontoinhaber;

    }

    public void setKontoinhaber(String name){

    kontoinhaber = name;}

    }

    Listing 3.12 Quelltext der Klasse Konto (Auszug)

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

    3.2.5 Blcke

    Ein Block ist die Zusammenfassung von keinem, einem oder vielenBefehlen. Blcke beginnen wie Methodenrmpfe mit einer ffnendengeschweiften Klammer und enden mit einer schlieenden geschweiftenKlammer. Sie knnen Blcke innerhalb von Methoden anlegen:

    56

  • Ein Objekt erzeugen 3.3

    public static void main(String[] args){

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

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

    }

    Listing 3.13 Blcke anlegen

    Blcke gruppieren verschiedene Anweisungen und sind selbst eineAnweisung. Es kann sinnvoll sein, Code nur unter bestimmten Bedin-gungen auszufhren. Sehr oft werden Sie auch die Notwendigkeit haben,den Code im Block wiederholt auszufhren. Wie das geht und wann dasntzlich ist, werden Sie in den nchsten 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, undwhlen Sie new Konto(). Mit diesem Befehl erzeugen Sie ein neuesObjekt (siehe Abbildung 3.1).

    Abbildung 3.1 Ein neues Objekt erzeugen

    57

  • Erste Schritte in Java3

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

    Bezeichner frObjekte

    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

    ausfhren

    Setzen Sie einen rechten Mausklick auf eines der Objekte. Whlen Sie imKontextmen getKontoinhaber(). Da Sie den ursprnglichen Wert nochnicht gendert haben, gibt BlueJ Ihnen den Initialwert Kunde Knigzurck, wie Sie in Abbildung 3.4 sehen knnen.

    Abbildung 3.2 Einen Bezeichner fr das Objekt eingeben

    Abbildung 3.3 Zwei Objekte Instanzen der Klasse Konto

    Abbildung 3.4 Rckgabewert anzeigen lassen

    58

  • Kommentare 3.4

    Setzen Sie wieder einen rechten Mausklick auf das Objekt alice. WhlenSie im Kontextmen setKontoinhaber(String kontoinhaber). BlueJfordert Sie im folgenden Dialog auf, den Namen des Kontoinhabers ein-zugeben vergessen Sie nicht die umschlieenden Anfhrungszeichen(Abbildung 3.5).

    Sie knnen 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 gendert hat.

    3.4 Kommentare

    Bessere ber-sichtlichkeit

    In der Anfangszeit sind Ihre Programme bersichtlich und einfach. Abersptestens, wenn Sie diese Einfhrung 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. Auerdem werden Sie selbst beiberschaubaren Programmen schon nach kurzer Zeit nicht mehr genauwissen, was Sie mit dieser oder jener Methode oder Klasse erreichenwollten.

    Zudem knnen 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 Grnde, um einen Quelltext lesbar zu machen, wobeiKommentare ein wesentlicher Aspekt sind. Sie knnen Ihren Quelltextmit drei Arten von Kommentaren versehen.

    Abbildung 3.5 Den Namen des Kontoinhabers eingeben

    59

  • Erste Schritte in Java3

    Einzeilige Kommentare

    EinzeiligeKommentare

    Einzeilige Kommentare werden durch doppelte Schrgstriche // 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

    Kommentarblcke

    Kommentarblcke Kommentarblcke werden durch /* eingeleitet und mssen 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 automatischfr Sie erstellt.

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

    * Sternchen am Zeilenanfang sind mglich, 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 Rck-gabewerten. Hierfr verwenden Sie @param und @return:

    /*** Gibt den Kontoinhaber zurck* @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

  • Erste Schritte in Java3

    Sinn derDokumentation

    Ein Programmierer, der die Klasse verwenden mchte, muss sich jetztnicht mehr mit dem Quelltext beschftigen. Er kann mit einem Blick indie Dokumentation sehen, was die Methode macht, welche Parameterund welche Rckgabewerte 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 fr die JVM.

    Sie knnen mssen aber nicht einer Methode einen oder mehrereParameter mitgeben.

    Eine Methode kann muss aber nicht an den Aufrufer eine Infor-mation zurckgeben.

    Fr die Klasse, fr Variablen und fr Methoden gibt es Zugriffsmodi-fizierer.

    Modifizierer regeln, wer auf die Klasse zugreifen darf.

    Quellcode wird mit Kommentaren lesbar aufgebaut.

    Es gibt einzeilige Kommentarzeilen, Kommentarblcke 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 hierfr ist, dass dieMethode private ist. Dieser Zugriffsmodifizierer bewirkt, dass von auen Sie mit BlueJ niemand zugreifen kann. Zugriff ist nur durch andere Metho-den der Klasse im Beispiel getKontoinhaber() mglich. 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 Kontobevollmchtigter.

    2. ndern Sie den Zugriffsmodifizierer der Methode drucke(Stringtext) in public. Erstellen Sie die Dokumentation neu, sehen Sienach, was sich gendert 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 fr 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 fhren Blcke gezielt wiederholt aus.

    Und Sie haben bereits einen Vorgeschmack auf objektorientierte Kon-zepte bekommen, whrend 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 heit. Der Datentyp String lsst sich alsoauf eine Klasse String zurckfhren. In der Dokumentation haben Sieetliche Methoden gefunden, die die Klasse String definiert, und die vonden Instanzen dieser Klasse ausgefhrt werden konnten beispielsweisekonnten Sie mit den Bordmitteln des Strings einen Text in Grobuchsta-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 ausgefhrt werden.

    167

  • Grundlegende Aspekte der OOP8

    Sie fragen sich vielleicht, ob daraus der Schluss gezogen werden kann,dass Strings und Konten fr 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 ProjektKonto_1

    Das folgende Beispiel soll Ihnen zeigen, wie Sie mit selbst definiertenDatentypen arbeiten knnen. 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 Knig";

    public void einzahlen(int betrag){

    kontostand += betrag;}

    public void setKontoinhaber(String name){

    kontoinhaber = name;}// ...

    }

    Listing 8.1 Die Klasse Konto (Auszug)

    Methodeueberweisen()

    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 mchten, mssen 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 knnen.

    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 Feldfr 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 Kontostnde anzeigen. Sie sehen, dass dasGeld wie gewnscht auf dem Konto-Objekt bob angekommen ist.

    Abbildung 8.1 Zwei Objekte vom Typ Konto

    169

  • Grundlegende Aspekte der OOP8

    Zusammenfas-sung und Ausblick

    Ihre eigenen Klassen knnen also genauso Datentypen sein wie dieDatentypen, die Java mitbringt. Sie werden, wenn Sie ein Programmschreiben, sehr viele Klassen komplexe Datentypen entwickeln. Imdritten Teil dieser Einfhrung werden noch grafische Benutzerober-flchen hinzukommen. Dadurch ndert sich zwar der Grad an Komplexi-tt und Abstraktion, aber das Prinzip ist immer das gleiche: Unabhngigvom Abstraktionsgrad und unabhngig von der Komplexitt 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 groe 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 Aktivitt, ein bestehen-des Projekt zu berarbeiten, ohne die Funktionalitt zu verndern, wirdRefactoring genannt.

    Abbildung 8.2 Parameter fr die Methode berweisen() eingeben

    170

  • Inhalt einer Klasse der Klassenentwurf 8.2

    Kohsion einer Klasse

    Jede Klasse hat einen eigenen Verantwortungsbereich und soll eine ein-zige Aufgabe erfllen: Wenn Sie eine Klasse haben, die Konto heit,werden Sie darin Daten zum Konto erwarten. Eine Klasse, die Kundeheit, ist fr 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 Kohsion. Der Begriff Koh-sion bezieht sich nicht nur auf Klassen, sondern auch auf Methoden: Wassoll eine Methode alles tun? Eine Methode fhrt 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 knnen. 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 mchten wissen, dass derComputer bootet, wenn Sie den Rechner anschalten. Der Computerher-steller hat Ihrem Wunsch Rechnung getragen. Er stellt Ihnen einen Schal-ter zur Verfgung, mit dem Sie den Computer starten. Was dann imInneren stattfindet, wenn der Rechner hochfhrt, darf ruhig das Geheim-nis des Herstellers bleiben. Das gleiche Prinzip liegt bei Objekten vor. Siedeklarieren private Datenfelder und knnen deren Werte ber ffentli-che Methoden lesen und verndern. In diesen Methoden werden in derPraxis viele Plausibilittsprfungen vorgenommen, von denen derAnwender nichts mitbekommt.

    Sie werden gleich eine Klasse Konto entwerfen, in der der Kontostandenthalten ist. Wenn ein Kunde eine berweisung ausfhren mchte,wird erst einmal geprft, ob berhaupt Geld auf dem Konto ist. Htte derKunde direkten Zugang auf seinen Kontostand, knnte die Bank diesePrfung nicht durchfhren, und sie wrde 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 spter 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

  • Grundlegende Aspekte der OOP8

    selbst bzw. von Instanzen der Klasse gelesen und verndert werden kn-nen, nennt man Datenkapselung oder Geheimnisprinzip.

    Ein Beispiel freine Plausibilitts-

    prfung

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

    public void einzahlen(int betrag){

    kontostand += betrag;}

    Es ist bei dieser Umsetzung immer noch mglich, einen negativen Betrageinzuzahlen, was einer Abbuchung gleich kme. Eine Plausibilittspr-fung knnte sein, dass zuerst geprft wird, ob der einzuzahlende Betragpositiv ist:

    public void einzahlen(int betrag){

    if(betrag >= 0){

    kontostand += betrag;}

    }

    Listing 8.3 Plausibilittsprfung

    Kopplung Die Klassen Kunde und Konto sind, da jede Klasse ihren eigenen Verant-wortungsbereich hat, unabhngig voneinander. Jede Klasse hat ihreDaten gekapselt. Die daraus erzeugten Objekte knnen nur ber Zugriffs-methoden, zum Beispiel ueberweisen(), miteinander kommunizieren.Man sagt dazu, die Klassen sind lose gekoppelt. Anders wre es, wenn dieKlassen nicht lose gekoppelt wren. Ein Objekt der Klasse Kunde httedann lesenden und schreibenden Zugriff auf das Datenfeld kontostand.Das wrden Sie aus zwei Grnden nicht wollen: Zum einen wre derGrundsatz der Datenkapselung verletzt, zum anderen htte jede nde-rung der Klasse Konto sehr umfangreiche Auswirkungen auf die KlasseKunde. Wenn das Datenfeld kontostand von int auf double gendertwrde, msste jeder Zugriff auf dieses Datenfeld berprft 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 Kohsion 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 knnen einfacher realisiert werden.

    172

  • Bestandteile einer Klasse 8.3

    Wenn beispielsweise knftig bei den Kundendaten auch die E-Mail-Adresse des Kunden hinterlegt werden soll, muss die bereits getesteteund lauffhige Klasse Konto nicht mehr berhrt werden. Umgekehrt kn-nen die Kundendaten unverndert bernommen werden, wenn derKunde ein weiteres Konto erffnet oder einen Bausparvertrag abschliet.

    8.3 Bestandteile einer Klasse

    Woraus bestehen Klassen?

    Objektorientierung bildet die Gegenstnde 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 ausgefhrt werden, wenn das Objekterzeugt wird.

    8.3.1 Datenfelder und Referenzdatentypen

    Datenfelder sind Variablen, die auerhalb eines Blockes und auerhalbeiner Methode deklariert werden. Was Variablen sind und wie man mitVariablen umgeht, wurde in Kapitel 4, Variablen, Datentypen und Ope-ratoren, ausfhrlich 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. Auerdemgibt es eine Variable vom Typ String, in der der Name des Kundengespeichert wird, und schlielich 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

  • Grundlegende Aspekte der OOP8

    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 zurckgeliefert.

    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;// ... gekrzt

    }

    Listing 8.5 Einzelnes Datenfeld

    Abbildung 8.3 Projektfenster mit Verwendungspfeil

    174

  • Bestandteile einer Klasse 8.3

    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 knnen 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 mchten die Mg-lichkeit haben, die Felder zu verndern und die Methoden des Objektesaufzurufen. Java bietet Ihnen keine Handhabe, das Objekt direkt anzu-sprechen. Sie knnen seine Datenfelder und Methoden nur indirekt berdie Variable erreichen. Zwischen der Variablen und dem Objekt gibt es

    Abbildung 8.4 Datenfelder inspizieren

    175

  • Grundlegende Aspekte der OOP8

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

    Referenz lschen Knnen Sie diese Referenz eigentlich auch lschen? Angenommen, derKunde lst das Konto auf, dann knnen Sie mit dem Befehl

    girokonto = null;

    die Referenz lschen. Das Objekt, das mit dieser Referenz verbundenwar, ist jetzt nutzlos. Wenn eine Referenz einmal gelscht 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 Rckenschwimmen an der Wasseroberflcheben. Sie nehmen unntig Platz weg und mssen daher entfernt werden.Der Fischzchter hat einen Gehilfen, der, wenn er ein wenig Zeit hat, dietoten Fische aus dem Aquarium herausfischt und in der Toilette runter-splt. 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 fr die Verwaltung des Speicherberei-ches verantwortlich sind. Das ist in Java anders. Sie arbeiten ausschlie-lich mit Variablen. Java sorgt selbst fr sein Speichermanagement.

    Das Schlsselwort static

    Klassenvariablen Datenfelder knnen zu einem Objekt gehren, sie knnen aber auch aneine Klasse gebunden sein. Daten, die fr alle Objekte Gltigkeit haben,werden blicherweise als Klassenvariablen angelegt. Hier kommt dasSchlsselwort static zum Tragen:

    public class Mensch{

    Abbildung 8.5 Symbol fr eine Referenz

    176

  • Bestandteile einer Klasse 8.3

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

    }

    Listing 8.6 Klassenvariable anlegen

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

    public class Mensch{

    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 gelst. Dabei hat jede Methode ihren eigenen Verantwor-tungsbereich: Eine Methode wandelt eine Zeichenkette in Grobuchsta-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, fllt Ihnen sicher die allgemeine Struktur einerMethodendeklaration auf:

    [Modifizierer] Rckgabewert Bezeichner (Parameter){

    // Anweisungen}

    Sie haben einen Bezeichner, eine Liste von Parametern, einen Rckgabe-wert und einen Modifizierer. Bezeichner und Parameterliste bilden dieSignatur der Methode. Die Signatur und der Rckgabewert bilden den

    177

  • Grundlegende Aspekte der OOP8

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

    Parameter was einer Methode bergeben werden kann

    Parameter einerMethode

    Sie knnen beliebig viele Parameter mit beliebigem Typ an eine Methodebergeben. 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 zurckgegeben. Fr die Rckgabe des Wertes istdas Schlsselwort return zustndig 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 Ganzzahlenbergeben werden knnen. Wenn Sie nun zwei Gleitkommazahlenaddieren mchten, ist diese Methode offensichtlich unbrauchbar. Sielegen also eine weitere Methode mit gleichem Bezeichner an, ndernaber die Parameterliste, wie in Listing 8.9 gezeigt:

    public class UeberladungBeispiel{

    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

  • Bestandteile einer Klasse 8.3

    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 jetztberladen. BlueJ wird Ihnen diese Klasse, ohne zu meckern, kompilierenund ausfhren. Whrend der Laufzeit entscheidet die VM, welche derbeiden Methoden addiere() ausgefhrt wird.

    berladung verlangt unter-schiedliche Argumentlisten.

    Zulssig 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) { }

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

    Alle Methoden, die hier aufgefhrt sind, knnten innerhalb einer Klassedeklariert werden sie haben unterschiedliche Signaturen.

    Unzulssige berladungen

    Keine zulssigen berladungen liegen in folgenden Fllen vor:

    Der Rckgabewert 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

  • Grundlegende Aspekte der OOP8

    Folgende zwei Methoden hingegen sind zulssig berladen:public double addiere(double a, int b) { }

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

    Gleiche Namenvon Variablen

    Das heit, dass Sie beide Methoden in einer Klasse deklarieren knnen.Was passiert, wenn die Klasse bereits Variablen mit gleichem Bezeichnerhat?

    public class UeberladungBeispiel{

    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; genausoberschattet die lokale Variable c das Datenfeld c. Solange die Methodeausgefhrt wird, kennt Java die Datenfelder nicht, sondern nur die lokaleVariable bzw. die Parameter. Das heit, dass lokale Variablen und Para-meter Vorrang vor Datenfeldern mit gleichem Bezeichner haben.

    Gltigkeit vonParametern

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

    Nheres zum Begriff Parameter

    Der Begriff Parameter ist nicht ganz eindeutig. Wenn Sie eine Methode vonauen 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 heit, 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 fr Parameter und aktuellerParameter fr Argument.

    180

  • Bestandteile einer Klasse 8.3

    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 Methodeunabhngig, obwohl sie gleiche Bezeichner haben? Gibt es hierfr eineErklrung? Betrachten Sie zur Klrung 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() ausgefhrtwurde, geben Sie die Elemente des Arrays einzeln auf der Konsole aus.Was wird ausgedruckt?

    bergabe von Array-Objekten

    public class ArrayBeispiel{

    public static void main(String[] args){

    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

  • Grundlegende Aspekte der OOP8

    }}

    }

    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 hlt 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 Fden zu ein und derselben Mari-onette hielten. Die Einstellungen, die Sie mit dem einen Holzkreuzvorgenommen haben, werden durch das andere wieder gendert.

    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 mchte ich Ihnen eine Besonderheit vorstellen. Die Klasse Stringstellt ebenfalls einen komplexen Datentyp zur Verfgung. Probieren wiraus, ob der gleiche Quelltext sich auf diesen Datentyp bertragen lsst. 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 Grobuchstaben umgewandelt wird. Wenn dieMethode vollstndig ausgefhrt 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 zugehrigeBeispielcode

    public class StringBeispiel{

    public static void main(String[] args){

    182

  • Bestandteile einer Klasse 8.3

    String text = "Hallo, schne 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 derursprngliche 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 unvernderlich, 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 fr das Programm dir. Wieknnen Sie einem Java-Programm Parameter mitgeben? Wenn Sie einProgramm auerhalb von BlueJ laufen lassen mchten, 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

  • Grundlegende Aspekte der OOP8

    public static void main(String[] args){

    for(String temp : args){

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

    }}

    Listing 8.13 Kommandozeilenparameter

    bergabe einesString-Arrays

    Wenn Sie