EMZETT.
Login

Emzett Wiki

Pascal: Units, Klassen und Objekte

Properties1
tagsprogrammiersprachen, pascal

4 Min. Lesezeit

Kurz: Object Pascal (Modus objfpc oder delphi) bietet Klassen mit Vererbung und virtuellen Methoden:

Teil des Kurses Pascal

Kapitel 4 von 8 im Kurs Pascal. Mit Fortschritt, Quiz und Zertifikat auf der Lernseite.

Klassen

Object Pascal (Modus objfpc oder delphi) bietet Klassen mit Vererbung und virtuellen Methoden:

program Tiere;
{$mode objfpc}{$H+}
 
type
  TTier = class
  private
    FName: String;
  public
    constructor Create(AName: String);
    function Laut: String; virtual;
    function Vorstellen: String;
    property Name: String read FName write FName;
  end;
 
  THund = class(TTier)
  public
    function Laut: String; override;
  end;
 
  TKatze = class(TTier)
  public
    function Laut: String; override;
  end;
 
constructor TTier.Create(AName: String);
begin
  inherited Create;
  FName := AName;
end;
 
function TTier.Laut: String;
begin
  Result := '...';
end;
 
function TTier.Vorstellen: String;
begin
  Result := Name + ' sagt ' + Laut;
end;
 
function THund.Laut: String;
begin
  Result := 'Wau';
end;
 
function TKatze.Laut: String;
begin
  Result := 'Miau';
end;
 
var
  zoo: array[0..1] of TTier;
  t: TTier;
begin
  zoo[0] := THund.Create('Rex');
  zoo[1] := TKatze.Create('Mimi');
  for t in zoo do writeln(t.Vorstellen);
  writeln(zoo[0] is THund, ' ', zoo[1] is THund, ' ', zoo[0].ClassName);
  for t in zoo do t.Free;
end.

Ausgabe:

Rex sagt Wau
Mimi sagt Miau
TRUE FALSE THund

Eigenschaften und Zugriffsschutz

private, protected, public regeln die Sichtbarkeit. Mit property kapselt man Felder:

program Konto;
{$mode objfpc}{$H+}
uses SysUtils;
 
type
  EZuWenig = class(Exception);
 
  TKonto = class
  private
    FStand: Double;
    procedure SetStand(Wert: Double);
  public
    procedure Einzahlen(Betrag: Double);
    procedure Abheben(Betrag: Double);
    property Stand: Double read FStand;
  end;
 
procedure TKonto.SetStand(Wert: Double);
begin
  FStand := Wert;
end;
 
procedure TKonto.Einzahlen(Betrag: Double);
begin
  if Betrag <= 0 then raise Exception.Create('Betrag muss positiv sein');
  SetStand(FStand + Betrag);
end;
 
procedure TKonto.Abheben(Betrag: Double);
begin
  if Betrag > FStand then raise EZuWenig.CreateFmt('Nur %.2f verfügbar', [FStand]);
  SetStand(FStand - Betrag);
end;
 
var
  k: TKonto;
begin
  k := TKonto.Create;
  try
    k.Einzahlen(100);
    k.Abheben(30);
    writeln(k.Stand:0:2);
    try
      k.Abheben(500);
    except
      on e: EZuWenig do writeln('Fehler: ', e.Message);
    end;
    try
      k.Einzahlen(-5);
    except
      on e: Exception do writeln('Allgemein: ', e.Message);
    end;
  finally
    k.Free;
  end;
end.

Ausgabe:

70.00
Fehler: Nur 70.00 verfügbar
Allgemein: Betrag muss positiv sein

Units: Code auf Dateien verteilen

Eine Unit hat einen öffentlichen interface- und einen privaten implementation-Teil:

unit Geometrie;
{$mode objfpc}
 
interface
function Kreisflaeche(r: Double): Double;
function Rechteckflaeche(b, h: Double): Double;
 
implementation
function Kreisflaeche(r: Double): Double;
begin
  Result := Pi * r * r;
end;
 
function Rechteckflaeche(b, h: Double): Double;
begin
  Result := b * h;
end;
end.

Das Hauptprogramm bindet die Unit mit uses Geometrie; ein. fpc findet Geometrie.pas im selben Ordner und übersetzt es automatisch mit.

Generics und Interfaces

program Generisch;
{$mode objfpc}{$H+}
uses Generics.Collections;
 
type
  IGruss = interface
    function Sage: String;
  end;
 
  TDeutsch = class(TInterfacedObject, IGruss)
    function Sage: String;
  end;
 
  generic TKiste<T> = class
    Inhalt: T;
    constructor Create(AInhalt: T);
    function Holen: T;
  end;
 
function TDeutsch.Sage: String;
begin
  Result := 'Guten Tag';
end;
 
constructor TKiste.Create(AInhalt: T);
begin
  Inhalt := AInhalt;
end;
 
function TKiste.Holen: T;
begin
  Result := Inhalt;
end;
 
var
  g: IGruss;
  liste: specialize TList<Integer>;
  kiste: specialize TKiste<String>;
  i, summe: Integer;
begin
  g := TDeutsch.Create;
  writeln(g.Sage);
  kiste := specialize TKiste<String>.Create('Inhalt der Kiste');
  writeln(kiste.Holen);
  kiste.Free;
  liste := specialize TList<Integer>.Create;
  try
    for i := 1 to 5 do liste.Add(i * i);
    liste.Sort;
    summe := 0;
    for i in liste do summe := summe + i;
    writeln(liste.Count, ' ', summe, ' ', liste[2]);
  finally
    liste.Free;
  end;
end.

Ausgabe:

Guten Tag
Inhalt der Kiste
5 55 9

Merke

  • class, constructor, virtual/override, inherited bilden die Objektorientierung
  • property kapselt Felder, private/protected/public steuern Sichtbarkeit
  • Speicher von Objekten gibt man mit Free frei (try ... finally)
  • Units teilen Code in interface und implementation; Generics (specialize) und Interfaces gibt es auch

Übungsaufgabe

Schreibe eine Klasse TStapel mit Push, Pop und Groesse auf Basis von TList.

Quiz zur Selbstkontrolle

Weiter im Kurs

Zurück: Strings, Arrays, Mengen und Records

Weiter: Dateien, Ausnahmen und Standardbibliothek

Alle Kapitel: Pascal im Überblick

Graphansicht

Backlinks