Ihr habt schon einige Datentypen kennengelernt, z.B. int, float, boolean, char. Das sind primitive Datentypen. Sie stehen für eine Zahl, eine Buchstabe usw.

Es gibt aber auch die Möglichkeit, Variablen für kompexere Zusammenhänge zu erstellen. Z.B. ist ein Datentyp denkbar, welcher die Studierenden des Robotiklabors repräsentiert. Ein_e Student_in könnte folgende Eigenschaften haben: Name, Matrikelnummer, Name des Projektteams, Noten usw. Oder, um ein Beispiel aus dem Bereich der Robotik zu geben, ein Datentyp, welcher einen Schrittmotor repräsentiert. Ein Motor könnte die Eigenschaften Pinnummer, Drehrichtung und Schrittwinkel haben. Darüber hinaus könnte man bestimmte Funktionalität mit diesem Datentyp verbinden, z.B. kann ein Motor eine vorgegebene Anzahl an Schritten in eine oder in die andere Richtung machen. Solche Datentypen heissen Objektdatentypen oder abstrakte Datentypen.

Die Modelliernug der Welt mit Hilfe von Objekten entspricht dem Paradigma der objektorientierten Programmierung. Fast alle modernen Programmiersprachen (C++, Java, Python, C#) unterstützen sie. Beispiele in diesem Artikel wurden in Java/Processing erstellt.

Einen Objektdatentyp definiert man mit Hilfe einer Klasse. Ihr habt schon in den ersten Kurswochen mit Klassen/Objekten gearbeitet, z.B. Servo, Serial, String. Ein Objekt (eine Variable) eines bestimmten Objektdatentyps nennt man auch eine Instanz dieser Klasse. In der Regel schreibt man eine Klasse in einer eigenen Datei. Eine Klasse hat folgende Bestandteile:

• Attribute, auch Membervariablen oder Memberfelder genannt, sind die Eigenschaften des Objektes, z.B. die Drehrichtung des Motors.
• Ein oder mehrere Konstruktoren sind Methoden, mit welchen man das Objekt erstellt. Oft nutzt man den Konstruktor, um die Objektattribute zu initialisieren.
• Methoden, auch Funktionen genannt, definieren, was das Objekt machen kann.

Exemplarisch sieht eine Klasse so aus (beachtet die Upper-Camel-Case-Schreibweise des Klassennamens):

class MyClassName { // alles, was zur Klasse gehört, steht zwischen den geschweiften Klammern
// 1. Attribute: Welche Eigenschaften hat das Objekt?
// 2. Konstruktor(en): Wie wird das Objekt erstellt?
// 3. Methoden: Was kann das Objekt tun?
}

Wir wollen nun das Beispiel von der letzten Crashkurs-Seite so umschreiben, dass Klassen verwendet werden. Wir wollen erstmal einen Roboter vorwärts bewegen und drehen lassen. Der Roboter hat folgende Eigenschaften: Radius, die aktuelle x- und y-Position sowie die aktuelle Richtung; Diese werden zu den Attributen der Klasse.

Im Sketch-Tab:

Haupttab.pde

Robot myRobot = new Robot(25, 100, 100, 0);
 
void setup() {
  size(600, 400);
}
 
void draw() {
  clear();
  myRobot.drawRobot();
  myRobot.move(4);
  myRobot.turn(0.1);
}

Im neuen Tab „Robot“:

Robot.pde

class Robot {
  // Attribute:
  int radius; // Radius des Roboters
  float xPos; // x-Position des Roboters
  float yPos; // y-Position des Roboters
  float angle; // Richtung des Roboters
 
  /*
   * Konstruktor
   */
   Robot(int paramRadius, float paramXPos, float paramYPos, float paramAngle) {
     this.radius = paramRadius;
     this.xPos = paramXPos;
     this.yPos = paramYPos;
     this.angle = paramAngle;
   }
 
/*
 * Zeichnet den Roboter
 */
  void drawRobot() {
    ellipse(xPos, yPos, radius*2, radius*2); 
    // *2, weil die ellipse-Funktion den Diameter verwendet
    line(xPos, yPos, xPos + radius * cos(angle), yPos + radius * sin(angle));
    // Linie zwischen dem Roboterzentrum und dem Roboterrand in die Bewegungsrichtung
  }
 
/*
 * Bewegt den Roboter nach vorne in seine Richtung
 */
  void move(float distance) {
    xPos = xPos + distance * cos(angle);
    yPos = yPos + distance * sin(angle);
  }
 
/*
 * Rotiert den Roboter
 */
  void turn(float angleDiff) {
    angle = angle + angleDiff;
  }
}

Haupttab.pde

Robot robot1; // Der 1. Roboter  
Robot robot2; // Der 2. Roboter
 
void setup() 
{
  size(600, 400);
  robot1 = new Robot(25, 300, 200, PI/4); // den 1. Roboter initialisieren
  robot2 = new Robot(50, 50, 200, 0); // den 2. Roboter initialisieren
}
 
void draw() {
  clear();
  robot1.drawRobot(); // beide Roboter zeichnen
  robot2.drawRobot();
  robot1.turn(0.1); // beide Roboter bewegen
  robot1.move(4);
  robot2.move(2);
  // Falls die beiden zu nah sind, sollen sie sich umdrehen:
  if (robot1.radius + robot2.radius >= robot1.distance(robot2)) {
    robot1.turn(PI);
    robot2.turn(PI);
  }
}

Im neuen Tab „Robot“:

Robot.pde

class Robot {
 
  // Attribute:
  int radius; // Radius des Roboters
  float xPos; // x-Position des Roboters
  float yPos; // y-Position des Roboters
  float angle; // Richtung des Roboters
 
  /*
   * Konstruktor
   */
  Robot(int paramRadius, float paramXPos, float paramYPos, float paramAngle) {
    this.radius = paramRadius;
    this.xPos = paramXPos;
    this.yPos = paramYPos;
    this.angle = paramAngle;
  }
 
  // Methoden:
  /*
   * Berechnet die Entfernung zwischen dem Zentrum von diesem Roboter und vom anderen Roboter
   */
  float distance(Robot other) {
    float deltaX = this.xPos - other.xPos;
    float deltaY = this.yPos - other.yPos;
    float dist = sqrt((sq(deltaX) + sq(deltaY)));
    return dist;
  }
 
 
  /*
   * Zeichnet den Roboter
   */
  void drawRobot() {
    ellipse(xPos, yPos, radius*2, radius*2); 
    // *2, weil die ellipse-Funktion den Diameter verwendet
    line(xPos, yPos, xPos + radius * cos(angle), yPos + radius * sin(angle));
    // Linie zwischen dem Roboterzentrum und dem Roboterrand in die Bewegungsrichtung
  }
 
  /*
   * Bewegt den Roboter nach vorne in seine Richtung
   */
  void move(float distance) {
    xPos = xPos + distance * cos(angle);
    yPos = yPos + distance * sin(angle);
  }
 
  /*
   * Dreht den Roboter
   */
  void turn(float angleDiff) {
    angle = angle + angleDiff;
  }
}