Projektlabor Robotik MINTgrün

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
====== Klassen ======


Ihr habt schon einige Datentypen kennengelernt, z.B. ''int'', ''float'', ''boolean'', ''char''. Das sind **primitive Datentypen**. Sie stehen für eine Zahl, einen Buchstaben 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 Modellierung der Welt mit Hilfe von Objekten entspricht dem Paradigma der [[https://de.wikipedia.org/wiki/Objektorientierte_Programmierung|objektorientierten Programmierung]].  Fast alle modernen Programmiersprachen (C++, Java, Python, C#) unterstützen sie. Die 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):

<code java>
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?
}
</code>

------

===== 1. Steuerung eines Roboters mit Hilfe einer Klasse =====

==Attribute und Konstruktor==

Wir wollen nun das Beispiel von [[skript:bewegungen|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. Dafür erstellen wir in Processing einen neuen Tab, d.h. eine neue Datei. Am besten nennen wir sie genau so wie unsere Klasse, z.B. ''Robot''.

Nun müssen wir der Klasse sagen können, dass diesen Attributen bestimmte Werte zugewiesen werden sollen. Das machen wir mit Hilfe des Konstruktors. Genauso wie bei Methoden/Funktionen können an den Konstruktor Parameter übergeben werden. In unserem Beispiel werden wir die Anfangswerte der Attribute übergeben:

<file java 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 radius, float x, float y, float angle) {
     this.radius = radius; // hier muss man "this" nutzen, um die Attributvariable vom gleichnamigen Parameter zu unterscheiden
     this.xPos = x; // alternativ: xpos = x; 
     this.yPos = y; // alternativ: yPos = y;
     this.angle = angle; // 'this' muss sein
   }
}
</file>

Damit können wir unsere Klasse schon nutzen und eine Variable dieses neuen Datentyps anlegen. Wir können auch auf die Attribute zugreifen:

<file java Haupttab.pde>
void setup() {
     Robot myRobot = new Robot(25, 100, 100, 0); 
     // Ein Robot-Objekt initialisiert mit dem Radius 25, Anfangsposition (100, 100) und Winkel 0 rad
     println("Radius: " + myRobot.radius);
     println("X-Koordinate: " + myRobot.xPos);
}
</file>

Mit dem Wort ''new'' wird signalisiert, dass hier ein Konstruktor aufgerufen wird. Man kann die Attributwerte abfragen, indem man ''objektName.attributName'' schreibt. Wenn man sich innerhalb der Klasse befindet, kann man anstelle des Variablennamens das Wort ''this'' verwenden -- wie es hier im Konstruktor gemacht wurde. ''this'' braucht man unbedingt, wenn der Attrbituname mit einem Parameternamen übereinstimmt (sonst überdeckt der Parameter das Attribut). In anderen Fällen ist ''this'' optional. 


==Methoden==

Die Methoden ''move()'' und ''turn()'' übertragen wir in die ''Robot''-Klasse. Diese Methoden greifen nicht mehr auf die globalen Variablen zu, sondern auf die Attribute des ''Robot''-Objektes. Darüber hinaus brauchen wir eine Methode, die die Zeichenfläche aktualisiert. Früher hatten wir das einfach in ''loop()'' gemacht; Jetzt ist dafür die Methode ''drawRobot()'' verantwortlich. Auf die Methoden der Klasse können wir im Haupt-Tab mit ''objektName.methodenName()'' zugreifen. (Vielleicht habt ihr schon geahnt, dass die Schreibweise ''myServo.write()'' der letzten Woche, genau das macht: die Methode ''write'' der Klasse Servo  aufrufen.) 

Schaut euch das Endergebnis an:


<code java 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);
}
</code>
Im neuen Tab "Robot":

<file java 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 radius, float x, float y, float angle) {
     this.radius = radius; 
     this.xPos = x; // alternativ: xpos = x; 
     this.yPos = y; // alternativ: yPos = y;
     this.angle = angle; 
   }

/*
 * 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 um die angegebene Entfernung
 */
  void move(float distance) {
    xPos = xPos + distance * cos(angle);
    yPos = yPos + distance * sin(angle);
  }

/*
 * Rotiert den Roboter um den den angegebenen Winkel 
 */
  void turn(float angleDiff) {
    angle = angle + angleDiff;
  }
}
</file>

------

=====2. Zwei Roboter auf der gleichen Zeichenfläche=====

Die Verwendung von Klassen hat den Vorteil, dass wir -- im Gegensatz zur Version mit globalen Variablen -- mit wenig Mühe mehrere "Roboter" auf unserer Zeichenfläche erstellen können. Weiterhin ist unser Code übersichtlicher und weniger redundant. 

<file java 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.distance(robot2) <= 0) {
    robot1.turn(PI);
    robot2.turn(PI);
  }
}
</file>

<file java 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 radius, float x, float y, float angle) {
     this.radius = radius; 
     this.xPos = x; // alternativ: xpos = x; 
     this.yPos = y; // alternativ: yPos = y;
     this.angle = angle;
   }

  // Methoden:
  /*
   * Berechnet die Entfernung zwischen diesem Roboter und einem anderen Roboter
   */
  float distance(Robot other) {
    float deltaX = this.xPos - other.xPos; // optional: float deltaX = xPos - other.xPos;
    float deltaY = this.yPos - other.yPos; 
    float dist = sqrt((sq(deltaX) + sq(deltaY))) - this.radius - other.radius;
    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;
  }
}
</file>
Projektlabor Robotik MINTgrün

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Seiten-Werkzeuge
