Generics richtig verstanden?

[EdAdvokat]

Ich schleiche mich so ganz langsam an generics heran und bin mir nicht so ganz sicher, ob ich es wirklich richtig verstanden habe.
Anbei mein Versuch:

Delphi-Quellcode:

type
  TPair<TKey,TValue> = class   // TKey. TValue type parameters
     FKey: TKey;
     FValue: TValue;
     function GetValue: TValue;
     function GetKey: TKey;
     procedure setValue(V:TValue);
     procedure setKey(K:TKey);
     constructor create;
     destructor Destroy;override;
     property Key:TKey read FKey write FKey;
     property Value:TValue read FValue write FValue;
   end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

{ TPair<TKey, TValue> }

constructor TPair<TKey, TValue>.create;
begin
  inherited create;
end;

destructor TPair<TKey, TValue>.Destroy;
begin

  inherited;
end;

function TPair<TKey, TValue>.GetKey: TKey;
begin
  Result:=FKey
end;

function TPair<TKey, TValue>.GetValue: TValue;
begin
  Result := FValue;
end;

procedure TPair<TKey, TValue>.setKey(K: TKey);
begin
  FKey:=K;
end;

procedure TPair<TKey, TValue>.setValue(V: TValue);
begin
  FValue:=V;
end;

procedure TForm1.btn1Click(Sender: TObject);
begin
  close;
end;

procedure TForm1.btnKeyClick(Sender: TObject);
var Key: TPair<string,integer>;  //typ parameter zuweisen bsp. string oder integer
begin
  Key:=TPair<string,integer>.create;
  try
    Key.Key:=edtKey.Text;
    lblKey.caption:=Key.Key;
    //ShowMessage(Key.Key);
  finally
    freeandNil(Key);
  end;
end;

procedure TForm1.btnInhaltClick(Sender: TObject);
var Inhalt: TPair<string,integer>;
begin
  Inhalt:=TPair<string,integer>.create;
  try
    Inhalt.Value:=strtoint(edtInhalt.text);
    lblValue.caption:=inttostr(Inhalt.Value);
    //ShowMessage(inttostr(Inhalt.Value));
  finally
    FreeAndNil(Inhalt);
  end;

end;

end.

Also einer generic-class weise ich die Typparameter TKey und TValue zu und arbeite mit diesen.
Um dann diesen abstrakten Parametern wieder ein Gesicht in Form von string bzw. integer zu geben, die ich dann in der Form aufrufen kann.
Habe ich das so richtig verstanden oder liege ich naiv völlig daneben?
Welche Vorteile ergeben sich aus der Arbeit mit generics? Könnte man das nicht auch bereits so in OOP ohne generics? Wo liegt also der Vorteil?
Möglicherweise sehr naive Fragen.