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.
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:
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.
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:
Wir können das zum besseren Verständnis auch in folgender Grafik sehen:
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.
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:
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.
Java Basics
[Java einrichten] [Variablen] [Primitive Datentypen] [Operatoren] [if else] [switch-case] [Arrays] [Schleifen]
Objektorientierung
[Einstieg] [Variablen ] [Konstruktor] [Methoden] [Rekursion] [Statische Member] [Initializer] [Pass-by-value] [Objektsammlungen] [Objektinteraktion] [Objekte löschen]
Klassenbibliothek
[Allgemeines] [String ] [Math] [Wrapper] [Scanner] [java.util.Arrays] [Date-Time-API]
Vererbung
[Einstieg Vererbung] [Konstruktoren bei Vererbung ] [Der protected Zugriffsmodifikator] [Abstrakte Klassen und Methoden] [Polymorphie in Java] [Typumwandlung] [Die Klasse Object] [Die toString()-Methode] [Objekte vergleichen] [Was ist ein Interface?]