Einstieg Java mit BlueJ, Klassendiagramme

1. BlueJ als Werkzeug zum Programmieren

Wir verwenden vorerst eine speziell für Lehrzwecke optimierte IDE (Integrated Development Environment - Integrierte Entwicklungsumgebung), die es erlaubt, direkt mit den Klassen und Objekten interaktiv zu arbeiten.

1.1. Wichtige Funktionalitäten von BlueJ

BlueJ bietet u.a.:

  • Als Hauptfenster eine graphische Darstellung der Klassen und deren Beziehungen: Klasendiagramm-(Arbeits-)Bereich und darunter der daraus erzeugten Objekte: Object-Bench (deutsch: Objekt-(Arbeits-)Bereich)

  • für jedes aus einer Klasse erzeugte Objekt ein Fenster zum Ansehen des jeweiligen Objekt-Zustandes (den aktuellen Werten aller Eigenschaften): Inspektor (bei Bedarf durch Doppelklick zu öffnen)

  • ein Werkzeug zur schrittweisen Ausführung des Programm-Codes und paralleler Ansicht aller gerade bestehenden Variablenwerte: Debugger.

Damit erleichtert BlueJ das direkte Arbeiten mit Klassen und Objekten ungemein.

1.2. Installation von BlueJ

BlueJ ist kostenlos verfügbar und wird am besten direkt von der Website https://www.bluej.org heruntergeladen.

Es gibt Versionen für Windows, Linux und Apple OS X.

Die Windows-, Linux- und Apple-Version enthält alles, was zum direkten Nutzen nötig ist (auch das zum Lauf nötige Java SDK …​ Software Development Kit).

Bei Installation des universell verwendbaren JAR-Archivs ist davor separat ein Java Development Kit (JDK) zu installieren. Die Instruktionen erreicht man z.B.
unter https://bluej.org/generic-installation-instructions.html

2. Graphische Notation für Klassen mit UML

UML (Unified Modeling Language) ist eine sehr verbreitete graphische Darstellungsform für viele Aspekte eines Programms oder Programmteils. Wir verwenden hier vorerst nur die Darstellung für Klassen – das Klassendiagramm.

BlueJ verwendet eine mit UML verwandte, vereinfachte Darstellung für Klassen und Objekte.

Wir werden oft in der Aufgabenstellung solche Klassendiagramme verwenden, die dann (unter Beachtung weiterer textueller Infos) in Java-Programme umzusetzen sind. Manchmal ist auch aus einer textuellen Beschreibung ein UML-Klassendiagramm zu erstellen.

Ein Klassendiagramm sieht z.B. folgendermaßen aus:

Personnachname: Stringvorname: StringgeburtsJahr: intweiblich: booleanKonstruktor()Konstruktor(nachname: String, vorname: String) setNachname(nachname: String)setVorname(vorname: String)setGeburtsJahr(geburtsJahr int)setWeiblich(weiblich: boolean) getNachname(): StringgetVorname(): StringgetGeburtsJahr(): intgetWeiblich(): boolean printInfo(zahl: int)

Eine sehr einfache Darstellungsform mit Text-Zeichen ist für uns oft praktischer (kann direkt in BlueJ erstellt werden) - z.B.:

+---------------------------------------------------+
| Person                                            |
+---------------------------------------------------+
| - nachname: String                                |
| - vorname: String                                 |
| - geburtsJahr: int                                |
| - weiblich: boolean    // Kommentar               |
+---------------------------------------------------+
| + Konstruktor()                                   |
| + Konstruktor(nachname: String, vorname: String)  |
| + setNachname(nachname: String)                   |
| + setVorname(vorname: String)                     |
| + setGebJahr(geburtsJahr int)                 |
| + setWeiblich(weiblich: boolean)                  |
|                                                   |
| + getNachname(): String                           |
| + getVorname(): String                            |
| + getGebJahr(): int                           |
| + getWeiblich(): boolean                          |
|                                                   |
| + printInfo()                                     |
+---------------------------------------------------+

Um das Diagramm vollständig verstehen und sebst eines erstellen zu können, ist einiges zu wissen:

  • Im Diagramm gibt es 3 Bereiche:

    • oben der Klassenname

    • danach die Instanzvariablen

    • unten die Methoden

  • Info zur "Sichtbarkeit" bei Instanzvariablen und Methoden:

    • vorgestelltes '-' bzw. rotes Quadrat: "privat" (en: private) - außerhalb der Klasse kann darauf nicht zugegriffen werden

    • vorangestelltes '+' bzw. grüner Kreis "öffentlich" (en: public) - jeder kann darauf zugreifen

  • Java-"Rechtschreibung" ist: Klassen beginnen IMMER mit Großbuchstaben, alles andere mit Kleinbuchstaben (außer Konstante, die lernen wir später - diese werden vollständig groß geschrieben)

  • Die Reihenfolge einer Zeile (Deklaration) in UML ist: Variablenname/Methodensignatur : Typ (die Leerzeichen vor dem ':' werden oft weggelassen)

  • zu beachten: Die Reihenfolge bei Deklarationen in Java ist teils umgekehrt: erst u.U. die Sichtbarkeit (private/public), dann der Typ (z.B. int/boolean/String), dann der Variablen- oder Methodenname

3. Erste Java-Klasse (passend zum obigen UML-Diagramm)

Wir starten nun die Lehr-IDE (Integrated Development Environment) BlueJ und erzeugen ein neues Projekt:

Nach Starten von BlueJ ist entweder ein leeres, unbenanntes Projekt geöffnet oder das zuletzt geschlossene. TODO: Beschreibung …​ …​ …​ …​ …​ …​

Hinweis

Ein für den Beginn guter Ansatz ist das Kopieren der UML-Klasse in die automatisch mit dem Projekt erzeugte Datei README.TXT.. Dazu doppelklicken wir diese, womit sie sich im BlueJ-Editor öffnet. Anschließend erzeugen wir eine neue Klasse mit BlueJ und öffnen sie ebenfalls.

Wir löschen den gesamten "Klassen-Rumpf", sodass nur mehr folgendes übrig bleibt:

public class Person {
    private String vorname;
    private String nachname;        // String ... Text-Inhalt (GROSSER Anfangsbuchstabe!)
    private int gebJahr;            // int ... Ganzahl (ca. -2 bis +2 Milliarden Wertebereich)
    private boolean weiblich;       // boolean ... Wahrheitswert (nur true oder false möglich)

    public Person() {  // Konstruktor ohne Parameter
        setVorname("-- leer --");
        setNachname("-- leer --");

    }

    // Konstruktor mit allen sinnvollen Parametern:
    public Person(String vorname, String nachname, int gebJahr, boolean weiblich) {
        setVorname(vorname);
        setNachname(nachname);
        setGebJahr(gebJahr);
        setWeiblich(weiblich);
    }

    public void setVorname(String vorname) {
        this.vorname = vorname;
    }

    public void setNachname(String nachname) {
        this.nachname = nachname;
    }

    public void setGebJahr(int gebJahr) {
        this.gebJahr = gebJahr;
    }

    public void setWeiblich(boolean weiblich) {
        this.weiblich = weiblich;
    }

    public String getVorname() {
        return this.vorname;
    }

    public String getNachname() {
        return this.nachname;
    }

    public int getGebJahr() {
      return this.gebJahr;
    }
    public char getWeiblich() {
        return this.weiblich;
    }

    public void printInfo() {
        System.out.println("===== Person =====");
        System.out.println("  Vorname:    " + this.vorname);
        System.out.println("  Nachname:   " + this.nachname);
        System.out.println("  GebJahr:    " + this.gebJahr);
        System.out.println("  Weiblich:   " + this.weiblich);
        System.out.println("*~*~*~*~*~*~*~*~*~");   // "Zierleiste"
        System.out.println();   // zusätzliche Zeilenschaltung (ergibt Leerzeile)
    }
}

Nun kopieren wir die UML-Klasse auch in den Editor und transformieren sie Schritt für Schritt von der UML-Notation in Java-Notation.

Dabei sind folgende Dinge zu beachten:

  • Der Klassenname steht schon da - nicht mehr benötigt

  • das einleitende '-' bzw. '+' wird in Java zu private und public

  • in UML steht erst +/-, dann der Eigenschaftsname, dann ':', dann der Typ.
    In Java steht erst public/private, dann der Typ, dann der Eigenschaftsname, dann ';'

  • das gilt auch für Methoden - in der Parameterliste und, wenn vorhanden, beim Rückgabe-Typ - siehe UML: getNachname(): String → Java: String getNachname();

  • Die Trennlinien gibt es in Java nicht - hier wird zwischen den Methoden etc. (lediglich zur optischen Trennung für den Programmierer) eine Leerzeile eingefügt. Hier wird sie für den Compiler unwirksam gemacht, indem sie "auskommentiert" wird

    • mit '//' wir ein Kommentar eingeleitet, der bis zum Zeilenende reicht.

public class Person {
    private String nachname;
    private String vorname;
    private int geburtsJahr;
    private boolean weiblich;
    // +---------------------------------------------------+
    public Person() {
        nachname = "--undefined--";   //  Standardwert, bitte später ändern
        vorname = "--undefined--";
        geburtsJahr = -9999;
        weiblich = true;
    }

    public Person(String neuerNachname, String vorname) {
        nachname = neuerNachname;   //  Standardwert, bitte später ändern
        this.vorname = vorname;
        geburtsJahr = -9999;
        weiblich = true;
    }

    public String getNachname() {
        return nachname;
    }

    public void setNachname(String nachname) {
        this.nachname = nachname;
    }

    public void printObjektInfo() {
    }
}

Einige Hinweise:

  • CamelCase-Schreibweise:

  • Erlaubtes in Namen: In Namen von Klassen, Eigenschaften, Methoden etc.

    • darf kein Leerzeichen verwendet werden

    • erlaubt sind lediglich: Klein- und Großbuchstaben, Unterstrich '_'.

    • Ab 2. Stelle auch Ziffern

    • sinnvollerweise keine Umlaute etc. - nur Buchstaben des englischen Alphabets

  • Texte (Datentyp String) werden in Gänsefüßchen "…​" eingeschlossen

  • Statements: werden mit ';' oder mit einem Block (siehe nachfolgend) abgeschlossen

  • Blöcke (potentiell mehrzeilig) werden in {…​} eingeschlossen

  • Innerhalb jedes Blocks wird die Einrückung um 4 Leerzeichen erhöht

  • Einrückung von Blöcken kann vom BlueJ-Editor automatisch erfolgen (Menü Edit/Auto-Layout), wenn die Klammerungen korrekt geschlossen sind.

  • Beim Anklicken einer der Klammern wird das passende Gegenstück grau markiert.

  • Man sollte daher IMMER die schließende Klammer sofort dazuschreiben und erst dann den Inhalt.