8 Klassen

Nachdem Sie schon Objekte des Typs PVector und String verwendet haben, lernen Sie jetzt, wie Sie eigene Klassen schreiben.

In dem obigen Beispiel werden die Bälle durch eine eigene Klasse repräsentiert, d.h. jeder Ball ist ein Objekt (Aufgabe 8.5e). Außerdem werden hier auch die Verbindungen durch Objekte (und eine Klasse Link) repräsentiert.

8.1 Klassen und Objekte

Das interessanteste an Objekten ist ihre Wiederverwendbarkeit. Diese Wiederverwendbarkeit hat dazu geführt, dass eine Sprache wie Java (Processing) erweitert wird, indem eine Reihe von Klassen von vornerein bereit gestellt wird. Sie kennen z.B. die Klasse String, die bei Java von Haus aus zur Verfügung steht. Eine Kollektion von Klassen nennt man auch Bibliothek. Die in Java "eingebaute" Bibliothek nennt man die Java-Standardbibliothek.

Eine Klasse ist ein zunächst Mal abstraktes Konzept wie z.B. der Mensch oder das Haus. Für jede Klasse gibt es konkrete Instanzen, z.B. der konkrete Mensch Barack Obama oder ein konkretes Haus wie Ihre derzeitige Wohnstätte. Eine Instanz nennt man in unserem Kontext auch Objekt.

Eine Klasse definiert bestimmte Eigenschaften, z.B. hat ein Mensch ein Alter und eine Haarfarbe, ein Haus hat eine Adresse. Aber die Eigenschaften einer Klasse haben zunächst keine Werte. Erst die entsprechenden Objekte/Instanzen haben konkrete Werte für diese Eigenschaften. In Processing sind die Eigenschaften als Variablen abgebildet.

Klasse definieren / Instanzvariablen

Um eine Klasse zu definieren, erzeugen Sie in Processing einen neuen Reiter (Tab) mit dem Namen der Klasse, z.B. Ball. Einen neuen Reiter erzeugen Sie mit dem kleinen Dreieck neben dem Hauptreiter:

Anschließend geben Sie den Namen für den neuen Reiter ein, z.B. Ball. Sie sehen den neuen Reiter oben:

Um eine Klasse Ball mit drei Eigenschaften zu definieren, schreiben Sie:

class Ball
{
   int xpos;
   int ypos;
   int d; // Durchmesser
}

Die Eigenschaften nennt man auch Instanzvariablen, da es Variablen sind, die immer jeweils einem Objekt (einer Instanz) gehören.

Eine Klasse kann man sich als abstrakten Bauplan im platonischen Raum der Ideen vorstellen:

Objekte erzeugen (Instanziieren)

Sobald Sie an anderer Stelle im Code eine Instanz einer Klasse benötigen, müssen Sie zunächst Variablen deklarieren, die eine solche Instanz speichern können:

Ball ball;
Ball foo;
Ball einBall;

Die Klasse Ball ist gleichzeitig ein Datentyp (genauso wie int oder String). Man sagt daher: "Variable foo ist vom Typ Ball".

Jetzt können Sie neue Instanzen erzeugen und jeweils in den Variablen ablegen:

ball = new Ball();
foo = new Ball();
einBall = new Ball();

In dem Beispiel werden also drei Ball-Objekte erzeugt. Sie können das natürlich auch jeweils auf einer Zeile ausführen:

Ball ball = new Ball();
Ball foo = new Ball();
Ball einBall = new Ball();

Der Prozess des Instanziierens führt dazu, dass ein neues Objekt (eine Instanz) erschaffen wird. Wir stellen uns das als Häuschen in Object City vor. Jedes Objekt hat konkrete Werte für die Eigenschaften xpos, ypos und d.

Die Variablen ball, foo und einBall enthalten nicht etwa diese Häuschen, sondern nur die Adresse des Häuschens. Man sagt auch, dass die Variable auf das Objekt zeigt.

Deshalb können Sie ein Objekt auch nicht einfach auf der Konsole ausgeben:

Ball ball = new Ball();
println(ball);

sketch_151202a$Ball@404f1faf

Was Sie sehen, ist so etwas wie die Adresse des Häuschens, aber Sie interessieren ja die Eigenschaften. Wenn Sie die sehen wollen, müssen Sie per Punktnotation auf sie zugreifen.

Variablenzugriff per Punktnotation

Um auf die Eigenschaften zuzugreifen, bedienen wir uns der Punktnotation. Hier setzen wir erstmal die Eigenschaften der drei Objekte von oben auf bestimmte Werte:

ball.xpos = 100;
ball.ypos = 100;
ball.d = 40;
foo.xpos = 50;
foo.ypos = 30;
foo.d = 20;
einBall.xpos = 20;
einBall.ypos = 10;
einBall.d = 20;

Processing/Java benötigt die Punktnotation, um dasjenige Objekt (Häuschen) zu finden, bei dem die Änderung vorgenommen werden soll:

Sofern man die Werte eines Objekts das erste Mal setzt, nennt man das auch ein Objekt initialisieren. Die Eigenschaften eines Objekts können sich natürlich während des Programmablaufs ändern, z.B. die Variablen xpos und ypos in dem Beispiel, sofern die Objekte animiert werden sollen. Mit dem Begriff Zustand meint man die aktuelle Belegung aller Eigenschaften (Instanzvariablen) eines Objekts. Der Zustand kann sich also fortwährend ändern.

Beispiel: Klasse Person

Ein weiteres Beispiel ist eine Klasse, die eine Person repräsentiert, z.B. für eine Kunden-, Patienten oder Studierenden-Datenbank.

Wir möchten, dass die Klasse Person definieren. Sie soll die Eigenschaften Vorname, Nachname und Geburtsjahr beinhalten.

Wir erzeugen also einen neuen Reiter/Tab "Person" und schreiben:

class Person {
  String vorname;
  String nachname;
  int geburtsjahr;
}

Um Objekte (Instanzen) zu erzeugen, deklarieren wir im Hauptprogramm in setup() zwei neue Variablen.

void setup() {
  Person p1;
  Person p2;
}

Anschließend erzeugen wir die zwei neuen Objekte mit new und weisen sie den Variablen zu:

void setup() {
  Person p1;
  Person p2;
  p1 = new Person();
  p2 = new Person();
}

Das kann man auch verkürzt schreiben:

void setup() {
  Person p1 = new Person();
  Person p2 = new Person();
}

Jetzt können wir die Eigenschaften der zwei Objekte per Punktnotation befüllen:

void setup() {
  Person p1 = new Person();
  Person p2 = new Person();
  p1.vorname = "Johnny";
  p1.nachname = "Depp";
  p1.geburtsjahr = 1963;
  p2.vorname = "Judi";
  p2.nachname = "Dench";
  p2.geburtsjahr = 1934;
}

Auch wenn Sie die Werte auslesen möchten, müssen Sie Punktnotation anwenden:

void setup() {
  Person p1 = new Person();
  Person p2 = new Person();
  p1.vorname = "Johnny";
  p1.nachname = "Depp";
  p1.geburtsjahr = 1963;
  p2.vorname = "Judi";
  p2.nachname = "Dench";
  p2.geburtsjahr = 1934;

  println(p1.nachname + ", " + p1.vorname);
}

Depp, Johnny

Der Wert null

Wird eine Variable angelegt, ohne dass ein Objekt darin gespeichert wird, befindet sich der Platzhalter null darin. Sie können das explizit angeben:

Ball ball2 = null;
println(ball2);

Sie sehen:

null

Das Symbol null bedeutet, dass die Variable ball2 gerade gar nicht auf ein Objekt zeigt:

Das wiederum heißt, dass Sie nicht per Punktnotation auf Instanzvariablen zugreifen können:

Ball ball2 = null;
ball2.xpos = 15; // Fehler! ball2 zeigt nirgendwo hin

Dies führt zu der Fehlermeldung NullPointerException. Sie müssen also bei Variablen, die Objekte beinhalten, immer aufpassen, dass dort nicht null enthalten ist.

class Person {
  String vorname;
  String nachname;
  int geburtsjahr;
}

void setup() {
  Person p = new Person();
  p.vorname = "Harry";
  p.nachname = "Potter";
  p.geburtsjahr = 2010;
}

class Wohnung {
  String adresse;
  float qm;
  int zimmer;
  boolean zuVermieten;
}

class Foo {
  int goo;
  boolean isDoo;
}

void setup() {
  Foo f1 = new Foo();
  Foo f2;

  f1.goo = 42;
  f2.isDoo = true;
}

void setup() {
  Adressbuch a = new Adressbuch();

  for (int i = 0; i < a.namen.length; i++) {
    println(a.namen[i] + ": " + a.tel[i]);
  }
}

Larry: 111 222
Lisa: 333 444
Harry: 012 345

class Mensch {
    String name;
    int alter;
}

void setup() {
    Mensch a = new Mensch();
    Mensch b = new Mensch();
    a.name = "Harry";
    a.alter = 18;
    println(a.name + " " + a.alter);

    b.name = "Sally";
    ...
}

8.2 Methoden

Methoden definieren

Objekte können auch Aktionen beinhalten. Ein Mensch kann sich z.B. fortbewegen oder etwas sagen. Zu beachten ist, dass sich nur ein konkreter Mensch (Objekt) fortbewegen kann, nicht die ganze Klasse! In Processing kann man Funktionen in Klassen einbetten. Solche Funktionen werden oft Methoden genannt.

class Ball
{
   int xpos;
   int ypos;
   int durchmesser;

   void zeichne() {
      ellipse(xpos, ypos, durchmesser, durchmesser);
   }

   void bewege() {
      xpos++;
   }
}

Methoden werden genauso wie Funktionen definiert, d.h. sie haben einen Namen, mehrere (oder keine) Parameter und einen Rückgabetyp.Sie müssen innerhalb der geschweiften Klammern der Klassendefinition definiert werden. Innhalb der Methoden kann man auf alle Instanzvariablen der Klasse zugreifen (im Beispiel: xpos, ypos, durchmesser).

Hier ein Beispiel einer Methode mit Parametern:

class Ball
{
   ...

   void setPosition(int xp, int yp) {
     xpos = xp;
     ypos = yp;
   }

}

Hier ein Beispiel einer Methode mit Rückgabe:

class Ball
{
   ...

   float distToMouse() {
      return dist(mouseX, mouseY, xpos, ypos);
   }

}

Methoden verwenden

Um eine Methode aufzurufen, bedient man sich ebenfalls der Punktnotation:

Ball ball = new Ball();

ball.xpos = 100;
ball.ypos = 100;
ball.durchmesser = 40;

ball.zeichne(); // Methode zeichne() dieses Objekts aufrufen

Beispiel: Klasse Person

Wir definieren uns für die Klasse Person zunächst mal eine Methode, die den Namen "zusammensetzt" und dann als String zurückgibt:

class Person {
  String vorname;
  String nachname;
  int geburtsjahr;

  String ganzerName() {
    return vorname + " " + nachname;
  }
}

Jetzt können wir die Personen etwas komfortabler benennen:

void setup() {
  Person p1 = new Person();
  Person p2 = new Person();
  p1.vorname = "Johnny";
  p1.nachname = "Depp";
  p1.geburtsjahr = 1963;
  p2.vorname = "Judi";
  p2.nachname = "Dench";
  p2.geburtsjahr = 1934;

  println(p1.ganzerName());
  println(p2.ganzerName());
}

Johnny Depp
Judi Dench

Wir fügen noch zwei weitere Methoden hinzu. Die Methode spreche gibt einen Text aus, schreibt aber zuvor, wer den Text sagt (und benutzt dazu unsere Methode ganzerName()). Die Methode berechneAlter berechnet das aktuelle Alter aufgrund des aktuellen Jahres.

class Person {
  String vorname;
  String nachname;
  int geburtsjahr;

  String ganzerName() {
    return vorname + " " + nachname;
  }

  int berechneAlter(int aktuellesJahr) {
    return aktuellesJahr - geburtsjahr;
  }

  void spreche(String nachricht) {
    println(ganzerName() + " sagt: " + nachricht);
  }
}

Wir verwenden unsere neuen Methoden für einen kleinen Dialog:

void setup() {
  Person p1 = new Person();
  Person p2 = new Person();
  p1.vorname = "Johnny";
  p1.nachname = "Depp";
  p1.geburtsjahr = 1963;
  p2.vorname = "Judi";
  p2.nachname = "Dench";
  p2.geburtsjahr = 1934;

  p1.spreche("Wie geht's dir?");
  p2.spreche("Gut.");
  p1.spreche("Wie alt bist du?");
  p2.spreche("Ich bin " + p2.berechneAlter(2018) + " Jahre alt.");
}

Johnny Depp sagt: Wie geht's dir?
Judi Dench sagt: Gut.
Johnny Depp sagt: Wie alt bist du?
Judi Dench sagt: Ich bin 84 Jahre alt.

Beispiel: Klasse Tabelle

Jetzt sehen wir uns ein weiteres Beispiel an, wo wir eine neue Speichermöglichkeit anlegen. Das nennt man auch eine Datenstruktur. Konkret möchten wir eine Tabelle erzeugen. In einer Tabelle hat man zwei Spalten, eine für die Schlüssel (engl. keys) und eine für die Werte (engl. values).

Der Zweck der Tabelle ist, dass man über den Schlüssel eine bestimmte Information nachschlagen kann. Das klassische Beispiel ist ein Telefonbuch, wo man über den Namen der Person auf die entsprechende Telefonnummer zugreift.

Für unsere Implementierung nehmen wir an, dass Schlüssel und Werte jeweils vom Typ String sind, weil wir damit am flexibelsten sind.

Wir schreiben eine neue Klasse Table. Um die Schlüssel und die Werte zu speichern, verwenden wir String-Arrays. Wir gehen mal von einer maximalen Größe von 100 aus und nutzen eine Variable size, um die Anzahl der benutzten Array-Elemente zu speichern, ähnlich wie bei den flexiblen Arrays.

Hier eine schematische Darstellung der Arrays (mit beispielhaften Werten):

Und jetzt die Klasse:

class Table {
  String[] keys = new String[100];
  String[] values = new String[100];
  int size = 0;

  // Methoden stehen hier
}

Damit man neue Einträge vornehmen kann, schreiben wir die Methode put. Hier werden Schlüssel und Wert übergeben und in die entsprechenden Arrays geschrieben.

void put(String key, String value) {
  keys[size] = key;
  values[size] = value;
  size++;
}

Damit man einen Wert mit Hilfe des Schlüssels auslesen kann, schreiben wir die Methode get. Dort übergibt man den Schlüssel und erhält den entsprechenden Wert als Rückgabe oder auch null, wenn der Schlüssel nicht in der Tabelle vorkommt.

String get(String key) {
  for (int i = 0; i < size; i++) {
    if (keys[i].equals(key)) {
      return values[i];
    }
  }
  return null; // Eintrag nicht vorhanden
}

Hier zeigen wir nochmal die vollständige Klasse, inklusive der Methoden size und printAll, die sicher nützlich sind.

class Table {
  String[] keys = new String[100];
  String[] values = new String[100];
  int size = 0;

  // Größe der Tabelle (befüllter Teil)
  int size() {
    return size;
  }

  // Neues Schlüssel-Wert-Paar eintragen
  void put(String key, String value) {
    keys[size] = key;
    values[size] = value;
    size++;
  }

  // Wert finden
  String get(String key) {
    for (int i = 0; i < size; i++) {
      if (keys[i].equals(key)) {
        return values[i];
      }
    }
    return null; // Eintrag nicht vorhanden
  }

  // Alle Tabelleneinträge ausgeben
  void printAll() {
    for (int i = 0; i < size; i++) {
      println(keys[i] + ": " + values[i]);
    }
  }
}

Und noch ein Beispielprogramm zum Testen:

void setup() {
  Table tab = new Table();

  tab.put("Angela", "111 222");
  tab.put("Joe", "333 444");
  tab.put("Emmanuel", "888 111");

  tab.printAll();

  println();
  println("SUCHE");
  println("Merkel: " + tab.get("Angela"));
  println("Kohl: " + tab.get("Helmut"));
}

Angela: 111 222
Joe: 333 444
Emmanuel: 888 111

SUCHE
Merkel: 111 222
Kohl: null

Was fehlt? Man könnte noch einbauen, dass man Einträge mit einer Methode remove, der man einen Schlüssel übergibt, löschen kann. Vielleicht probieren Sie das mal.

Hallo, mein Name ist Harry Potter.

class Person {
  String vorname;
  String nachname;
  int geburtsjahr;

  void hallo() {
    println("Hallo, mein Name ist " + vorname + " " + nachname);
  }
}

void setup() {
  Person p = new Person();
  p.vorname = "Harry";
  p.nachname = "Potter";
  p.geburtsjahr = 2010;
  p.hallo();
}

Wohnung zu vermieten: 4 Zimmer, 80.0 qm, Musterstraße 42.

Wohnung (Musterstraße 42) ist vermietet.

class Wohnung {
  String adresse;
  float qm;
  int zimmer;
  boolean zuVermieten;

  void printAnzeige() {
    if (zuVermieten) {
      println("Wohnung zu vermieten: " + zimmer + " Zimmer, "
      + qm + " qm, " + adresse + ".");
    } else {
      println("Wohnung (" + adresse +") ist vermietet.");
    }
  }
}

class Losmaschine {
  String[] lose = { "Niete", "Niete", "1 Punkt", "Niete", "1 Punkt", "10 Punkte" };
}

void setup() {
  Losmaschine lm = new Losmaschine();
  println(lm.losZiehen());
}

Hallo, ich bin Harry (123).
Hallo, ich bin Sally (456).

String tel1 = a.findeTel("Lisa");
String tel2 = a.findeTel("Horst");
println("suche Lisa: " + tel1);
println("suche Horst: " + tel2);

suche Lisa: 333 444
suche Horst: unbekannt

void setup() {
  Zahlenliste liste = new Zahlenliste();
  liste.addZahl(10);
  liste.addZahl(20);
  liste.addZahl(30);
  println("Liste der Länge " + liste.size());
  liste.show();

  // Liste verlängern und nochmal ausgeben
  liste.addZahl(-5);
  liste.addZahl(1002);
  println("Liste der Länge " + liste.size());
  liste.show();
}

Liste der Länge 3
[0] 10
[1] 20
[2] 30
Liste der Länge 5
[0] 10
[1] 20
[2] 30
[3] -5
[4] 1002

void setup() {
  Zahlenliste liste = new Zahlenliste();
  liste.addZahl(10);
  liste.addZahl(20);
  liste.addZahl(30);
  liste.addZahl(22);
  liste.addZahl(-5);
  liste.addZahl(1002);
  liste.show();
}

adding 10
capacity: 5, size: 1, free: 4
adding 20
capacity: 5, size: 2, free: 3
adding 30
capacity: 5, size: 3, free: 2
adding 22
capacity: 5, size: 4, free: 1
adding -5
capacity: 5, size: 5, free: 0
adding 1002
extending capacity to 10
capacity: 10, size: 6, free: 4
[0] 10
[1] 20
[2] 30
[3] 22
[4] -5
[5] 1002  

class Ball
{
   int xpos;
   int ypos;
   int durchmesser;

   void zeichne() {
      ellipse(xpos, ypos, durchmesser, durchmesser);
   }
}

Ball ball = new Ball();
ball.zeichne();

8.3 Konstruktoren

Sobald man new Ball() aufruft, wird eine spezielle Methode der Klasse aufgerufen: der Konstruktor. Ein Konstruktor ist wie eine Methode und wird genau dann aufgerufen, wenn das Objekt erzeugt wird. Er wird häufig verwendet, um die Eigenschaften zu setzen (Initialisierung).

Der sogenannte leere Konstruktor wird automatisch erzeugt, wenn Sie keine eigenen Konstruktoren erzeugen. Er enthält aber keine besondere Funktionalität.

Einfacher Konstruktor

Sie können selbst einen Konstruktor schreiben, um z.B. Ihre Eigenschaften auf einen Anfangszustand zu setzen:

class Ball
{
  int xpos;
  int ypos;
  int durchmesser;

   // Ihr eigener Konstruktor
   Ball()
   {
      xpos = 50;
      ypos = 50;
      durchmesser = 20;
   }

   // hier kommen die weiteren Methoden
}

Ein Konstruktor sieht aus wie eine Methode, heißt aber immer genauso wie die Klasse, wird also (anders als Methoden) groß geschrieben.

Sie können im Konstruktor beliebigen Code unterbringen. Zum Beispiel können Sie eine kurze Ausgabe einbauen, die signalisiert, dass der Konstruktor aufgerufen wurde.

class Ball
{
  int xpos;
  int ypos;
  int durchmesser;

   // Ihr eigener Konstruktor
   Ball()
   {
      xpos = 50;
      ypos = 50;
      durchmesser = 20;
      println("Neuen Ball erzeugt.");
   }

   // hier kommen die weitere Methoden
}

Wenn Sie jetzt zwei Ball-Objekte erzeugen:

void setup() {
  Ball b1 = new Ball();
  Ball b2 = new Ball();
}

Sehen Sie:

Neuen Ball erzeugt.
Neuen Ball erzeugt.

Konstruktor mit Parametern

Sie können dem Konstruktor auch Parameter mitgeben, wenn Sie z.B. den Durchmesser übergeben wollen:

class Ball
{
  int xpos;
  int ypos;
  int durchmesser;

   // Ihr eigener Konstruktor
   Ball(int x, int y, int d)
   {
      xpos = x;
      ypos = y;
      durchmesser = d;
   }
}

Dieser Konstruktor wird bei der Instanziierung wie folgt aufgerufen:

void setup() {
  Ball ball = new Ball(70, 60, 30);
}

Sobald Sie einen eigenen Konstruktor definieren, wird der leere Konstruktor nicht mehr automatisch erzeugt.

Das hat zur Folge, dass dieser Code jetzt fehlerhaft ist:

void setup() {
  Ball ball = new Ball(70, 60, 30);
  Ball ball2 = new Ball(); // FEHLER: Konstruktor fehlt!
}

Sie können auch mehrere Konstruktoren gleichzeitig definieren. Jeder dieser Konstruktoren ist dann bei der Instanziierung verwendbar:

class Ball
{
  int xpos;
  int ypos;
  int durchmesser;

   // Konstruktor 1 für Faule
   Ball()
   {
      xpos = 50;
      ypos = 50;
      durchmesser = 20;
      println("Konstruktor 1 aufgerufen.");
   }

   // Konstruktor 2 für Raffinierte
   Ball(int x, int y, int d)
   {
      xpos = x;
      ypos = y;
      durchmesser = d;
      println("Konstruktor 2 aufgerufen mit " + x + ", " + y + ", " + d);
   }
}

Dann könnten Sie folgendermaßen Instanziieren:

void setup() {
  Ball ball = new Ball(70, 60, 30); // Konstruktor 2
  Ball foo = new Ball(); // Konstruktor 1
  Ball einBall = new Ball(); // Konstruktor 1
}

Unsere Konsole zeigt:

Konstruktor 2 aufgerufen mit 70, 60, 30
Konstruktor 1 aufgerufen.
Konstruktor 1 aufgerufen.

Beispiel: Klasse Person

Auch für unsere Klasse Person lässt sich ein sinnvoller Konstruktor definieren.

class Person {
  String vorname;
  String nachname;
  int geburtsjahr;

  Person(String vn, String nn, int gj) {
    vorname = vn;
    nachname = nn;
    geburtsjahr = gj;
  }
}

Jetzt können wir unsere Objekte mit wesentlich weniger Code erzeugen:

void setup() {
  Person p1 = new Person("Jonny", "Depp", 1963);
  Person p2 = new Person("Judi", "Dench", 1934);
}

class Tropfen {
  float x;
  float y;
}

class Tropfen {
  float x;
  float y;

  Tropfen (float px, float py) {
    x = px;
    y = py;
  }
}

Tropfen foo = new Tropfen();

void setup() {
  Kunde k1 = new Kunde("Haribert", "Schmidt", 501);
  Kunde k2 = new Kunde("Prof. Dr. Dr.", "Lara", "Schulte", 339);

  println(k1.name);
  println(k2.name);
}

void setup() {
  Kunde k1 = new Kunde("Haribert Schmidt", 501);
  Kunde k2 = new Kunde("Lara Schulte", 339);

  println(k1.vorname);
  println(k1.nachname);
  println(k2.vorname);
  println(k2.nachname);
}

8.4 Interaktion zwischen Objekten

Abhängigkeiten

Objekte können Abhängigkeiten untereinander aufweisen. Zum Beispiel möchte ein Autohaus eine Kunden-Datenbank anlegen von verkauften Autos und ihren jeweiligen Besitzern. Dazu benötigt man Klassen für Autos und Personen. Zum Beispiel hier die Klasse Kunde:

class Kunde {
  String name;
  String adresse;

  Kunde(String n, String a) {
    name = n;
    adresse = a;
  }
}

Die Klasse Auto soll neben Marke und Farbe auch den Besitzer enthalten. Jetzt könnten wir den Namen als String verwenden, aber das wäre umständlich, wenn ich vom Auto ausgehend alle Daten des Benutzers finden möchte. Stattdessen speichere ich einfach das dazugehörige Kundenobjekt.

class Auto {
  String marke;
  String farbe;
  Kunde besitzer;

  Auto(String m, String f, Kunde k) {
    marke = m;
    farbe = f;
    besitzer = k;
  }
}

Der Vorteil, hier das Kundenobjekt zu speichern und nicht nur den Namen als String ist folgender: ich kann jetzt auf alle Informationen des Objekts zugreifen - hier z.B. die Adresse - ohne dass ich das entsprechende Objekt vorher suchen muss.

Ich kann jetzt eine Beschreibung hinzufügen, in der ich auch die Adresse des Kunden verwende:

class Auto {

  ...

  void beschreibe() {
    println(besitzer.name + " aus " + besitzer.adresse +
    " hat einen " + marke + " in " + farbe);
  }
}

Eine Beispielanwendung:

void setup() {
  // Kunden erstellen
  Kunde barack = new Kunde("Barack Obama", "Amerika");
  Kunde angie = new Kunde("Angela Merkel", "Deutschland");

  // Autos erstellen
  Auto bmw = new Auto("BMW", "rot", angie);
  Auto porsche = new Auto("Porsche", "schwarz", barack);
  Auto rover = new Auto("Land Rover", "schwarz", barack);

  // Autos ausgeben
  bmw.beschreibe();
  porsche.beschreibe();
  rover.beschreibe();
}

Angela Merkel aus Deutschland hat einen BMW in rot
Barack Obama aus Amerika hat einen Porsche in schwarz
Barack Obama aus Amerika hat einen Land Rover in schwarz

Im Grunde haben Sie hier nichts neues gelernt. Sie wussten bereits, dass Variablen Objekte "enthalten" können (besser gesagt: sie zeigen auf sie). Jetzt haben Sie gesehen, dass auch Instanzvariablen auf Objekte zeigen können.

Im Diagramm könnte man die Situation wie folgt darstellen:

Es ist immer wichtig, sich klar zu machen, dass die Variablen lediglich Zeiger auf Objekte sind. Wenn Sie z.B. aus einem Auto-Objekt heraus ein Kundenobjekt manipulieren, dann gilt diese Änderung natürlich "überall", also auch, wenn Sie später den Kunden über die Variable angie zugreifen.

Punktnotation

Die Punktnotation kann mehrfach hintereinander eingesetzt werden und sollte dies auch, weil sich dadurch sehr lesbarer Code ergibt:

void setup() {

  Kunde barack = new Kunde("Barack Obama", "Amerika");
  Kunde angie = new Kunde("Angela Merkel", "Deutschland");

  Auto bmw = new Auto("BMW", "rot", angie);
  Auto porsche = new Auto("Porsche", "schwarz", barack);
  Auto rover = new Auto("Land Rover", "schwarz", barack);

  println("Kunde des BMW: " + bmw.besitzer.name);
}

Kunde des BMW: Angela Merkel

Dies nennt man auch eine Verkettung von Punktnotation.

Grafisches Beispiel

Wir schauen uns ein weiteres Beispiel aus der Computergrafik an, wo Objekte miteinander verknüpft sind.

Zunächst definieren wir eine Klasse Ball, die einen Ball so animiert, dass er von den Wänden abprallt:

class Ball {
  PVector pos;
  PVector speed;

  Ball() {
    pos = new PVector(random(5, width-5), random(5, height-5));
    speed = new PVector(random(-2, 2), random(-2,2));
  }

  void render() {
    noStroke();
    ellipse(pos.x, pos.y, 10, 10);
  }

  void update() {
    pos.add(speed);
    if (pos.x < 5 || pos.x > width-5) {
      speed.x = -speed.x;
    }
    if (pos.y < 5 || pos.y > height-5) {
      speed.y = -speed.y;
    }
  }
}

Wir animieren im Hauptprogramm drei Ball-Objekte:

Ball b1 = new Ball();
Ball b2 = new Ball();
Ball b3 = new Ball();

void draw() {
  background(0);

  b1.render();
  b2.render();
  b3.render();

  b1.update();
  b2.update();
  b3.update();
}

Jetzt möchten wir Verbindungen zwischen je zwei Bällen hinzufügen. Jede Verbindung kann man sich als Objekt vorstellen, wo jeweils die zwei "Enden" gespeichert sind. Wir nennen die dazu notwendige Klasse Link.

class Link {
  Ball ball1;
  Ball ball2;

  Link(Ball b1, Ball b2) {
    ball1 = b1;
    ball2 = b2;
  }

  void render() {
    stroke(255);
    line(ball1.pos.x, ball1.pos.y, ball2.pos.x, ball2.pos.y);
  }
}

In der Methode render() sehen Sie wieder ein Beispiel für verkettete Punktnotation.

In unserem Hauptprogramm bauen wir zwei Links ein:

Ball b1 = new Ball();
Ball b2 = new Ball();
Ball b3 = new Ball();
Link link1 = new Link(b1, b2);
Link link2 = new Link(b2, b3);

void draw() {
  background(0);

  link1.render();
  link2.render();

  b1.render();
  b2.render();
  b3.render();

  b1.update();
  b2.update();
  b3.update();
}

Ein Objekt kann also auch eine Beziehung zwischen zwei oder mehr Objekten sein. Dass Objekte aufeinander verweisen (= zeigen), ist in der objektorientierten Programmierung ganz normal.

void setup() {
  Kunde barack = new Kunde("Barack Obama", "Amerika");
  Kunde angie = new Kunde("Angela Merkel", "Deutschland");

  Auto bmw = new Auto("BMW", "rot", angie);
  Auto porsche = new Auto("Porsche", "schwarz", barack);
  Auto rover = new Auto("Land Rover", "schwarz", barack);
}

println(gleicherBesitzer(bmw, porsche));
println(gleicherBesitzer(rover, porsche));

false
true

class Member {
  String name;

  Member(String n) {
    name = n;
  }
}

void setup() {
  Member a = new Member("Hans");
  Member b = new Member("Anna");
  Member c = new Member("Franz");
  Member d = new Member("Julia");

  println(a.name + " ist Mitglied.");
  println(b.name + " ist Mitglied.");
  println(c.name + " ist Mitglied.");
  println(d.name + " ist Mitglied.");
}

Freund von Hans ist Anna
Freund von Anna ist Hans
Freund von Franz ist Julia
Freund von Julia ist Franz

8.5 Array von Objekten

Wenn wir viele Objekte erzeugen und verwenden wollen, ziehen wir Arrays hinzu. Wie funktioniert ein Array von Objekten?

Array-Variable deklarieren

Ganz einfach: Da eine Klasse wie "Ball" genauso ein Datentyp ist wie "int" und "float", kann man auch einen Array dieses Typs definieren:

Ball[] balls;

Array erzeugen

Doch Vorsicht, der Array existiert noch nicht. Wir müssen ihn erst erzeugen, z.B. für fünf Objekte:

balls = new Ball[5];

Array mit Objekten befüllen

Jetzt haben wir ein Array mit fünf leeren Eimern, die jeweils ein Objekt vom Typ "Ball" aufnehmen können. Zu Beginn enthalten die Eimer lediglich den Wert null:

balls = new Ball[5];
println(balls[2]);

null

Wir müssen also zunächst die leeren Eimer befüllen, entweder einzeln...

balls[0] = new Ball();
balls[1] = new Ball();
balls[2] = new Ball();
balls[3] = new Ball();
balls[4] = new Ball(); // letzter Eimer!

... oder (besser) mit einer Schleife:

for (int i = 0; i < balls.length; i++) {
   balls[i] = new Ball();
}

Schauen wir uns mal eine bestimmte Klasse an, die auch ein bisschen was kann:

// Klasse Ball (in eigenem Reiter "Ball")
class Ball
{
  float xpos;
  float ypos;
  float xspeed;
  float yspeed;

  // Konstruktor
  // erzeugt Ball an zufälliger Position
  // mit zufälliger Geschwindigkeit
  Ball() 
  {
    xpos = random(10, width-10);
    ypos = random(10, height-10);
    xspeed = random(0,3);
    yspeed = random(0,3);
  }

  // Methode zum Zeichnen
  void render() {
    noStroke();
    ellipse(xpos, ypos, 20, 20);
  }

  // Methode zum Bewegen, inkl. Kollision
  void move() {
    xpos += xspeed;
    ypos += yspeed;

    if (xpos < 10 || xpos > width-10) {
      xspeed = -xspeed;
    }
    if (ypos < 10 || ypos > height-10) {
      yspeed = -yspeed;
    }
  }
}

Objekt-Methoden aufrufen

Diese Klasse können wir wie oben gezeigt in ein Array tun. Damit die Bälle auch gezeichnet und bewegt werden, müssen wir alle Bälle regelmäßig in der draw()-Methode des Hauptprogramms "aufgerufen" werden. Das komplette Hauptprogramm sähe wie folgt aus:

// Hauptprogramm
Ball[] balls = new Ball[5]; // neues Array

void setup() {
  // Array befüllen mit Objekten
  for (int i = 0; i < balls.length; i++) {
    balls[i] = new Ball();
  }
}

void draw() {
  background(100);

  // Funktionen der Objekte regelmäßig aufrufen
  for (int i = 0; i < balls.length; i++) {
    balls[i].render();
    balls[i].move();
  }
}

Arrays und Objekte sind eine mächtige Kombination, weil Sie so Ihre Computerwelt sehr leicht mit vielen komplexen Objekten bevölkern können, egal ob es sich um Spielfiguren, Dokumente oder Personeneinträge eines Sozialen Netzes handelt.

Beispiel: Personen

Sie können Objekte z.B. verwenden, um eine Personendatenbank anzulegen und zu durchsuchen. Zunächst definieren wir eine Klasse Person:

class Person {
  String name;
  int alter;
  float groesse;

  Person(String n, int a, float g) {
    name = n;
    alter = a;
    groesse = g;
  }
}

Jetzt legen Sie einen Array von Beispielpersonen an:

void setup() {
  Person[] personal = new Person[4];
  personal[0] = new Person("Harry", 36, 1.80);
  personal[1] = new Person("Sally", 26, 1.71);
  personal[2] = new Person("Angie", 56, 1.60);
  personal[3] = new Person("Jerry", 15, 1.75);
}

Schauen Sie sich jetzt die passenden Übungen dazu an.

void setup() {
  Person[] personal = new Person[4];
  personal[0] = new Person("Harry", 36, 1.80);
  personal[1] = new Person("Sally", 26, 1.71);
  personal[2] = new Person("Angie", 56, 1.60);
  personal[3] = new Person("Jerry", 15, 1.75);

  // Ihr Code hier...
}

void setup() {
  Person[] personal = new Person[4];
  personal[0] = new Person("Harry", 36, 1.80);
  personal[1] = new Person("Sally", 26, 1.71);
  personal[2] = new Person("Angie", 56, 1.60);
  personal[3] = new Person("Jerry", 15, 1.75);

  // Hier Funktion testen
  printByAge(personal, 30);
}

// Hier Funktion schreiben

void setup() {
  Person[] personal = new Person[4];
  personal[0] = new Person("Harry", 36, 1.80);
  personal[1] = new Person("Sally", 26, 1.71);
  personal[2] = new Person("Angie", 56, 1.60);
  personal[3] = new Person("Jerry", 15, 1.75);

  // Hier Funktion testen
  Person[] result = getByAge(personal, 30);
  // jetzt For-Schleife zum Ausgeben der Namen
}

// Hier Funktion schreiben

8.6 Objekte und Zeiger

Variablen, die ein Objekt enthalten, enthalten in Wirklichkeit nur die Adresse des Objekts. Dies hat wichtige Konsequenzen, wie wir gleich sehen werden. Schauen wir uns zwei Variablen mit Objekten an:

Ball b1 = new Ball(10, 20);
Ball b2 = new Ball(9, 99);

Wobei die Klasse Ball wie folgt aussieht:

class Ball {
   int xpos;
   int ypos;

   Ball(int x, int y) {
      xpos = x;
      ypos = y;
   }
}

Eine Variable, die ein Objekt aufnehmen kann, enthält nicht wirklich das Objekt selbst, sondern nur seine Adresse im Speicher. Man sagt auch, die Variable speichert eine Referenz oder einen Zeiger (engl. pointer) auf das Objekt. Man nennt eine Klasse deshalb auch einen Referenztyp. Man kann sich das so vorstellen:

Wenn Sie eine Zuweisung zwischen Objektvariablen ausführen, wird lediglich die Adresse eingefüllt. Im folgenden Fall zeigen beide Variablen anschließend auf das identische Objekt:

b2 = b1; // Adresse vom b1 wird in b2 gespeichert

Dann haben wir folgende Situation:

Weil b1 und b2 auf das selbe Objekt zeigen, kann man sowohl mit b1 als auch mit b2 dieses eine Objekt manipulieren. Wenn Sie schreiben...

b1.xpos = 5;
b2.ypos = 55;
println(b1.xpos);
println(b1.ypos);

...wird bei beiden Zuweisungen das selbe Objekt manipuliert:

Ihre Ausgabe sieht entsprechend aus:

5
55

Denn es gibt nur ein einziges Objekt. Beide Variablen, b1 und b2, zeigen auf dies eine Objekt. Egal, mit welcher Variable Sie dies Objekt manipulieren, so wird immer nur dies eine Objekt manipuliert und der zuletzt gesetzte Wert für eine Instanzvariable gilt.

Sie können beliebig viele weitere Variablen auf dies Objekt zeigen lassen:

Ball b3 = b1;
Ball b4 = b2;
Ball b5 = b1;
Ball b6 = b2;

Dabei ist es egal, welche andere Variable Sie als "Zulieferer" für die Adresse verwenden. Es steht überall das gleiche drin.

Primitive Variablen

Die Beschäftigung mit Objekten kann dazu führen, dass Sie Ihre Intuition bei primitiven Datentypen (int, float, boolean...) verlieren und hier Fehler machen.

Schauen Sie sich konkret folgenden Code an.

int a = 1;
int b = 0;

Sie haben zwei Variablen mit unterschiedlichen Werten. Was passiert jetzt:

b = a;

Variable b wird auf den Wert von a gesetzt. Wenn Sie b nochmals ändern...

b = 99;

...stellt sich die Frage, ob sich a auch ändert. Das ist nicht der Fall - es gibt keine unsichtbare Verbindung zwischen a und b!

Es werden in jedem Schritt Werte gesetzt. Es wird nicht mit Referenzen/Zeigern gearbeitet, es gibt keine "Häuschen". Man kann auch sagen: Primitive Variablen haben keine Identität (= Häuschen), sondern enthalten lediglich "primitive" Werte.

Objekte als Parameter

Wichtig ist das bei Funktionsaufrufen. Sehen wir uns zunächst eine Funktion mit einem Parameter an, der einen primitiven Datentyp (int) angehört:

void setup() {
   int x = 5;
   foo(x);
   println(x);
}

void foo(int p) {
   p = 10;
}

5

Ihre Variable x wird durch den Funktionsaufruf nicht geändert, denn Processing kopiert den Wert 5 in die Parametervariable p. Dies hat dann nichts mehr mit x zu tun.

Die Situation ändert sich, wenn Sie das gleiche mit einem Objekt der Klasse Ball tun:

void setup() {
   Ball b = new Ball(1, 2);
   boo(b);
   println(b.xpos);
}

void boo(Ball ball) {
   ball.xpos = 9;
}

Der Parameter ball ist nur eine weitere (lokale) Variable, die nach Funktionsaufruf auf die Adresse des einzigen bislang erzeugten Objekts zeigt:

Das heißt, alles, was Sie mit dem Objekt anstellen, bleibt natürlich auch nach Funktionsaufruf bestehen:

Also bekommen Sie als Ausgabe von b.xpos:

9

Merken müssen Sie sich also, dass bei Übergabe von Objekten an Funktionen diese Objekte geändert werden. Sie sollten daher mit Funktionsparametern sehr vorsichtig umgehen und diese nur dann ändern, wenn es notwendig ist.

Objekt als Rückgabewert (Rolle von null)

Es kommt natürlich auch vor, dass eine Funktion ein Objekt zurückgibt. Zum Beispiel, wenn Sie eine Datenbank durchsuchen. Hier soll das erste Auto zurückgegeben werden, das eine bestimmte Mindest-PS-Zahl hat:

Auto findAuto(Auto[] autos, int minPS) {
    for (int i = 0; i < autos.length; i++) {
        if (autos[i].ps > minPS) {
            return autos[i];
        }
    }
    // Problem! Kein return weit und breit...
}

Processing beschwert sich hier. Denn was passiert, wenn ein solches Auto nicht gefunden wird? Processing kommt am Ende der For-Schleife an und findet dort kein return vor. Aber welche Art von Objekt soll denn dann zurückgegeben werden? Was Programmierer in dieser Situation häufig tun, ist, den Wert null zurückzugeben:

Auto findAuto(Auto[] autos, int minPS) {
    for (int i = 0; i < autos.length; i++) {
        if (autos[i].ps > minPS) {
            return autos[i];
        }
    }
    return null
}

Wer auch immer die Funktion verwendet muss also wissen, dass null bedeutet: es wurde nichts gefunden!

Diese Praxis hat einen unangenehmen Nebeneffekt. Wenn Sie eine Funktion verwenden, die potentiell null zurückgibt, müssen Sie aufpassen, wie Sie das zurückgegebene Objekt weiter behandeln:

Auto found = findAuto(meineAutos, 300);
found.printSteckbrief(); // Vorsicht! Könnte null sein.

Es könnte sein, dass in der Variablen found der Wert null steckt. Sie müssen also, bevor Sie die Methode printSteckbrief() aufrufen, sicherstellen, dass found nicht null enthält:

Auto found = findAuto(meineAutos, 300);
if (found != null) {
    found.printSteckbrief();
}

Solche Abfragen sehen Sie sehr häufig, wenn mit Objekten hantiert wird!

Identität testen

Sie kennen das doppelte Gleichheitszeichen im Zusammenhang mit Zahlen und booleschen Werten. Doch was bedeutet es im Zusammenhang mit Objekten?

Ball b1 = new Ball(10, 20);
Ball b2 = new Ball(10, 20);

if (b1 == b2) {
  println("samesame");
} else {
  println("different");
}

different

Die beiden Ball-Objekte sind zwar "gleich" im dem Sinne, dass sie die gleichen Werte enthalten, aber es handelt sich um zwei unterschiedliche Objekte (= Häuschen). Man kann auch sagen: die beiden Objekte sind nicht identisch.

Merken Sie sich: Das doppelte Gleichheitszeichen testet, ob es sich um dasselbe Häuschen handelt! Anders gesagt: Bei Objekten bedeutet das ==, dass beide Variablen auf dasselbe Objekt zeigen, d.h. es handelt sich um das identische Objekt.

Beachten Sie, dass das nicht immer intuitiv ist, denn es deckt sich nicht mit unserem Verständnis von "Gleichheit". Im folgenden Beispiel erstellen wir zwei Vektoren, die jeweils nur aus Nullen bestehen. Insofern wären beide "gleich". Da es sich aber um zwei verschiedene Objekte handelt, sind sie nicht identisch.

PVector v1 = new PVector();
PVector v2 = new PVector();

println(v1);
println(v2);

if (v1 == v2) {
  println("samesame");
} else {
  println("different");
}

[ 0.0, 0.0, 0.0 ]
[ 0.0, 0.0, 0.0 ]
different

Um Gleichheit zu testen, bieten alle vorhandenen Klassen die Methode equals() an:

PVector v1 = new PVector();
PVector v2 = new PVector();

println(v1);
println(v2);

if (v1.equals(v2)) {
  println("samesame");
} else {
  println("different");
}

[ 0.0, 0.0, 0.0 ]
[ 0.0, 0.0, 0.0 ]
samesame

Das bedeutet: Wenn Sie die Identität von Objekten testen wollen, verwenden Sie ==. Wenn Sie Gleichheit (gleiche Inhalte) testen wollen, verwenden Sie equals().

Bei Strings wollen Sie i.d.R. Gleichheit testen, also verwenden Sie bei Strings immer die Methode equals().

Wenn Sie selbst Klassen schreiben, können Sie die Methode equals() selbst schreiben, um zu definieren, was bei Ihren Klassen Gleichheit genau bedeutet. Wie das funktioniert, erfahren Sie im nächsten Semester.

Student s1 = new Student("Harry", 123);
Student s2 = new Student("Sally", 456);
s2 = s1;
println(s1.name);
println(s2.name);

if (s1 == s2) {
   println("identisch!");
} else {
   println("nicht identisch");
}

Student s1 = new Student("Harry", 123);
Student s2 = new Student("Sally", 456);
Student s3 = s1;
s3.name += " Smith";
s2 = s3;
s2.matrikelnummer = 42;
println(s1.name + " " + s1.matrikelnummer);
println(s2.name + " " + s2.matrikelnummer);
println(s3.name + " " + s3.matrikelnummer);

Student s1 = new Student("Harry", 123);
Student s2 = new Student("Harry", 123);

if (s1 == s2) {
   println("identisch!");
} else {
   println("nicht identisch");
}

class KlausurNote {
  String student;
  int note;

  KlausurNote(String s, int n) {
    student = s;
    note = n;
  }
}

void setup() {
  KlausurNote[] noten = new KlausurNote[3];
  noten[0] = new KlausurNote("Fred", 3);
  noten[1] = new KlausurNote("Susi", 1);
  noten[2] = new KlausurNote("Thore", 2);
}

Fred hat eine 3
Susi hat eine 1
Thore hat eine 2

Fred hat eine 1
Susi hat eine 1
Thore hat eine 1

class Auto {
  boolean licht = true;
  boolean motor = true;
  boolean tuev = true;

  Auto(boolean l, boolean m) {
    licht = l;
    motor = m;
  }
}

void setup() {
  Auto[] autos = new Auto[3];
  autos[0] = new Auto(true, false);
  autos[1] = new Auto(false, false);
  autos[2] = new Auto(true, true);
  tuevCheck(autos);
  // Hier alle Autos auf die Konsole ausgeben
}

// Hier Ihre Funktion tuevCheck

8.7 Umgang mit Klassen

Klassen gut zu designen ist eine Kunst. Seien Sie also nicht frustriert, wenn Ihnen derzeit nicht klar ist, ob Sie ein Stück Code in die Klasse oder in den Hauptcode setzen sollen. Hier zeigen wir ein paar Situationen, wo man klare Empfehlungen geben kann.

Unterschied: Globale Variable vs. Instanzvariable

Sie sollten nie eine globale Variable direkt im Code einer Klasse (d.h. Funktionen oder Konstruktor) verwenden. Beispiel:

// Globale Variable
int x = 0;

class Ball {

  void drawBall() {
   ellipse(x, 100, 10, 10);
  }

  void move() {
    x++; // NICHT GUT!
  }
}

Warum? Weil Ihre Klasse Ball dann nicht unabhängig vom restlichen Code ist. Die Klasse Ball kann also nur in solchen Programmen verwendet werden, wo es eine globale Variable x gibt. Und darüber hinaus muss dieses x auch noch im gleichen Sinne wie im Originalprogramm verwendet werden.

Klassen sollen möglichst autonome Gebilde sein. Man sagt auch, dass eine Klasse eine Art Kapsel ist oder dass die Funktionalität der Klasse gekapselt sein sollte. Das heißt: keine Verbindungen zur Außenwelt, außer durch Parameterübergabe an Funktionen und Konstruktoren.

Wenn wir unser Beispiel verbessern wollen haben wir zwei Möglichkeiten, je nachdem, wie wir unsere Klasse designen wollen.

Möglichkeit 1: Ihre Klasse soll nur zum Zeichnen dienen. Man kann der Klasse sagen "mal einen Ball bei (x, y)". Folglich muss das Bewegen des Balls außerhalb der Klasse stattfinden. Jedesmal wenn Sie den Ball zeichnen wollen, müssen Sie die konkreten Koordinaten angeben.

int x = 0;

class Ball {

  void drawBall(int ballX) {
   ellipse(ballX, 100, 10, 10);
  }
}

Möglichkeit 2: Ihre Klasse beinhaltet einen Ball, der sich autonom bewegt, wenn man den entsprechenden Befehl aufruft (move). Folglich muss die Klasse die eigenen Koordinaten kennen und verwalten.

// Hier ist die x-Koordinate in der Klasse gekapselt
class Ball {
  int x = 0;

  void drawBall(int x) {
   ellipse(x, 100, 10, 10);
  }

  void move() {
    x++;
  }
}

Möglichkeit 2 ist in der Regel zu bevorzugen, d.h. versuchen Sie immer, alle relevanten Informationen in der Klasse zu halten.

Kein Interfacecode in Ihrer Klasse

Wenn Sie Klassen für Objekte schreiben, die per Maus manipuliert werden können, müssen Sie davon ausgehen, dass sich das Interface ändert. Vielleicht wollen Sie Ihren Ball per Multitouch, Kinect oder Nintendo-Controller steuern? Dann ist es ungünstig, wenn Sie mit keyCodes arbeiten oder die Variablen mouseX oder mousePressed im Code Ihrer Klasse verwenden.

Stattdessen merken Sie sich am besten, dass jeglicher Interface-Code außerhalb Ihrer Klasse sein sollte.

// Klasse Thing
class Thing {
  int x;
  int y;

  Thing(int ax, int ay) {
    x = ax;
    y = ay;
  }

  void draw() {
    rect(x, y, 20, 20);
  }

  // Nicht gut: Klasse enthält Interface-Code
  // (irgendwas mit key... oder mouse...)

  void checkKeys() {
    if (keyPressed && keyCode == LEFT) {
      x = x - 1;
    }
    if (keyPressed && keyCode == RIGHT) {
      x = x + 1;
    }
  }
}

// Hauptcode
Thing thing = new Thing(50, 50);

void setup() {
  size(100,100);
}

void draw() {
  background(100);
  thing.draw();
  thing.checkKeys();
}

Stattdessen verlagern Sie den Interface-Code in Ihr Hauptprogramm. Sie ergänzen die Klasse eventuell um Methoden zur Bewegung (wie hier moveX), die dann aus dem Hauptprogramm aufgerufen werden.

// Klasse Thing
class Thing {
  int x;
  int y;

  Thing(int ax, int ay) {
    x = ax;
    y = ay;
  }

  void draw() {
    rect(x, y, 20, 20);
  }

  // Bewege entlang x-Achse um Distanz
  void moveX(int distance) {
    x = x + distance;
  }
}

// Hauptcode
Thing thing = new Thing(50, 50);

void setup() {
  size(100, 100);
}

void draw() {
  background(100);
  thing.draw();
  if (keyPressed && keyCode == LEFT) {
    thing.moveX(-1);
  }
  if (keyPressed && keyCode == RIGHT) {
    thing.moveX(1);
  }
}

Sie können sich fürs erste die Regel merken, dass Sie in Ihren Klassen nicht die Variablen mouseX, mouseY, mousePressed, keyPressed, keyCode verwenden sollten.