Objekt­ori­en­tier­te Programmierung

Inhalt

Ein­füh­rung

Das Kon­zept der ➨Funk­tio­nen ist ein gutes Werk­zeug zur Struk­tu­rie­rung eines Pro­gramms. Häu­fig ver­wen­de­te Pro­gramm­tei­le müs­sen nur ein­mal erstellt wer­den. Sie kön­nen dann an belie­bi­ger Stel­le im Pro­gramm auf­ge­ru­fen wer­den. Eine Funk­ti­on kann einen Befehl aus­füh­ren und eine Varia­ble an die Stel­le zurück­ge­ben (return), von der sie auf­ge­ru­fen wur­de oder ledig­lich eine Fol­ge von Befeh­len "abar­bei­ten".

Klas­sen und deren Objek­te sind eine Wei­ter­ent­wick­lung der Funktionen.

Varia­blen besit­zen vor­de­fi­nier­te Typen:
int, float, char, String

Ein Objekt muss als eine Art "Bau­plan" pro­gram­miert wer­den. In der objekt­ori­en­tier­ten Pro­gram­mie­rung wird die­ser Objekt­typ Klas­se genannt.

Am Bei­spiel eines Zufalls­ge­nera­tor soll das Prin­zip erklärt werden.

Bei­spiel Zufalls­zah­len generieren

class

Zunächst wird die Klas­se mit dem Schlüs­sel­wort class ein­ge­lei­tet. Anschlie­ßend wer­den die not­wen­di­gen Varia­blen für den Zah­len­raum defi­niert, in dem die Zufalls­zah­len ermit­telt wer­den sollen.

// Definition der Klasse
class Zufall 
{
  // Variablen der Klasse
  int Minimum;
  int Maximum;

Kon­struk­tor

Der Kon­struk­tor über­mit­telt dem spä­ter erzeug­ten Objekt eini­ge Infor­ma­tio­nen. Der Kon­struk­tor kann auf die Attri­bu­te (Varia­blen) einer Klas­se zugrei​fen​.Er wird genau­so wie eine nor­ma­le Metho­de defi­niert, jedoch ohne das Schlüs­sel­wort void.

Das Schlüs­sel­wort public teilt der Klas­se mit, dass sie auf Metho­den und Attri­bu­te zugrei­fen darf.

// Konstruktor
public:
  Zufall(int minimumZahl, int maximumZahl) 
  {
    Minimum = minimumZahl;
    Maximum = maximumZahl;
  }

Metho­de

Funk­tio­nen inner­halb einer Klas­se wer­den Metho­den genannt. Die Metho­de Zufalls­zahl() ermit­telt eine Zufalls­zahl.
Die Defi­ni­ti­on der Klas­se wird mit einem ; abgeschlossen. 

  // Funktion Zufallszahl
  int Zufallszahl() 
  {
    int Zahl = random(Minimum, Maximum);
    return Zahl;
  }
};

Objek­te erzeugen

Wie an einem Abreiß­block kön­nen Objek­te der Klas­se Zufall erzeugt wer­den. Als Para­me­ter wird dem Objekt die kleins­te und die größ­te Zahl des Zah­len­raums übergeben.

/*
  neue Objekte der Klasse Zufall erzeugen
  Parameter: Minimum und Maximum des Zahlenraums der Zufallszahlen
  random rundet immer nach unten
  -> Zahlenraum um 1 erhöhen
*/
Zufall ersteZufallsZahl(1, 7);
Zufall zweiteZufallsZahl(10, 21);
Zufall dritteZufallsZahl(100, 201);

Das Pro­gramm

Objekt und Metho­de der Klas­se wer­den durch einen . getrennt.

// Definition der Klasse
class Zufall 
{
  // Variablen der Klasse
  int Minimum;
  int Maximum;

// Konstruktor
public:
  Zufall(int minimumZahl, int maximumZahl) 
  {
    Minimum = minimumZahl;
    Maximum = maximumZahl;
  }
  
  // Funktion Zufallszahl
  int Zufallszahl() 
  {
    int Zahl = random(Minimum, Maximum);
    return Zahl;
  }
};

/*
  neue Objekte der Klasse Zufall erzeugen
  Parameter: Minimum und Maximum des Zahlenraums der Zufallszahlen
  random rundet immer nach unten
  -> Zahlenraum um 1 erhöhen
*/
Zufall ersteZufallsZahl(1, 7);
Zufall zweiteZufallsZahl(10, 21);
Zufall dritteZufallsZahl(100, 201);

void setup() 
{
  Serial.begin(9600);
}

void loop() 
{
  Serial.println("Zahl zwischen 1 und 6: " + String(ersteZufallsZahl.Zufallszahl()));
  Serial.println("Zahl zwischen 10 und 20: " + String(zweiteZufallsZahl.Zufallszahl()));
  Serial.println("Zahl zwischen 100 und 200: " + String(dritteZufallsZahl.Zufallszahl()));

  delay(1000);

  Serial.println("------------------------------"); 
  Serial.println("Neue Zahlen");
  Serial.println("------------------------------"); 
}

Bei­spiel Blinklichter

Das Pro­gramm im Film

Erläu­te­rung des Programms

Das Pro­gramm erstellt eine Klas­se Blink­licht, die Metho­de Blin­ken sorgt für das Ein- und Aus­schal­ten der LED für varia­ble Zeit­span­nen.
Beach­te die Kommentare.

// Definition der Klasse
class Blinklicht 
{
  /*
    Variablen der Klasse
    LEDPin = digitaler Pin der LED
    ZeitEingeschaltet = Einschaltdauer der LED
    ZeitAusgeschaltet = Ausschaltdauer der LED
  */
  int LEDPin;              
  long ZeitEingeschaltet;  
  long ZeitAusgeschaltet;  

  // Status der LED (ein/aus)
  int LEDStatus;

  // gesicherte Zeit, wird für die Ermittlung der Ein- und Ausschaltdauer benötigt
  unsigned long gesicherteZeit;

// Konstruktor  
public:
  Blinklicht(int PinMummer, long einGeschaltet, long ausGeschaltet) 
  {
    LEDPin = PinMummer;
    pinMode(LEDPin, OUTPUT);

    ZeitEingeschaltet = einGeschaltet;
    ZeitAusgeschaltet = ausGeschaltet;

    LEDStatus = LOW;
    gesicherteZeit = 0;
  }

  void Blinken() 
  {
    // aktuelle Zeit ermitteln
    unsigned long aktuelleZeit = millis();

    /*
      wenn die LED eingeschaltet ist
      und (&&) die Zeitdifferenz zwischen der aktuellen Zeit und der zuvor gesicherten Zeit
      größer als die Einschaltdauer ist
      -> LED ausschalten und aktuelle Zeit für den nächsten Durchlauf sichern
    */
    if ((LEDStatus == HIGH) && (aktuelleZeit - gesicherteZeit > ZeitEingeschaltet)) 
    {
      LEDStatus = LOW;              
      gesicherteZeit = aktuelleZeit;  
      digitalWrite(LEDPin, LEDStatus);  
    } 

    /*
      wenn die LED ausgeschaltet ist
      und (&&) die Zeitdifferenz zwischen der aktuellen Zeit und der zuvor gesicherten Zeit
      größer als die Ausschaltdauer ist
      -> LED einschalten und aktuelle Zeit für den nächsten Durchlauf sichern
    */
    else if ((LEDStatus == LOW) && (aktuelleZeit - gesicherteZeit > ZeitAusgeschaltet)) 
    {
      LEDStatus = HIGH;
      gesicherteZeit = aktuelleZeit;    
      digitalWrite(LEDPin, LEDStatus);      }
  }
};

// neue Objekte der Klasse Blinklicht erzeugen, zwei LEDs an Pin 6 und 7
// Parameter: Pin, Dauer eingeschaltet, Dauer ausgeschaltet
Blinklicht led1(6 100, 400);
Blinklicht led2(7, 350, 350);

void setup() 
{
  // bleibt leer
}

// Objekt und Methode durch . getrennt
void loop() 
{
  led1.Blinken();
  led2.Blinken();
}

Bei­spiel Blink­licht mit einem Array

class Led 
{               
    int  LedPin;         
    bool StatusLED;      

  public:                
    Led(byte PinNummer) 
    {      
      LedPin = PinNummer;
      StatusLED = false;
      pinMode(LedPin, OUTPUT);
    }

    // Methoden der Klasse
    void Blinken()
    {
      digitalWrite(LedPin, HIGH);
      delay(200);
      digitalWrite(LedPin, LOW);
      delay(200);
    }

    void EinAus() 
    {         
      StatusLED = !StatusLED; 
      digitalWrite(LedPin, StatusLED);
      delay(200);
    }
};     

// Array mit den Pins der LEDs
Led ListeLED[] = {Led(3), Led(4), Led(5), Led(6), Led(7), Led(8), Led(9)}; 

void setup() 
{
  // bleibt leer
}

void loop() 
{
  // alle LEDs blinken nacheinander
  for (int i = 0; i < sizeof(ListeLED) / sizeof(ListeLED[0]); i++)  
  {
    ListeLED[i].Blinken();
  }

  // Lauflicht
  for (int i = 0; i < sizeof(ListeLED) / sizeof(ListeLED[0]); i++)  
  {
    ListeLED[i].EinAus();
  }
}

Quel­len

Letzte Aktualisierung: 7. Okt 2024 @ 11:37