|
Le classi fanno in qualche modo parte dei tipi derivati. Una classe può contenere variabili, costanti e campi come le normali strutture, ma, addizionalmente a questi, può contenere anche funzioni, procedure, costruttori e distruttori. Per questo verso, la classe è paragonabile ad un oggetto, che ha una determinata serie di istruzioni per ogni operazione che compie: una classe può essere un pulsante, una finestra, una lista o qualsiasi altra cosa. Tant'è vero, questo, che nella dichiarazione di una classe si usa la parola riservata object (oggetto).
Vediamo intanto come si dichiara una classe:
type
<nome>=Object
(*Corpo della classe, in cui ci possono essere:
procedure
funzioni
costruttore
distruttore
costanti
variabili
strutture
enumeratori
ecc...*)
end;
I membri private e i membri public
In una classe, i membri possono essere di 2 tipi differenti: private e public. I membri private, come suggerisce il nome, sono privati, cioè accessibili solo dai membri della stessa classe. Infatti i membri private non sono modificabili da qualunque ente esterno che non siano le stesse procedure e funzioni (o costruttori e distruttori) della classe mdesima.
D'altra parte, i membri public possono liberamente essere modificati da ogni ente esterno. Per esempio:
(*...*)
type
classe=object
private
i:integer;
public
l:longint;
procedure myproc;
begin
i:=2; (*Corretto, i è membro della stessa classe di myproc*)
end;
end;
var es:classe;
(*...*)
begin
(*...*)
es.l:=98; (*Corretto, l è public*)
es.i:=98; (*Errato, i è private*)
(*...*)
end;
E' evidente la differenza fra le due.
I membri di una classe
In una classe si possono dichiarare, come già detto, procedure, funzioni, variabili, costanti, costruttori e distruttori, che possono essere tutti public o private.
Per sapere come dichiarare correttamente i vari membri, studiate questo esempio:
program esempio;
uses crt;
type
classe=object
private
i:integer;
procedure modify(u:integer);
public
const MAX:byte=5;
procedure show;
function MAXi:integer;
procedure Seti(x:integer);
end;
procedure classe.modify(u:integer);
begin
i:=u;
end;
procedure classe.show;
begin
writeln('Integer: ',i);
end;
function classe.MAXi:integer;
begin
MAXi:=i*MAX;
end;
procedure classe.Seti(x:integer);
begin
modify(x);
end;
(*...*)
Oppure, nelle librerie:
unit esempio;
interface
type
classe=object
private
i:integer;
procedure modify(u:integer);
public
const MAX:byte=5;
procedure Show;
function MAXi:integer;
procedure Seti(x:integer);
end;
implementation
procedure classe.modify;
begin
i:=u;
end;
procedure classe.show;
begin
writeln('Integer: ',i);
end;
function classe.MAXi;
begin
MAXi:=i*MAX;
end;
procedure classe.Seti;
begin
modify(x);
end;
end.
I costruttori e i distruttori
Questo particolare tipo di procedure ha molti usi: il più semplice è quello di inizializzare le variabili e gli spazi di memoria necessari al funzionamento della altre parti della classe. Ad esempio:
(*...*)
type
tipi=object
private
i:ineteger;
l:longint;
c:char;
s:string;
public
constructor Create;
end;
constructor tipi.Create;
begin
i:=0;
l:=0;
c:='';
s:='';
end;
(*...*)
La sua vera funzione è quella di inizializzare classi contenenti metodi virtuali, ma vedremo in seguito.
|
|
Feeds
Sondaggio
Condividi
Numeri
