Discussion :

[poppels]

Bonjour à tous !

J'aimerai bien connaitre les différences fondamentales entre les 2 codes suivants :

1. Code 1
   

   Code :

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

   1
   2
   3
   4
   5
   6
    
   public class maFrame extends JFrame
   {
      //Création complète de la fenêtre maFrame 
      //Et le reste du code ...
   }

2. Code 1
   

   Code :

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

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
    
   public class X
   {
      private JFrame maFrame;
      //Création de la fenêtre
      maFrame = new JFrame();
      //et puis le reste de la fenêtre, par exemple dans une méthode makeFrame()...
    
   //Et le reste du code ...
   }

Quels sont les avantages / inconvénients de l'un par rapport à l'autre ?
Ces 2 méthodes sont-elles équivalentes ? Si pas (ce que je pense...) quelqu'un pourrait-il me donner un exemple de chose faisable avec un code et pas par l'autre ? (c'est surement un exemple de ce type qui pourra m'aider à comprendre la différence fondamentale entre ces 2 choses...)

Merci à tous !

[billynirvana]

Dans la première version tu peux ajouter des fonctionnalités à ceux proposées par la classe JFrame alors que dans le deuxième cas, tu ne peux que les appeler.

[dingoth]

La première s'appelle l'héritage.

La seconde s'appelle l'encapsulation.

P.S. enlève tes blockquotes

[poppels]

Merci pour vos réponses ! (j'ai enlevé les blocquotes )

Je sais qu'il s'agit de l'héritage pour la première, et puis qu'il s'agit d'encapsulation, je rajouterai même qu'il s'agit de composition ... Mais bon ... Ma question (partiellement répondue par "on sait rajouter des fonctionnalités) est : sait-on faire quelque chose avec la première méthode qu'on ne sait pas faire avec la deuxième ? (c'est mon sentiment : faire public class MaFenetre extends JFrame{...} est "plus fort" que public class X{private JFrame maFenetre; ...} , mais j'aimerai avoir une réelle confirmation de cela ... et un exemple pour l'appuyer ...)

Merci à vous !

[EDIT] Et de plus ... Est-ce que l'une ou l'autre méthode de codage est "plus propre" ? Plus conseillée, d'un point de vue clarté du code ? Et d'un point de vue maintenance ?

[sinok]

En général on préfère la délégation (aka composition dans ce cas) , tout simplement car tu n'as aucun besoin de redéfinir le comportement intrinsèque d'une JFrame, so let il live...
L'héritage ne soit être utilisé que si l'on veut ajouter un comportement spécifique à un objet, ou dans le cas où l'on doit faire avec des mécanismes d'abstraction.
Grosso merdo redéfinir une JFrame je n'en vois pas trop l'utilité.
Par contre pour un JComponent celà peut être utile si l'on veut en customiser le rendu (redéfinition des méthode telles que paintComponent ou paintBorder).

Donc si tu n'as pas un besoin impérieux de redéfinir une des méthodes d'un objet, mieux vaut utiliser la délégation

[T`lash]

Je pense que la question c'est : vas-tu utiliser plusieurs instances de ta JFrame dans ton application ?
Et encore dans ce cas tu peux utiliser une méthode qui construit ta fenêtre.

Ensuite, as-tu besoin de différencier ta JFrame parmi d'autres n'ayant pas les mêmes spécificités ? (utilisation du instanceof)