Newsgroup: it.comp.lang.delphi
Titolo: Dervare da Classe esistente ma con nuova Interface

la sequenza (1) funziona e non da problemi
la sequenza (2) genera un'errore non indicativo, credo piu' nella 
dichiarazione errata (**)
 
il test mi serve per capire se sia possbile creare classi che puntano a 
Interface diverse.
 
(1)
   type
     IMyInterface = Interface
     ['{BCC17930-EFB5-4728-B94F-165D9BDF0F1F}']
     function  GetServerName : string;
     procedure SetServerName(Name : string);
     property  ServerName : string read GetServerName write SetServerName;
   end;
 
   { TMyClass }
   type
   TMyClass = class(TInterfacedObject, IMyInterface)
   private
     FServerName : string;
   public
     function  GetServerName : string;
     procedure SetServerName(Name : string);
   end;
 
   { TMyClassTest }
   //eredito da Myclass e aggiungo un nuovo metodo
   type
   TMyClassTest = class(TMyClass, IMyInterface)
   private
     FNomePath: string;
   public
     function GetPath: string;
   end;
 
procedure TForm2.Button1Click(Sender: TObject);
var
   MyInterface : IMyInterface;
   MyTest : TMyClasstest;
begin
   try
   MyInterface := TMyClass.Create;
   MyInterface.ServerName := 'Srv_Test';
   ShowMessage('Server: '+ MyInterface.ServerName);
 
   MyTest := TMyClassTest.Create;
   ShowMessage('Path ' + MyTest.GetPath);
 
   finally
     if Assigned(MyInterface) then
      MyINterface := nil;
   end;
end;
 
(2)
estendere le funzionalita' aggiungenedo una
nuova Interfaccia IMyInterfaceTest;
- se compilo prima di aggiungere TMyClassTest, va a buon fine
- dopo l'aggiunta di TMyClassTest
 
[DCC Error] Unit1.pas(41): E2291 Missing implementation of interface 
method IMyInterfaceTest.GetProctollo
anche se aggiungo a mano il metodo non compila
 
 
   type
     IMyInterface = Interface
     ['{BCC17930-EFB5-4728-B94F-165D9BDF0F1F}']
     function  GetServerName : string;
     procedure SetServerName(Name : string);
     property  ServerName : string read GetServerName write SetServerName;
   end;
 
   type
     IMyInterfaceTest = Interface(IMyInterface)
     ['{6ADBB6B9-493A-4BB5-B0F1-37EF2DB34970}']
     function GetPath: string;
     procedure SetPath(sPath: string);
     property  NomePath : string read GetPath write SetPath;
   end;
 
   { TMyClass }
   type
   TMyClass = class(TInterfacedObject, IMyInterface)
   private
     FFirstName : string;
   public
     function  GetFirstName : string;
     procedure SetFirstName(Name : string);
   end;
 
   { TMyClassTest }
   type
   TMyClassTest = class(TMyClass, IMyInterface)
   private
     FNomePath: string;
   public
     function GetPath: string;
   end;
 
   { TMyClassTestDue }
   //usare
   type
   (**) //---> sembra non si valida la dichiarazione
   TMyClassTestDue = class(TMyClass, IMyInterfaceTest)
   private
     FProtocollo: string;
   public
     function GetProtocollo: string;
   end;

xche in TMyClass non ci sono le dichiarazioni dei membri servername esposti da IMyInterface?
 
 
xche in TMyClassTest2 non ci sono le dicihiarazioni dei  membri path esposti da IMyInterfaceTest?
 
A.
 


risolto, erano proprio i membri non esposti, coem hai indicato.
 
   TMyClassTestDue = class(TMyClass, IMyInterfaceTest)
   private
     FProtocollo: string;
   public
     function GetPath: string;
     procedure SetPath(sPath: string);
     function GetProtocollo: string;
   end;
 
mi chiedo spesso dove sia il vantaggio delle Interface (salvo DCOM), 
rispetto ad una classe che una un metodo dichiarato virtual; abstract;
e ridefinendo poi i deriuvati come override;
 
qualcosa di simile
 
   TAnagrafe = class
     public
       function IdentificaSede: string; virtual; abstract;
   end;
 
   TSedeDecentrata = class(TAnagrafe)
     private
       FIdSede: integer;
 
     public
       function IdentificaSede: string; override;
   end;

    end;
 
Le interfacce hanno il vantaggio che una classe ne puo' 
implementare diverse, mentre l'eredita' e' sempre singola:
 
TSedeAmericana = class( TSedeDecentrata, ILinguaInglese, IFusoOrarioDiverso )
 
Inoltre, ma questo vale solo per le interfacce di tipo COM, hai
la possibilta' di interrogare un oggetto per sapere se implementa
un'interfaccia, tramite la funzione Support().
 
Altra cosa, avendo la gestione dei riferimenti, 
le interfacce producono la distruzione automatica degli oggetti, e questo
puo' essere un vantaggio (non devi distruggere tu le cose) ma anche fonte di 
notti insonni di debug quando non capisci da dove diavolo esce un AV! :)
 
ciao
Giacomo
 
 
 
 
 

 rispetto ad una classe che una un metodo dichiarato virtual; abstract;
 
Hai il polimorfismo senza avere troppi livelli di ereditarieta.
 
Tclass1 = class
TClass2 = class(TClass1)
...
TClass5 = class(TClass4)
 
Dono tutte polimorifche rispetto a class1. Pero', hai 5 livelli di ereditarieta.
 
ISexInterface = interface
  function DoSex: integer;
end;
 
TCindyCrawford = class(TAutomationObject, ISexInterface)
...
end;
 
TNaomiCampbell = class(TAutomationObject, ISexInterface)
...
end;
 
TSegretaria906090 =  class(TAutomationObject, ISexInterface)
...
end;
 
TVicinaDiCasa = class(TQualcunoCheConosco, ISexInterface)
...
end;
 
 
Puoi usare queste 4 classi come ISexInterface.
Queste classi non sono gerarchicamente legate da vincoli di ereditarieta.
 
Imho, salvo che non si tratti di componenti visuali, andare oltre i 4 livelli di ereditarieta di classe potrebbe alla lunga ridurre la flessibilita'.
Ma ribadisco: imho.
 
A.

 Puoi usare queste 4 classi come ISexInterface.
Da te Alberto non potevo aspettarmi altro tipo di interfacce ;-)
Marpione..
-- 
morde
Android
QT 4.7
Delphi (5,6,7.. expired)
Firebird Database
 

Detesto i moralismi! :-D
Non ho mai trovao niente di meglio del sesso ne ho mai conosciuto persone a cui non piace fare sesso, donne o uomini che fossero...)! 
 
rotfl!
 
A.

 rotfl!
:-D


 che l'ultima delle mie intenzioni era quella di moralizzare il discorso ;)
 
Ti conosco troppo, bene...
So che tu sei piu marpione di me... ahahahahahahhaha!
 
A.
 

 So che tu sei piu marpione di me... ahahahahahahhaha!
#-)...............


 Marpione..
 
Can che abbaia ... non Morde.
 
(non firmo che č meglio ...)
 
-- 
 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it
 
 
 

 Can che abbaia ... non Morde.
 
 
Sto con le lacrime agli occhi per le risate!
rotfl alla n-esima potenza!
 
 


IDEM!!!!!!!
