Falconbyte.net :: Objektinteraktion in Java

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 Klasse Tennisturnier 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 modelliert 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 Instanzvariablen 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 erinnern 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 den schlechtesten und 1 den besten 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 MethodenerhoeheSiegeUm1() 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 Zufallsgenerator 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 Konsolenausgabe:

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 prozedurale Programmierung hinter uns gelassen und schwören auf die Objektorientierung.