Objektorientierende Programmierung OOP
Kern der OOP bilden die Objekt-Typen: Deren Deklaration ähnelt jener des bekannten Record-Typs. Im Gegensatz zur Record-Variablen beinhaltet eine Objekt-Variable nicht nur Daten, sondern auch sogenannte Methoden. Methoden ähneln Prozeduren, die auf die Daten des Objekts angewendet werden können.
In einigen Programmiersprachen bezeichnet man Objekte als Klassen oder Komponenten (z.B. Delphi).
Objektorientierendes Programmieren
| Eine Objektorientierende Welt ist durch eine Menge von Objekten gekennzeichnet, die miteinander in Beziehung stehen. Ein Objekt ist ein Fähigkeiten bzw. Verhalten und einen Zustand gekennzeichnet. Die Fähigkeiten werden auch als Methoden bezeichnet. Der Zustand wird in den Attributen aufbewahrt |
| Finden sich mehrere Objekte, die gleiche Attribute und Methoden besitzen, so kann man diese zu einer Klasse abstrahieren. Eine Klasse ist also ein Prototyp für mehrere Objekte. |
| Der Unterschied zwischen einer Methode und der Funktion der strukturierten Programmierung ist, dass eine Methode an ein Objekt gebunden ist. Methoden sind zumeist öffentlich bekannt und können von anderen Objekten aufgerufen werden. Durch diesen Aufruf wird eine Botschaft übermittelt. |
| Die Attribute eines Objektes sind im allgemeinen nicht von außen zugänglich. (Dafür sind die Methoden da!) Ein Attribut entspricht einer Variablen in der strukturierten Programmierung, jedoch sind Attribute ebenfalls an Objekte gebunden. Dadurch dass Attribute nicht öffentlich sind, hat das einzelne Objekt eine bessere Kontrolle über die Werte, die in den Attributen abgelegt |
Struktur einer Klasse:
die Klasse besteht aus einer bestimmten Anzahl von Komponenten, welche entweder Datenkomponenten oder Methoden zur Durchführung von Operationen auf den Objektdaten sind.
Bezeichnerliste = bez1, bez2, ... {+++Datenelemente der Klasse+++}
Methodenkopf = PROCEDURE prname ( ... );
FUNCTION fktname ( ...): ...;
CONSTRUCTOR name ( ... );
DESTRUCTOR name ; {+++Operationen auf den Daten der Klasse+++}
Erzeugung von Objekten (Objektinstanzen) einer Klasse
Konstruktor (CONSTRUCTOR)
- ist spezielle Art von Prozedur zur Initialisierung einer Objektinstanz (Anfangsbelegung der Variablen)
- ist notwendig, wenn die Klasse über virtuelle Methoden verfügt
- muss vor einer virtuellen Methode aufgerufen werden
Destruktor (DESTRUCTOR)
- dient zur Beseitigung dynamisch angelegter Objekte und garantiert die Freigabe der korrekten Anzahl an Bytes auf dem Heap
- ist nur in Verbindung mit der dispose-Anweisung zu aktivieren, sonst keine Wirkung
Arbeit mit den Objekten (Botschaftenaustausch)
- Daten eines Objektes sollten nur innerhalb seiner eigenen Methoden direkt angesprochen werden. Die Verwendung des Punktoperators ist hierbei (wie bei RECORD-Komponenten) möglich.
Mit 'private' kann man sie explizit vor einem Zugriff von außen schützen
Die Methoden eines Objektes werden von außen (Hauptprogramm oder Methode einer anderen Klasse) ebenfalls mit Hilfe des Punktoperators aufgerufen.
Kapselung:
Daten und Operationen auf diesen Daten (Methoden) werden zu einem neuen strukturierten Typ, dem Objekttyp, zusammengefasst.
Vererbung:
Objekte werden bei der Definition in eine Klassenhierarchie eingegliedert, wobei jedes abstammende Objekt den gesamten Code und alle Daten der übergeordneten Klassen übernimmt.
Definition von geeigneten Klassenhierarchien ist Grundvoraussetzung für eine sinnvolle objektorientierten ProgrammierungPolymorphie (Vielgestaltigkeit):
Einer Methode wird ein Name gegeben, der für Objekte verschiedener Klassen gilt. Und dennoch wird die für die jeweilige Klasse adäquate Methode ausgeführt. Gleichnamige Methoden in den verschiedenen Hierarchieebenen sind in der Regel unterschiedlich
1. Beispiel Zahl suchen [Gestaltung des Bildschirmes über OOP (Mein erster Versuch mit OOP)]
2.Beispiel
(**********************************************************************) (* *) (* Simulation mit einem Würfel *) (* *) (**********************************************************************)
program Wuerfel;
uses crt;
type pw = array[1..6] of real;
ausgabe = array[1..6] of integer;
haeufig_keit = array[1..100] of word;
var i,n, augenzahl : integer;
haeufigkeit : haeufig_keit;
prozent : pw;
strecke : ausgabe;
max : real;
{ooooooooooooooooooooooooooo BEGINN O O P ooooooooooooooooooooooooooooo}
type balken = object xl,xr,yo,yu : byte; {+++Koordinaten des balkens+++} farbe : integer; constructor ini(pxl,pyo,pxr,pyu,pfarbe : byte); procedure oeffnen; procedure schliessen; end;
titelbalken = Object (balken) ziffer : byte; xa,ya : byte; constructor ini(pxl,pyo,pxr,pyu,pfarbe : byte; p_ziffer : byte; pxa,pya : byte); procedure oeffnen; procedure schliessen; end; constructor balken.ini(pxl,pyo,pxr,pyu,pfarbe : byte); begin xl := pxl; yo := pyo; xr := pxr; yu := pyu; farbe := pfarbe; end;
procedure balken.oeffnen;
var i,j : integer;
begin
window(xl+1,yo+1,xr-1,yu-1);
for i := 1 to (xr - xl +1 ) do
for j := 1 to (yu - yo +1 ) do
begin
gotoxy(i,j);textbackground(farbe);write(' ');
end;
clrscr;window(1,1,80,25);
end;
procedure balken.schliessen;
begin
clrscr;
window(1,1,80,25);
end;
constructor titelbalken.ini(pxl,pyo,pxr,pyu,pfarbe : byte;
p_ziffer : byte;
pxa,pya : byte);
begin
ziffer := p_ziffer;
xa := pxa; ya := pya;
balken.ini(pxl,pyo,pxr,pyu,pfarbe);
end;
procedure titelbalken.oeffnen;
begin
balken.oeffnen;
gotoxy(xa,ya);
write(ziffer);
end;
procedure titelbalken.schliessen;
begin
window(1,1,80,25);textbackground(black);clrscr;
end;
{oooooooooooooooooooooooooooooo ENDE O O P ooooooooooooooooooooooooooooooo}
var balken1 : balken; {Instanzen der Objekte} titelbalken1 : titelbalken;
Procedure eingabe(var n :integer);
begin
gotoxy(3,3);textcolor(red);write('+++++Simulation eines Wrfels+++++');
gotoxy(3,5);textcolor(black);write('Anzahl der Simulationslaeufe: '); readln(n);
end;
procedure Berechnung_haeufigkeit( n :integer; var haeufigkeit : haeufig_keit;prozent : pw); var max :real;
begin
for i:=1 to 6 do haeufigkeit[i] := 0;
window(3, 3, 79, 22);textcolor(black);
for i:=1 to n do
begin
augenzahl := random(6) + 1;
inc(haeufigkeit[augenzahl]);
end;
for i := 1 to 6 do
begin
gotoxy(3,7);write('Absolute H„ufigkeiten',' ':3,'theoretischer Wert: ',N/6:6:2,' ');
gotoxy(3,8+i); write('Augenzahl ',i:4,': ',haeufigkeit[i]:5);
end;
end;
procedure berechnung_strecke(haeufigkeit : haeufig_keit; var prozent : pw;
var strecke : ausgabe);
begin
window(3, 3, 74, 19);
for i:=1 to 6 do
begin
prozent[i] := haeufigkeit[i]/n * 100 ;
max := prozent[1];
if max < prozent[i] then max := prozent[i];
strecke[i] := round((prozent[i]/max)*22) ;
gotoxy(35, 8 + i); textcolor (green);write(prozent[i]:10:2,' %');
end;
end;
procedure darstellung(strecke:ausgabe;prozent :pw); var i :integer; begin
textcolor(black);
for i := 1 to 6 do
begin
strecke[i]:=24-strecke[i];
titelbalken1.ini(5*i+5,strecke[i],5*i+9,25,(random(7)+1),i,5*i+7,20);
titelbalken1.oeffnen;
end;
textcolor(6);
titelbalken1.ini(45,4,75,22,6,0,47,6);
titelbalken1.oeffnen;
for i:=1 to 6 do
begin
textcolor(black);
gotoxy(50,8); write('+++++AUSWERTUNG+++++');
gotoxy(50,10); write('fr ',n,' Simulationslaeufe');
gotoxy(52,11+i);write(i,' ',prozent[i]:6:2,' %');
end;
end;
{+++++++++++++++++++++HAUPTPROGRAMMM++++++++++++++++++++++++}
begin
repeat
clrscr;
balken1.ini(1,1,80,25,7);
balken1.oeffnen;
randomize;
eingabe(n);
berechnung_haeufigkeit(n,haeufigkeit,prozent); readln;
berechnung_strecke(haeufigkeit,prozent,strecke);
window(1, 1, 80, 25);
gotoxy(4, 20);textcolor(red);
write('Weiter mit grafischer Darstellung <TASTE> ');
readln;
until ord(readkey) = 13;
balken1.schliessen;
balken1.ini(1,1,80,25,0);
balken1.oeffnen;
darstellung(strecke,prozent);
readln; end.
