Projekt mit
1 €
unterstützen?
So geht das *:


Step 20 - OOP - Vererbungslehre

Dieses Tutorial ist die Fortsetzung von Step 19, in dem zu Beginn die Vererbung bereits am Beispiel der Klasse TBitBtn erklährt wurde. Hieran wird nun angeschlossen.

Doch was ist Vererbung? Vererbung ist ein Phänomen, um spezialisiertere Objekte, verschiedener Art und Weise zusammenzufassen. Die Elternklasse beinhaltet alle Attribute (=Felder) und Methoden, welche dann auch in der Vererbten Klasse eingesetzt werden können, sofern sie an der richtigen Stelle deklariert wurden. Die verschiedenen Bereiche, private bis published, wurden im vorangehenden Kapitel bereits abgehandelt. Wenn wir also wollen, dass etwas in der abgeleiteten Klasse verwendet werden kann, oder auch verändert oder sogar überschrieben werden kann, so sollte dies nicht unter private stehen. Ansonsten kann man mittels sogenannten Properties auch hierauf wieder zugreifen. Properties sind jedoch Thema im Fortgeschrittenen Bereich. Zudem werden wir hier nun nicht alle Aspekte der Vererbung kennenlernen. Was fehlen wird sind einige Grundlegenden Aspekte, wie das Überschreiben von Methoden, der Vorteil an verschiedenen Spezialisierungen des Elternklasse, welche oft erst bei "größeren Projekten" spürbar werden. Aber hier geht es erstmal um eine Spezialisierung des Caesar-Verfahrens.

Wir gehen also nun davon aus, dass die Theorie in Step 19 verstanden worden und das Wissen über das Vigenére-Verfahren vorhanden ist, können wir gleich den in Step 19 erzeugten Quelltext in einen eigenen Ordner "OOPProject2" kopieren (bitte nur alle *.pas, *.dfm und die *dpr !) und wie in Step 19 eine neue Unit Namens "mVigenere.pas" anlegen. Hiernach kann man das Projekt per "Projekt speichern unter" unter einem neuen Projektnamen wie z.B. "OOPProject2" speichern.

In dieser Unit deklarieren wir auch vergleichbar mit Step 19 den type TVigenere, mit der Ausnahme, dass wir nicht von TObject ableiten, sondern von TCaesar. Um dies machen zu können müssen wir erstmal in die uses die unit mCaesar einbinden.

Das ganze sollte dann etwa so aussehen:

unit mVigenere;

interface

uses
  mCaesar;

type
  TVigenere = class(TCaesar)
  private
    { private-Deklarationen }
  protected
    { protected-Deklarationen }
  public
    { public-Deklarationen }
  published
    { published-Deklarationen }
  end;

implementation

end.

Den Constructor deklarieren wir genau wie in Step 19, nur mit dem Unterschied, dass dieser nun einen Parameter "password:String" bekommt:

    constructor Create(password:String);

Nun müssen wir erst noch das Feld fPassword:String im privat-Abschnitt deklarieren.

Hiernach können wir es im Constructor initialisieren:

constructor TVigenere.Create(password:String);
begin
  inherited Create;
  fPassword:=password;
end;

Nun muss im Grunde "nur" noch die Verschlüsselung imlementiert werden.
Wir "überschreiben" somit die Funktion DeCode und geben ihr neuen Parametern und neuem Inhalt:

  // deklaration:
    function DeCode(orig:String; decode:Boolean):String;

  // initialisierung (vorerst):
function TVigenere.DeCode(orig:String; decode:Boolean):String;
begin

end;

Wie im Constructor kann mittels "inherited" die function DeCode des Elternobjektes TCaesar aufgerufen werden. Somit ist es möglich den Algorithmus der Caesar-Verschlüsselung auszuführen.

Wir deklarieren zunächst drei Integer-Variablen:
IndexSource: Index des zu codierenden Strings durchgehen.
IndexPw: Index des Passwortes.
code: Verschiebung von A -> move.
Und zu guter letzt noch einen String:
coded: Codiertes Wort.

Das folgende Schaubild soll den Algorithmus veranschaulichen:

und hier der kommentierte Script dazu:

var
  indexOrig,           // Index des Original-Strings
  indexPw,             // Index des Passwort-Strings
  move      : Integer; // Verschiebung
  coded     : String;  // Codierter String
begin
  // Variablen initialisieren:
  indexOrig:=0;
  indexPw:=0;
  coded:='';
  while indexOrig < Length(orig) do // Während noch Buchstaben zu bearbeiten sind
  begin
    Inc(indexOrig); // nächsten Buchstaben behandeln
    Inc(indexPw);   // Passwortindex um eins erhöhen
    // Wenn Passwortindex größer als Länge des Passwortes
    if indexPw > Length(fPassword) then
      // Passwortindex auf 1 zurücksetzen
      indexPw := 1;
    // Buchstabe des Passwortes in ASCII-Zahl codieren und ord('a') abziehen
    // hierbei resuliert für z.B. fPassword[indexPW]='a'  move = 0;
    move := ord(fPassword[indexPw])-97;
    if decode then      // wenn decodiert werden soll
      move := 26-move;    // dann move umdrehen -> Rückwärts verschieben
    // Funktion der Klasse TCaesar mit aktulellem Buchstaben bei indexOrig ausführen
    coded := coded + inherited DeCode(orig[indexOrig],move);
  end;
  // codierten String zurückgeben
  result:=coded;
end;

Nun haben wir die mVigenere.pas fertiggestellt.
Es folgt die Implementierung in die MainUnit.

Bisher ist alles auf die mCaesar-Unit angepasst.
Dies ändern wir wie folgt:
  • Umbenennen der Objekte:
    BtnCaesar -> BtnVigenere
    EdMoveCount -> EdPassword
  • Hinzufügen der CheckBox CbDecode mt dem Text: "decodieren"
  • In der BtnVigenereClick-Procedure umbenennen:
    Caesar -> Vigenere
    TCaesar -> TVigenere
  • Beim Instanzieren des Objektes Vigenere als Parameter EdPassword.Text setzen
  • 2. Parameter der DeCode-Procedure ist nun CbDecode.Checked

Um nochmals ganz sicher zu gehen, ob alles stimmt, vergleicht nochmal euer Projekt mit dem, welches hier zum Download bereit steht.

Wenn ihr nun alle Kapitel bearbeitet habt, steht euch nichtsmehr im Wege die Aufgaben im nächsten Step zu bearbeiten ;-)


Da das Kommentarmodul dieser Seite zur Zeit neu überarbeitet werden muss, sendet bitte alle Fragen, Anregungen oder Probleme mit Betreff zu welchem Thema es sich handelt an folgende Mailadresse:


Hinweis:

Dieses Kommentar-Modul teilt seinen Inhalt mit dem gleichnamigen Kapitel im Lazarus-Anfängerkurs. Daher kann es vorkommen, dass Fragen zu Lazarus im Anfängerkurs im Delphi-Anfängerkurs und umgekehrt stehen. Wenn ihr euch registriert, werdet ihr aber immer an die richtige Stelle weitergeleitet.
Zu dieser gemeinsamen Nutzung der Datenbank habe ich mich entschlossen, weil die Sprachelemente in Lazarus genauso wie in Delphi genutzt werden können.

www.marco-hetzel.de
www.delphi-lernen.de
www.lazarus-lernen.de

© 2006-2019 by Marco Hetzel , last modified 01.11.2018, 11:28

(* Unterstützung dient der Aufrechthaltung laufender Kosten für dieses Projekt.)