• Klassendefinition
• Array von Referenze
• Verschachtelte Klassen
• Referenzen und Methoden
• Selbstreferenz: Rekursive Datentypen
• Bäume haben mindestens zwei Selbstreferenzen
• Videos

Klassendefinition

• Woraus besteht ein Datum?
  • Tag
  • Monat
  • Jahr
  Alle drei Bestandteile sind ganze Zahlen und können je als int definiert werden.
• Woraus besteht ein Mensch?
  • Der Name ist ein String. Wenn man unterscheiden möchte, je einer für Vor- und Nachname.
  • Die Adresse kann ebenfalls in einem String abgelegt werden oder in mehreren für Straße, Ort und PLZ.
  • Das Bankkonto ist wiederum ein String für die IBAN.
  • Das Alter, die Größe oder das Gewicht wäre jeweils eine Zahl.
  • Der Geburtstag ist ein Datum. Man könnte also eine Klasse zum Bestandteil einer anderen machen.
• Woraus besteht ein Auto?
  • Marke, Modell,
  • PS und Baujahr sind Integer
  • Der Verbrauch und der Preis sind Fließkommazahlen.
  • Die Erstzulassung ist wieder ein Datum.

Modellbau

public class Auto {
    String marke = "";
    String modell = "";
    int ps = 0;
    int hubraum = 0;
    int baujahr = 0;
    double preis = 0.0
    double verbrauch = 0.0;
}

Jede Klasse wird in Java in einer eigenen Datei abgelegt, die den Klassennamen trägt, der um die Endung .java erweitert wird. Für die Klasse Auto wird die Datei Auto.java angelegt.

Unter Eclipse werden Klassen über das Menü mit File|New|Class erzeugt. Dazu muss das Projekt angewählt sein, zu dem die Klasse gehören soll.

Der Java-Compiler wandelt jede Klassendatei einzeln in Zwischencode um und hängt dieser Datei die Endung .class an.

Lokale Klassen

Eine solche Vorgehensweise findet man normalerweise nur bei nicht objektorientierten Programmen. Da in diesem Fall die Methoden static definiert sind, muss dann auch die lokale Klasse static definiert sein.

public class Hauptprogramm {
    
    static class Auto {
        String marke = "", modell = "";
        int ps = 0, hubraum = 0, baujahr = 0;
        double preis = 0.0, verbrauch = 0.0;
    }
    
    public static void main(String[] args) {
        Auto r4 = new Auto();
    }
}

Objekte sind Instanzen

Eine Instanz einer Klasse Auto wird mit der folgenden Anweisung erzeugt:

public static void main(String[] args) {
    Auto r4 = new Auto();
    // ...

Die Instanz wird auch Objekt genannt und liegt irgendwo im Speicher. Die Referenz enthält die Speicheradresse, wo das Objekt liegt.

Zugriff auf die Attribute

Auto r4 = new Auto();
r4.marke = "Renault";

r4.ps = 34;

Mehrere Instanzen

Auto r4 = new Auto();
Auto a4 = new Auto();

Jede Referenz hat daraufhin ein eigenes Objekt, weil für jede Referenz ein eigenes new aufgerufen wurde. Im Speicher ergibt sich das folgende Bild:

Kopie einer Referenz

Auto meinR4 = new Auto();
Auto deinR4 = meinR4;  // die Referenzen zeigen auf eine gemeinsame Instanz

Die Konsequenz daraus ist, dass die Änderungen an meinem R4 auch deinen R4 betreffen. Zeigen wir das ganze an einem a4, der ja mehr PS hat.

Auto meinR4 = new Auto();
meinR4.ps = 34;
Auto a4 = meinR4; // die Referenzen zeigen auf eine Instanz
a4.ps = 100;      // Änderung an a4 ist eine Änderung an meinR4

Kopie einer Instanz

Auto meinR4 = new Auto();
meinR4.marke = "Renault";
meinR4.ps = 34;
meinR4.baujahr = 1978;
Auto deinR4 = new Auto();
deinR4.marke   = meinR4.marke;
deinR4.ps      = meinR4.ps;
deinR4.baujahr = meinR4.baujahr;

deinR4.baujahr = 1982;
System.out.println(meinR4.baujahr); // 1978

Array von Referenzen

final int FAHRZEUGE = 4;
Auto[] fuhrpark = new Auto[FAHRZEUGE];

Die Variable fuhrpark ist ein Array von Referenzen auf Auto-Instanzen. Die Auto-Instanzen liegen aber zu diesem Zeitpunkt nicht vor. Es fehlt noch das new für jede der Referenzen in dem Array.

Da die Referenzen ohne Instanz unweigerlich zu einer NullPointerException führen würden, müssen die Referenzen entweder aus dem Programm belegt werden oder man muss neue Instanzen über den Befehl new anlegen. Um die Instanzen zu den im Array abgelegten Referenzen zu erzeugen, muss das Array mit einer Schleife durchlaufen werden.

for (int i=0; i<FAHRZEUGE; i++) {
    fuhrpark[i] = new Auto();
}

fuhrpark[2].ps = 34;

Verschachtelte Klassen

class Datum {
    int tag=0, monat=0, jahr=0;
}

class Auto {
    String marke = "", modell = "";
    int ps = 0, hubraum = 0, baujahr = 0;
    double preis = 0.0, verbrauch = 0.0;
    Datum erstzulassung = new Datum();
}

Der Zugriff erfolgt über die Referenz des Autos auf die Referenz erstzulassung und dann auf die Attribute der Klasse Datum.

Auto a4 = new Auto();
a4.erstzulassung.tag = 12;

Referenzen und Methoden

Referenz als Parameter

Über diese Referenz greift die Methode aber auf das Objekt zu, das der Aufrufer übergeben hat.

static void tuneAuto(Auto a) {
    a.ps += 100;
}

Auto r4 = new Auto();
r4.ps = 34;
tuneAuto(r4);
System.out.println(r4.ps); // 134

Rückgabe einer Referenz

static public Koordinate eingabe() {
        Koordinate koord = new Koordinate();
        // Benutzereingabe
        koord.x = x;
        koord.y = y;
        return koord;        
    }

Selbstreferenz: Rekursive Datentypen

static class Liste {
    String data;
    Liste next = null;
}

Der Anfang der Liste, den man auch als Anker bezeichnet, ist über die Variable anker greifbar. Ist anker==null, gibt es kein Element. Das folgende Programmstück füllt die Liste mit Clownsnamen:

Liste anker = null;
String[] clowns = { "August", "Arnold", "Willemer" };
for (int i=0; i<clowns.length; i++) {
    Liste alt = anker;
    anker = new Liste();
    anker.data = clowns[i];
    anker.next = alt;
}

Um die Liste auszugeben, wird eine Referenz lauf mit dem Anker initialisiert. Solange lauf nicht das Ende der Liste darstellt, wird das Element, auf das lauf zeigt, ausgegeben und durch Zuweisung von next auf das nächste Element der Liste weitergewechselt.

Liste lauf = anker;
while (lauf!=null) {
    System.out.println(lauf.data);
    lauf = lauf.next;
}

Der Vorteil einer verketteten Liste gegenüber einem Array ist die Möglichkeit, die Liste bei Bedarf dynamisch zu verlängern. Auch das Einfügen oder Löschen von Elementen in der Mitte ist bei einer verketteten Liste wesentlich effizienter als bei einem Array.

Dagegen ist der direkte Zugriff auf das Element an der x-ten Position im Array deutlich schneller, weil man sich in einer verketteten Liste von Element zu Element durchhangeln muss.

Bäume haben mindestens zwei Selbstreferenzen

Sie kennen vieleicht das Kinderspiel, in dem sich ein Kind eine Zahl ausdenkt, die das andere Kind raten muss. Als Hilfestellung verrät das erste Kind, ob die gedachte Zahl größer oder kleiner als die geratene Zahl ist. Besonders effizient findet das ratende Kind die Zahl, indem es den Zahlenraum halbiert. So kann es nach 10 Versuchen eine Zahl zwischen 1 und 1000 finden.

Beim Baum legt man die Werte gleich entsprechend ab. Hier die Definition der Klasse:

static class Baum {
        int wert = 0;
        Baum kleiner = null;
        Baum groesser = null;
    }

Auslesen eines Sortierbaums

Stattdessen verwenden Sie eine knackig kurze Rekursion. Sie tut genau das oben beschriebene und das auf wenigen Zeilen.

static void ausgeben(Baum baum) {
    if (baum != null) {
        ausgeben(baum.kleiner);
        System.out.print(" " + baum.wert);
        ausgeben(baum.groesser);
    }
}

Einfügen in Sortierbaum

static void einsortieren(Baum baum, int zahl) {
    if (baum.wert > zahl) {
        if (baum.kleiner != null) {
            einsortieren(baum.kleiner, zahl);
        } else {
            baum.kleiner = new Baum();
            baum.kleiner.wert = zahl;
        }
    } else {
        if (baum.groesser != null) {
            einsortieren(baum.groesser, zahl);
        } else {
            baum.groesser = new Baum();
            baum.groesser.wert = zahl;
        }
    }
}

Videos

Klassen als Datenverbund

Rekursive Datentypen