Jetzt anmelden...

Login
Passwort
Registrieren

Java Tutorial #17

Objektinteraktion in Java

Wir haben in den letzen Kapitel so einiges über das Klassendesign und die Objekterzeugung in Java gelernt. In diesem Kapitel wollen wir Objekte nicht mehr nur für sich alleine betrachten, sondern uns anschauen, wie unterschiedliche Objekte in einem Programm miteinander interagieren.

Kommentare [0]

Stefan 12.12.2018

Infos zum Artikel

Kategorie Java
Autor Stefan
Datum 12.12.2018

Thema in Kurzform

  • Wir sprechen von Objektinteraktion, wenn Objekte mit anderen Objekten in Beziehung treten.
  • Dies ist z.B. der Fall, wenn Objekte andere Objekte als Instanzvariablen halten, sich untereinander austauschen oder miteinander verglichen werden.

Komplexe Datentypen

Wir wollen dieses Thema anhand eines ganz einfachen Tennisturnier-Programms verdeutlichen. Es gibt darin zwei Klassen. Die erste heißt Tennisspieler und die zweite Tennisturnier. Von der Tennisspieler-Klasse werden wir später mehrere Objekte erstellen, die dann in einem Objekt der KlasseTennisturnier miteinander interagieren.

Zunächst schauen wir uns aber die Implementierung der Klasse Tennissspieler an:

Die Klasse Tennisspieler

package p1;

public class Tennisspieler {

    private String name;
    private int itn; // International Tennis Number -> Spielstärke 10 - 1 (beste)
    private int spiele;
    private int siege;
    private int niederlagen;

    public Tennisspieler(String name, int itn){
        this.name = name;
        this.itn = itn;
    }

  /* getter-Methoden hier
     nicht abgebildet */

    public double getSiegquote() {

       double quote = 0;
       if(spiele != 0) {
           quote = siege / spiele * 100;
       }
        return quote;
    }

    public void erhoeheSpieleUm1(){
        spiele++;
    }

    public void erhoeheSiegeUm1(){
        siege++;
    }

    public void erhoeheNiederlagenUm1() {
        niederlagen++;
    }

    @Override
    public String toString(){
        return "Name: " + getName() +
               ", Itn-Wert: " + getItn() +
               ", Spiele: " + getSpiele() +
               ", Siegquote: " + getSiegquote() + "%";
    }
}

Die Klasse modeliert ganz simpel einen Tennisspieler. Ein paar Instanzvariablen, ein Konstruktor mit zwei Parametern sowie Methoden zum Inkrementieren (um +1 erhöhen) der Instanzvariablen spiele, siege, niederlagen sind vorhanden (die verschiedenen Standard-getter-Methoden wurden aus Platzgründen ausgelassen).

Die Methode getSiegquote() errechnet aus dem Verhältnis von Spielen und Siegen die Erfolgsquote in Prozent und gibt den errechneten Wert zurück.

Die überschriebene toString()-Methode am Ende liefert schließlich eine Beschreibung des Objekts als String zurück.

Die Klasse Tennisturnier

Nun zur zweiten Klasse, Tennisturnier. Hier erstellen wir einige Tennisspieler-Objekte:

package p1;

public class Tennisturnier {

   private Tennisspieler s1;
   private Tennisspieler s2;
   private Tennisspieler s3;

   public Tennisturnier(){
      s1 = new Tennisspieler("Rafael", 4);
      s2 = new Tennisspieler("Andrew", 10);
      s3 = new Tennisspieler("Björn", 7);
    }

   public static void main(String[] args) {
        Tennisturnier t1 = new Tennisturnier();
    }
}

Uns fällt in den Zeilen 5-7 gleich auf, dass die Klasse drei Instanzvariablern vom Typ Tennisspieler besitzt. Bislang hatten die Klassen, mit denen wir gearbeitet haben, vorwiegend Instanzvariablen primitiver Datentypen (char, int, double,...) und Strings.

Die Felder der Klasse Tennisturnier sind dagegen komplexe Datentypen (Referenztypen). "Komplex" werden sie deshalb genannt, da ihre Datenstruktur in einer Klasse (hier: Tennisspieler) beschrieben wird. Als Referenzvariablen können sie dann auf Objekte dieser Klasse verweisen.

Erzeugen wir nun ein Objekt der Klasse Tennisturnier:

Tennisturnier t1 = new Tennisturnier();

Indem wir das tun, werden durch den Konstruktor dieser Klasse auch drei Objekte der Klasse Tennisspieler instanziiert. Denn wir erinenrn uns: Der Code innerhalb eines Konstruktors wird bei der Objekterzeugung automatisch ausgeführt:

s1 = new Tennisspieler("Rafael", 4);
s2 = new Tennisspieler("Andrew", 10);
s3 = new Tennisspieler("Björn", 7);

Damit ist folgender Fall eingetreten:

  • Ein Objekt der Klasse Tennisturnier hält drei Objekte der Klasse Tennisspieler.

Wir können das zum besseren Verständnis auch in folgender Grafik sehen:

Java Objektinteraktion

Ohne ein Objekt der Klasse Tennisturnier (t1), kann es in unserem Programmcode keine Objekte der Klasse Tennisspieler geben (s1, s2, s3), da diese erst durch den Aufruf des Konstruktors von Tennisturnier erzeugt werden. Das ist, wenn man so will, die erste Stufe der Objektinteraktion.

Objekte interagieren

Wir wollen nun die einzelnen Tennisspieler gegeneinander antreten lassen. Mit den Worten der Objektorientierung heißt das, dass wir einzelne Tennisspieler-Objekte miteinander interagieren lassen möchten 😊

Wie in der Tennisspieler-Klasse oben zu sehen ist, hat jeder Tennisspieler eine Spielstärke, die im Tennis mit der itn (international tennis number) gemessen wird und die von 10 bis 1 geht, wobei 10 der schlechteste und 1 der beste Wert darstellt. Wenn wir einzelne Spieler in einem Duell gegeneinander antreten lassen, soll die Höhe des jeweiligen itn-Werts entscheiden, wer als Sieger vom Platz geht.

Um ein Duell zweier Tennisspieler zu ermöglichen, brauchen wir aber noch eine entsprechende Methode. Diese Methode ergänzen wir in der Klasse Tennisturnier:

//weiterer Code der Klasse Tennisturnier
public void duellStarten(Tennisspieler s1, Tennisspieler s2){

        s1.erhoeheSpieleUm1();
        s2.erhoeheSpieleUm1();

        if(s1.getItn() > s2.getItn()){
           s1.erhoeheSiegeUm1();
           s2.erhoeheNiederlagenUm1();
        }
        else if(s1.getItn() < s2.getItn()){
            s2.erhoeheSiegeUm1();
            s1.erhoeheNiederlagenUm1();
        }
        else{
            /* Bei Unentschieden:
            Zufallsgenerator entscheidet */
            }
}
//weiterer Code der Klasse Tennisturnier

Die Methode duellStarten() hat zwei Parameter vom Objekttyp Tennisspieler. Innerhalb der Methode passiert nun Folgendes:

  • Auf den beiden Tennisspieler-Objekten wird die Methode erhoheSpieleUm1() aufgerufen.
  • Als nächstes wird mit einer if-Abfrage geprüft, ob s1 einen höheren itn-Wert hat als s2. Die itn-Werte erhalten wir durch Aufruf der Methode getItn() auf beiden Objekten. Liefert die Prüfung einen wahren Wert, dann hat s1 gewonnen bzw. s2 verloren und es werden durch die beiden Methoden erhoeheSiegeUm1() sowie erhoeheNiederlagenUm1() die Siege von s1 bzw. die Niederlagen von s2 um +1 erhöht.
  • Ist die Aussage der if-Prüfung falsch, findet eine erneute Prüfung durch else if statt. Es wird nun geprüft, ob s1 einen niedrigeren itn-Wert hat als s2. Ist dies der Fall, erhöhen sich die Siege von s2 bzw. die Niederlagen von s1 durch die entsprechenden Methodenaufrufe um jeweils +1. Also genau umgekehrt zum if-Block oben.
  • Der else-Block am Ende der Methode wird ausgeführt, wenn keine der beiden Prüfungen einen wahren Wert lieferten, d.h. beide Objekte den gleichen itn-Wert haben. In diesem Fall könnte der Sieger etwa durch einen Zufallsgenertor ermittelt werden. Da uns das zu weit von unserem Thema wegführt, überlassen wir es Ihnen, diesen auszuprogrammieren.

In unserem Fall besiegt "Andrew" den "Rafael", da s2 (10) einen höheren itn-Wert hat als s1 (4) 😎

Wenn wir die Methode duellStarten() nun im Konstruktor der Klasse Tennisturnier ausführen lassen, sieht der vollständige Code der Klasse so aus:

package p1;

public class Tennisturnier {

   private Tennisspieler s1;
   private Tennisspieler s2;
   private Tennisspieler s3;

   public Tennisturnier(){
      s1 = new Tennisspieler("Rafael", 4);
      s2 = new Tennisspieler("Andrew", 10);
      s3 = new Tennisspieler("Björn", 7);

      duellStarten(s1,s2);

      System.out.println(s1);
      System.out.println(s2);
      System.out.println(s3);
    }

    public void duellStarten(Tennisspieler s1, Tennisspieler s2){

        s1.erhoeheSpieleUm1();
        s2.erhoeheSpieleUm1();

        if(s1.getItn() > s2.getItn()){
            s1.erhoeheSiegeUm1();
            s2.erhoeheNiederlagenUm1();
        }
        else if(s1.getItn() < s2.getItn()){
            s2.erhoeheSiegeUm1();
            s1.erhoeheNiederlagenUm1();
        }
        else{
            /* Bei Unentschieden:
            Zufallsgenerator entscheidet */
        }
    }

    public static void main(String[] args) {
        Tennisturnier t1 = new Tennisturnier();
    }
}

Wir haben außerdem noch 3x System.out.println() im Konstruktor zum Testen hinzugefügt. Wenn wir das Programm starten, erzeugt es folgende Konsolenausagebe:

Name: Rafael, Itn-Wert: 4, Spiele: 1, Siegquote: 0.0%
Name: Andrew, Itn-Wert: 10, Spiele: 1, Siegquote: 100.0%
Name: Björn, Itn-Wert: 7, Spiele: 0, Siegquote: 0.0%

Wir haben also gesehen, wie wir einzelne Objekte kombinieren und miteinander interagieren lassen können. Zusammen haben die unterschiedlichen Objekte eine gemeinsame Aufgabe erfüllt. Dabei wurde ein Modell aus der Wirklichkeit nachgebildet, nämlich ein Tennisturnier (Objekt) mit Tennisspielern (Objekte anderen Typs), die gegeneinander antreten. Aus diesem Grund haben wir die prozeduale Programmierung hinter uns gelassen und schwören auf die Objektorientierung.

Übungen

einfach

Es gibt zwei Klassen: Verein und Mitglied

Die Klasse Verein soll zwei Objekte der Klasse Mitglied halten. Schreiben Sie den Code der Klasse Verein.

Lösung ein-/ausblenden

mittel

Erweitern Sie die Klasse Verein ein wenig. Schreiben Sie eine Methode pruefeMitglied(), die einen Parameter vom Typ Mitglied hat. Die Methode könnte z.B. die Details zu einem Mitglied ausgeben oder ähnliches. Sie müssen die Methode nicht ausprogrammieren.

Lösung ein-/ausblenden

schwer

Erweitern Sie zunächst die Klasse Mitglied, sodass sie zwei Instanzvariablen enthält, nämlich String name und int beitrittsjahr. Die Initialisierung der beiden Variablen soll bei der Objekterzeugung durch Parameterübergabe im Konstruktor erfolgen. Schreiben Sie zu den Feldern die passenden return-Methoden (getName() und getBeitrittsjahr()).

Nun zurück zur Klasse Verein. Wir erzeugen vier neue Mitglied-Objekte gemäß der neuen Klassendefinition von Mitglied. Zusätzlich kommen diese vier auch gleich in eine nette ArrayList namens mitgliederListe.

Und jetzt verdienen Sie sich den Diamanten: Schreiben Sie eine Methode, die uns Details zu allen Mitglieder des Vereins auf der Konsole ausgibt, die seit einem bestimmten Jahr Mitglied sind. Welches Jahr das ist, wird via Parameterübergabe beim Methodenaufruf festgelegt.

Lösung ein-/ausblenden

Kommentar schreiben

Nur angemeldete und aktivierte Benutzer können kommentieren.

Alle Kommentare

Es gibt bislang noch keine Kommentare zu diesem Thema.

Einstieg Objektorientierung

Lernen Sie die Grundlagen der Objektorientierung

Methoden in Java

Wie erstelle ich Methoden?

Schleifen in Java

Schleifenstrukturen gehören zu den wichtigsten Grundlagen in der Programmierung überhaupt.

FALCONBYTE.NET

Handmade with 🖤️

© 2018, 2019 Stefan E. Heller

Impressum | Datenschutz

facebook programmieren lernen twitter programmieren lernen youtube programmieren lernen