Discussion :

[rvzip64]

Salut tout le monde,

J'ai plusieurs class avec des hértiages différents qui n'ont aucun parent en commun et je voudrais pourtant qu'elles disposent toutes de la meme méthode.


Comment dois je faire ?

[Andnotor]

En POO traditionnelle, c'est malheureusement impossible.

Il faudrait retrouver la méthode par RTTI ou éventuellement utiliser une Interface. (D'autres que moi seront plus à même de te donner plus d'indications. So stay tune. )

[rvzip64]

Merci quand meme Andnotor

[Paul TOTH]

Salut tout le monde,

J'ai plusieurs class avec des hértiages différents qui n'ont aucun parent en commun et je voudrais pourtant qu'elles disposent toutes de la meme méthode.


Comment dois je faire ?

tout dépend de ce que tu entends pas là...

j'aurais tendance à répondre qu'en effet il n'est pas possible de définir une méthode commune à toutes ces classes...mais il reste possible de définir des choses communes...comme une interface par exemple.

[rvzip64]

Tu as un exemple simple d'utilisation d'interface ?

[Paul TOTH]

oui

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
type
 IMonInterface=interface
  procedure MaMethode;
 end;
 
 TMonButton=class(TButton, IMonInterface)
  procedure MaMethode;
 end;
 
 TMaClasse=class(TMonAncetre, IMonInterface)
  procedure MaMethode;
 end;
 
procedure FaireQuelqueChose(AMonInterface : IMonInterface);
begin
  AMonInterface.MaMethode;
end;
 
var
 MonButton : TMonButton;
 MaClasse : TMaClasse;
begin
  MonButton := TMonButton.Create(nil);
  MaClasse := TMaClasse.Create;
  FaireQuelqueChose(MonBouton);
  FaireQuelqueChose(MaClasse);
end;

attention cependant si l'objet ne supporte aucune interface IUknown sera réclamée en plus de IMonInterface

et si tu ne veux pouvoir travailler sur une classe sans la dériver, tu peux toujours créer une classe supplémentaire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
type
 TButtonInterface=class(TInterfacedObject, IMonInterface)
 private
  FButton : TButton;
  procedure MaMethode;
 public
  constructor Create(AButton : TButton);
 end;
 
var
 ButtonInterface : TButtonInterface;
begin
 ButtonInterface := TButtonInterface(Button1);
 FaireQuelquechose(ButtonInterface);
end;

[rvzip64]

En gros ça veut dire que l'interface définit un ensemble de méthode, mais est ce que je peux faire ça ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
type
 IMonInterface=interface
  procedure MaMethode;
 end;
 
 
procedure IMonInterface.mamethode;
begin
   showmessage('salut');
end;

[Paul TOTH]

non !

l'interface (comme pour une unité) ne produit aucun code, c'est jusque la déclaration des méthodes.

pour mettre du code, il faut un objet qui implémente l'interface (comme la partie implémentation d'une unité).

[rvzip64]

ok donc dans tous les cas je vais etre obligé de dupliquer le code de ma fonction dans chacun de mes objets.

[Aos]

A moins que tu fasses une classe abstraite parent a toute tes classes avec uniquement ta procedure.

[rvzip64]

C'est pas possible j'hérite de différentes classes présentent dans delphi

[Kaféine]

Salut,

Salut tout le monde,

J'ai plusieurs class avec des hértiages différents qui n'ont aucun parent en commun et je voudrais pourtant qu'elles disposent toutes de la meme méthode.


Comment dois je faire ?

A mon avis ça depend du traitement que la méthode effectue.
1) si elle manipule des données de l'instance de la classe alors l'utilisation des interfaces s'impose
2) dans le cas contraire, il suffit de creer une classe utilitaire, ou peut être un class helper (ne maitrisant pas ce dernier)

[Aka Guymelef]

ok donc dans tous les cas je vais etre obligé de dupliquer le code de ma fonction dans chacun de mes objets.

Pas forcément je dirais. Cela dépend en fait surtout de ce que fais cette méthode commune.

Si tu peux résumer cette méthode à une routine simple alors dans toutes les implémentations de l'interface dans tes divers objets tu te contente de faire appel à la routine.

Ton code est ainsi centralisé dans ta routine, c'est juste qu'il y a autant d'appels que de classe qui implémente ta méthode commune en fait.

[Andnotor]

Il s'agit plus d'un question à Paul qu'une réponse supplémentaire (j'apprends en même temps ), mais ça pourrait faire avancer le Schmilblick.

Est-ce que l'interface accepte un record (Ou plus généralement une variable) ?
Les records acceptant des procédures/fonctions depuis D2007 (je crois), est-ce que quelque chose comme cela est envisageable ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
type
  TMonRecord = record
    procedure MaMethode;
  end;
 
  IMonInterface=interface
    MonRecord :TMonRecord;
  end;
 
  TMaClasse=class(TMonAncetre, IMonInterface)
    ...
  end;
 
  procedure TMonRecord.maMethode;
  begin
    showmessage('salut');
  end;
 
  procedure FaireQuelqueChose(AMonInterface : IMonInterface);
  begin
    AMonInterface.MonRecord.MaMethode;
  end;

[Aka Guymelef]

Non car tu ne peux pas définir de champs dans une interface, tu peux (dans les versions récentes de Delphi) définir des propriétés à implémenter mais pas des champs.

Une interface ça n'est qu'un squelette (on parle aussi de contrat) pour les classes qui implémenterons cette interface.

[Paul TOTH]

ok donc dans tous les cas je vais etre obligé de dupliquer le code de ma fonction dans chacun de mes objets.

de façon général ... oui

prenons un exemple; voici deux objets qui possèdent une propriété Text de type string. Admettons que je veuille pouvoir passer se texte en majuscule...je pourrais définir un méthode ToUppercase() qui se charge de le faire, et désirer pour l'invoquer dans une boucle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
type
  TMonObjet1=object
    num1 : Integer;
    num2 : Integer;
    Text  : string;
  end;
 
  TMonObjet2=object
    data1 : String;
    Text  : string;
  end;
 
var
  list : TList;
  i : Integer;
begin
  list := TList.Create;
  list.Add(TMonObjet1.Create);
  list.Add(TMonObjet2.Create);
  for i := 0 to Pred(list.count)
   T???(List[i]).ToUpper();
end;

voila le problème, j'ai des objets différents dans une liste, je veux effectuer un même traitement...comment faire ?

[NB: il y a peut-être une solution avec les ClassHelper, mais je n'ai jamais exploré cela puisque je me suis arrêté à Delphi 7 ]

Le premier constat est qu'il est "impossible" d'avoir un même code qui fera le traitement pour les deux classes.

Voici une première façon de traiter le problème :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
type
 TUpperObject = class
  procedure ToUpper(); virtual; abstract;
 end;
 
 TMonObjet1Upper = class (TUpperObject)
 private
  FObject : TObject1;
 public
  constructor Create(AObject : TObject1);
  procedure ToUpper(); override;
 end;
 
constructor TMonObjet1Upper.Create(AObject: TObject1);
begin
  FObject := AObject;
end;
 
procedure TMonObject1Upper.ToUpper();
begin
  FObject.Text := UpperCase(FObject.Text);
end;
 
type
 TMonObjet2Upper = class (TUpperObject)
 private
  FObject : TObject2;
 public
  constructor Create(AObject : TObject2);
  procedure ToUpper(); override;
 end;
 
constructor TMonObjet2Upper.Create(AObject: TObject2);
begin
  FObject := AObject;
end;
 
procedure TMonObject2Upper.ToUpper();
begin
  FObject.Text := UpperCase(FObject.Text);
end;
 
var
  list : TList;
  i : Integer;
begin
  list := TList.Create;
  list.Add(TMonObject1Upper.Create(TMonObjet1.Create));
  list.Add(TMonObject2Upper.Create(TMonObjet2.Create));
  for i := 0 to Pred(list.count)
   TUpperObject(List[i]).ToUpper();
end;

[NB: les classes génériques trouvent ici un usage tout indiqué...bien que ma version de Delphi... ]

Et une autre approche :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
type
 IUpperInterface = interface
  procedure ToUpper(); 
 end;
 
 TMonObjet1Upper = class (TMonObjet1, IUpperInterface)
  procedure ToUpper(); 
 end;
 
procedure TMonObject1Upper.ToUpper();
begin
  Text := UpperCase(Text);
end;
 
type
 TMonObjet2Upper = class (TMonObjet2, IUpperInterface)
  procedure ToUpper(); 
 end;
 
procedure TMonObject2Upper.ToUpper();
begin
  Text := UpperCase(Text);
end;
 
var
  list : TList;
  i : Integer;
begin
  list := TList.Create;
  list.Add(TMonObjet1Upper.Create);
  list.Add(TMonObjet2Upper.Create);
  for i := 0 to Pred(list.count)
   IUpperInterface(List[i]).ToUpper();
end;

dans le premier cas, on a une classe qui chapeaute le tout et qui peut très bien avoir des variables internes et même avoir un ancêtre commun...de l'autre on demande à la classe de posséder l'ensemble des méthodes de l'interface afin de pouvoir les invoquer dans un regroupement homogène