Bonjour, maîtres du café !
J'ai un petit souci de conception

Dans le tutoriel Java de cysboy sur les JFrame, il explique que le code suivant est assez lourd car, si on veut créer plusieurs fenêtres, on doit retaper les mêmes lignes de code à chaque fois :

import javax.swing.JFrame;
 
public class Test {
 
        public static void main(String[] args){
        
                JFrame fenetre = new JFrame();
                
                //Définit un titre pour votre fenêtre
                fenetre.setTitle("Ma première fenêtre java");
                //Définit une taille pour celle-ci ; ici, 400 px de large et 500 px de haut
                fenetre.setSize(400, 500);
                //Nous allons maintenant dire à notre objet de se positionner au centre
                fenetre.setLocationRelativeTo(null);
                //Terminer le processus lorsqu'on clique sur "Fermer"
                fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                
                fenetre.setVisible(true);
        }       
}

Au lieu de ça, on peut créer une nouvelle classe dont le constructeur s'occupera lui-même de créer la fenêtre. Ainsi, il suffira simplement d'appeller le constructeur de cette nouvelle classe plutôt que de retaper à chaque fois le code ci-dessus, ce qui est beaucoup moins lourd que la technique précédente. On a donc :

import javax.swing.JFrame;
 
public class Fenetre extends JFrame{
   
     public Fenetre(){
         //Définit un titre pour votre fenêtre
         this.setTitle("Ma première fenêtre java");
         //Définit une taille pour celle-ci ; ici, 400 px de large et 500 px de haut
         this.setSize(400, 500);
         //Nous allons maintenant dire à notre objet de se positionner au centre
         this.setLocationRelativeTo(null);
         //Ferme-toi lorsqu'on clique sur "Fermer" !
         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
             
         this.setVisible(true);
     }
}

Et c'est là que je coince
J'ai deux questions :

• Pourquoi cette classe doit-elle hériter de JFrame (extends JFrame) alors que la classe Test définie précédemment se contentait simplement d'importer le package ?
• Dans le constructeur de la classe Fenetre, on ne fait pas appel au constructeur JFrame : on utilise directement this.setTitle, etc... Comment fait Java pour comprendre que l'objet qu'on est en train de créer est bien un objet JFrame ? On ne l'a jamais précisé ! Si on avait utilisé un super(), qui apellerait le constructeur de JFrame, je comprendrais... Mais là, on ne précise absolument pas que l'objet Fenetre est... une fenêtre, justement. On se permet d'appliquer des méthodes propres aux fenêtres sur cet objet alors qu'il n'a pas forcément ces propriétés.

Bref, ma question est : pourquoi pas le code suivant ?

import javax.swing.JFrame;
 
public class Fenetre{ // Pas besoin d'hériter de la classe JFrame puisqu'on l'a importée
   
     public Fenetre(){

         super(); // On apelle le constructeur de JFrame pour bien spécifier que l'objet Fenetre est un digne descendant de JFrame

         this.setTitle("Ma première fenêtre java");
         this.setSize(400, 500);
         this.setLocationRelativeTo(null);
         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);             
         this.setVisible(true);
     }
}

Bien sur, comme j'utilise super(), le fait que la classe hérite de JFrame prend tout son sens
Voilà, j'espère que vous pourrez éclaircir ma lanterne

Ha non, tu ne peut pas faire ça, le mot clé super n'est utilisable que si ta classe hérite de JFrame, super() fait appel au constructeur (sans arguments) de la classe mère. (JFrame ici)

Le mot clé this fait référence à l'objet que tu est entrain de créer, c'est à dire ici, ton objet Fenetre.

Mais comme ton objet fenêtre hérite de JFrame, elle possède aussi ses méthodes donc, si Java ne trouve pas la méthode par ex setTitle dans la classe Fenêtre, il ira la rechercher automatiquement dans la classe mère, (JFrame ici) grâce au polymorphisme.

Donc Java n'a pas besoin de super.setTitle("taratata") pour la raison ci dessus.

Si tu ne fait pas hériter ta classe Fenetre de JFrame, ta classe Fenetre ne possèdera pas les méthodes et variables de la classe JFrame, et donc tu sera à chaque fois obligé de créer une JFrame dans le constructeur de ta classe Fenetre, et appelée les méthodes setTitle dessus, hors que tu peut le faire sans créer un objet JFrame grâce au polymorphisme ce qui t'épargne des lignes de code su style :

public class Fenetre {
       public Fenetre () {
           JFrame fenetre = new JFrame ();
           fenetre.setTitle("taratata");
       }
}

Même si ce n'est pas mauvais, ce n'est pas pratique de faire comme cela, mieux vaut utiliser le polymorphisme.

public class Fenetre extends JFrame {
       public Fenetre {
              super (); /*Création d'un JFrame via le constructeur sans argument de la classe JFrame.*/
              this.setTitle("Taratata");
              /*Ajout d'un titre à notre fenêtre, si la méthode setTitle n'est pas présente dans la classe Fenetre, java ira la rechercher dans la classe mère (JFrame) placée après le mot clé extends. (Polymorphisme)*/
}

Maintenant tu te demandes ou est le new JFrame ?
En fait, java crée une JFrame automatiquement dans ta classe Fenetre, c'est le but du mot clé super, et il fait référence à un objet JFrame de ta classe mère.

comme dit précédemment vieux flans (c'est affectueux )

Dans ton premier code, tu créés un objet JFrame
qui est un objet standart de la JVM donc il n'est pas personnalisé comme tu le veux

Je te rappel que tu es dans une methode static
donc qui ne dépend pas du context

donc toutes les lignes

//Définit un titre pour votre fenêtre
                fenetre.setTitle("Ma première fenêtre java");
                //Définit une taille pour celle-ci ; ici, 400 px de large et 500 px de haut
                fenetre.setSize(400, 500);
                //Nous allons maintenant dire à notre objet de se positionner au centre
                fenetre.setLocationRelativeTo(null);
                //Terminer le processus lorsqu'on clique sur "Fermer"
                fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

servent à paramétrer ton objet à dire comment il est ext ext... (mais apres l'avoir créé)

bon apres ça il te dis c'est chiant a faire si tu dois faire pleins de JFrame (et il à bien raison )
alors il créé un nouvel objet qui hérite de JFrame

à la simple différence
que cette fois si c'est ton objet donc dans le constructeur, tu peux l'initialiser comme tu veux et directement lui régler les bon paramètre par la suite (une fois ta class Fenetre écrite) ta class "Test" (donc celle qui contient la méthode main) deviendra :

public class Test {
 
        public static void main(String[] args){
        
                Fenetre fenetre = new Fenetre();
        }       
}

ici tu ne créés plus une JFrame comme dans ta class test précédente cette fois tu créé un Objet Fenetre
mais l'objet Fenetre c'est un objet que tu à créé qui fait la même choses que JFrame
vois tu ?

tu demandes aussi " comment il sait que c'est une JFrame"
ben justement ça n'est plus une JFrame mais un objet qui étend JFrame
donc qui à les mêmes propriétés qui fait la même chose (il hérite de tout de Jframe)
mais c'est un Objet Fenetre que l'on créé
si il n'héritait pas de Jframe, ça ne marcherait pas parce que Fenetre serait un objet banal qui ne "fait rien"

Merci beaucoup pour vos deux réponses, j'ai les idées vachement plus claires ! (nottament grâce à Lolilolight ).

Dernier souci cependant : Le code ci-dessous

public class Fenetre extends JFrame {
       public Fenetre {
              super (); /*Création d'un JFrame via le constructeur sans argument de la classe JFrame.*/
              this.setTitle("Taratata");
              /*Ajout d'un titre à notre fenêtre, si la méthode setTitle n'est pas présente dans la classe Fenetre, java ira la rechercher dans la classe mère (JFrame) placée après le mot clé extends. (Polymorphisme)*/
}

inclut bien le mot-clef super alors que l'exemple de cysboy ne l'inclut pas... Mais comme on a effectivement le droit d'utiliser les méthodes de JFrame (étant donné qu'on hérite de cette classe), peut-être n'est-il pas indispensable...

En tout cas, merci beaucoup, je suis paré pour attaquer la suite

oui ici super() n'est pas indispensable, Java appellera d'office le constructeur par défaut de JFrame si tu ne le mets pas grâce à l'héritage, perso, moi je n'utilise pas la même manière que cisboy, je mets directement un titre à la fenêtre :

public class Fenetre extends JFrame { 
       public Fenetre ()  {
              super ("Taratata");
              //Suite du code.
       }
}

Je trouves que c'est plus simple.

Si je puis me permettre de balancer une petite critique sur le tuto de cysboy (néanmoins je respecte son énorme travail), il mériterait à être perfectionné. Il faut lire la javadoc, les codes des autres, d'autres tutos pour comparer, réapprendre et avoir l'esprit critique.

Bon courage

Je suis du même avis

Merci pour la précision, Lolilolight.

et moi chuis impressionné XD
sur le site du zero XD et même pas sur msn
traitre