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.