Bonjour, je voulais savoir si en POO on était obligé d'écrire à chaque fois:

public Ville(){
          System.out.println("Création d'une ville !");          
          nomVille = "Inconnu";
          nomPays = "Inconnu";
          nbreHabitant = 0;
  }
 
  /**
   * Constructeur d'initialisation
   * @param pNom 
   *                    Nom de la Ville
   *  @param pNbre
   *                    Nombre d'habitants
   *  @param pPays
   *                    Nom du pays
   */
  public Ville(String pNom, int pNbre, String pPays)
  {
          System.out.println("Création d'une ville avec des paramètres !");     
          nomVille = pNom;
          nomPays = pPays;
          nbreHabitant = pNbre;
  }

comme dans le cours, ou est ce qu'on peut simplement écrire:

public Ville(String pNom, int pNbre, String pPays)
  {
          System.out.println("Création d'une ville avec des paramètres !");     
          nomVille = pNom;
          nomPays = pPays;
          nbreHabitant = pNbre;
  }

Dans le sens strict, obligé : non.
Le constructeur sans paramètre s'appelle constructeur par défaut, et globalement on le met si on en a besoin tout simplement.

Dans quel cas on peut en avoir besoin en fait? Je n'ai pas vraiment compris sont utilité.

Ben par exemple, une personne va se faire faire son costume par son tailleur habituel (le tailleur est le constructeur). La personne commande une robe simple le tailleur va lui en faire une simple ! (autrement dit on demande au constructeur une robe par défaut). Mais il peut arriver que la personne ait envie de personnaliser sa robe (ce qui revient à spécifier des paramètres dans un constructeur). Dans ce cas le tailleur cherche dans son savoir-faire comment faire la robe désirée (id est la JVM saura quel constructeur appeler si on lui passe des paramètres).

MMmmm, ouai je vois à peu près ok ok

Cela va au-delà de ça. Avoir un constructeur sans argument va permettre la réutilisation du code. Effectivement, j'écris ma classe A qui fournit X fonctionnalités. Puis plus tard, une autre personne va utiliser ma classe A et lui fournir de nouvelles fonctionnalités. Il va donc créer une classe B qui hérite de la classe A. Maintenant, il faut savoir qu'en java le constructeur de la classe dérivée doit prendre en charge l'intégralité de la construction de l'objet. Comment s'assurer qu'un objet sera bien construit ? Faire appel à l'instruction super(). Cette instruction doit être la première instruction si l'on fait appel au constructeur de la classe supérieure. l'instruction super() va faire appel au constructeur sans argument de la classe supérieure.

Ainsi, si je ne connais pas l'implémentation de ma super classe (de la classe que j'hérite), cela me permet de m'assurer que l'objet X sera correctement initialisé avec une simple instruction super() si la classe a été correctement construite.

De plus, cela fait parti des recommandations d'avoir une classe possédant au moins un constructeur sans argument.

en plus ça facilite les tests
avoir une class qui s'initialise avec des valeurs par défaut

Citation : elmh

Dans le sens strict, obligé : non.
Le constructeur sans paramètre s'appelle constructeur par défaut, et globalement on le met si on en a besoin tout simplement.

Ce n'est pas exactement ça, le constructeur par défaut est celui crée implicitement par le compilateur lorsqu'on ne déclare aucun constructeur, celui ci va par défaut appeler le constructeur sans argument de la classe parent(alors attention si la classe parent n'a pas de constructeur no arg visible). Si tu ajoutes un constructeur, même sans paramètre il n'y plus de constructeur par défaut.

Certains framework par exemple ont besoin de classes avec soit un constructeur par défaut, soit un constructeur sans paramètre(pour diverses raisons), et donc tu es obligé d'ajouter un constructeur sans paramètre si tu en as déclaré avec des paramètres.

Dod, j'ai à peu près tout compris sauf à partir de l'explication de "super()", pourrais tu me donner un petit exemple et me l'expliquer pour m'éclairer?

hé bien
imaginon que je fais une class "homme"
et une class secretaire qui étend ou impléménte "homme"

public class Homme{
  int nombredePied;
  int nombredeMAin;
  int nombrededoigts;

 public Homme(){

    nombredePied=2;
    nombredeMAin=2;
    nombrededoigts=10;
  }
}

public class Secretaire extends Homme{
 int nombredheuredetravailparsemaine;
  public Secretaire(){
    super();//initialisation de :  Pied, Main,Doigts
    nombredheuredetravailparsemaine=35;
   }
}

voili voilà un exemple d'utilisation si tu fais

"new Secretaire", tu auras toutes les variables Hommes qui seront initialisées normalement et puis le nombre d'heure sera a 35

Mais que fait "super()" ici précisément?
Il permet de modifier le constructeur "Homme" en ajoutant le nombre d'heures de travail?

Ben un secrétaire homme est avant tout un homme. Donc quand on construit un secrétaire homme, on construit d'abord un homme (d'où l'appel du constructeur par défaut de la classe homme grâce au mot-clé "super"), puis comme on construit un secrétaire, on va lui fixer ses attributs de secrétaire.

Oui je sais mais je veux juste savoir préciser ce que fait le mot-clé "super()"?
Il appel le constructeur dans la classe Secretaire pour ensuite y ajouter un paramètre (nombre d'heures)?

non -_-' il fait l'inverse °_0 il est dans le constructeur de la class Secrétaire =/
et il appel le constructeur de la class Homme =/

pour initialiser les variable Pied,Main,Doigts du secrétaire =/

Oui dsl c'est ce que je voulais dire...donc dans le constructeur "public Secretaire()" on amène, en quelque sorte, les paramètres du constructeur "public Homme()" avec "super()" puis on rajoute un paramètre.
Je pense avoir bien compris, si j'ai dit une erreur dites-le moi.

Evite de dire les paramètres, y'a des mots pour décrire ça.
Paramètre, c'est ce que tu passes à une méthode pour travailler ; ici je pense que tu voulais dire champ d'instance.

Je ne peux pas faire plus simple que dire super() appelle le constructeur par défaut de la classe Homme. Mais apparemment tu as compris ^^'
J'ignore comment ça se passe en mémoire lors d'un héritage mais bon.
Dans le constructeur de Secretaire, tu appelles le constructeur de Homme. Et si dans le constructeur de Homme on affecte des valeurs à des variables, ben tu les récupères en construisant un Secretaire.

Et comment on change par exemple "nombredePied" si on veut une secrétaire à 5 pieds? on met "super()" et on ajoute en dessous "nombredePied = 5"?

Ben ça dépend. Mais je vais encore introduire de nouvelles notions si je t'explique...

Si tu as un constructeur dans la classe Homme qui change le nombre de pieds, tu peux l'appeler.

Admettons t'as le code suivant :

public class Homme{
  int nombredePied;
  int nombredeMAin;
  int nombrededoigts;

 public Homme(){

    nombredePied=2;
    nombredeMAin=2;
    nombrededoigts=10;
  }
  public Homme(int nbreDePieds){
    nombreDePied = nbreDePieds;
    nombredeMAin=2;
    nombrededoigts=10;
}

Alors là dans Secretaire tu peux faire :

public class Secretaire extends Homme{
 int nombredheuredetravailparsemaine;
  public Secretaire(){
    super(5);//initialisation de : 5 Pieds, Main, Doigts
    nombredheuredetravailparsemaine=35;
   }
}

Sinon, tu peux construire une Secrétaire avec super() (et donc un Secretaire avec 2 pieds) et faire this.nombredePied = 5 (si nombreDePied est public ou protected) ou this.setNombreDePied(5) (si nombreDePied est private et qu'il y'a un setter déclaré dans la class Homme.
N.B. Si tu ne comprend pas le this, retire-le c'est pareil.

Le mot-clé super() permet de faire référence à la classe parente. Si tu mets un paramètre dans le super, la JVM ira chercher le constructeur avec le même nombre et types de paramètres (par exemple si t'écris super(5), la JVM ira chercher un constructeur dans la classe Homme avec un seul paramètre de type int. S'il y'a deux tels constructeurs dans la classe Homme, ça ne compilera pas).

Ok, ok je comprends...merci beaucoup
Juste une chose, si j'initialise nombredePied à 0 pour le constructeur "Homme", est ce que je peux ensuite utiliser le "this.nombredePied = 5" pour la Secrétaire?

bien sur
mais bin en général, on commence par faire un constructeur qui prend pleins de paramètres
et on initialise directement à 5

Youhou! lol Ok
Merciiiiiiiiiiiiiiiii

par contre °_0 ta secrétaire est une extra terrestre ?
(et ton homme d'office manchot)

C'était pour l'exemple mais pour être franc, oui, ma secrétaire à 5 pieds...

ha tu habite pluton ?
tu m'emmènes ?

Dans cet exemple, ne faudrait-il pas utiliser extends Homme au lieu de implements Homme étant donné que la classe Homme n'est pas une interface (qui n'est pas instanciable) ?

euh oui y'a une erreur, j'ai même pas fait gaffe ^^'

a dire vraix moi non plus
je vais modifier ça

Citation : Poipoi

Dans cet exemple, ne faudrait-il pas utiliser extends Homme au lieu de implements Homme étant donné que la classe Homme n'est pas une interface (qui n'est pas instanciable) ?

On peut instancier un type d'interface (ou abstract class) en lui fournissant une implémentation à la volée (anonymous inner class).

Un exemple avec Runnable:

Runnable myRunnable = new Runnable() {
    public void run() {
        doSomething();
    }
}
myRunnable.run();

Ouai, je sais pas, j'ai aps encore compris les interfaces, je suis déjà doucement en train de comprendre les classes abstraites

Citation : elmh

J'ignore comment ça se passe en mémoire lors d'un héritage mais bon.

Situation : classe A puis classe B qui hérite de A.

Lorsqu'il s'agit d'une classe simple, les étapes réalisées lors de la compilation sont les suivantes :
- Allocation mémoire pour tous les champs de la classe A.
- Initialisation implicite (exemple : int a = 0, String f = null)
- Initialisation explicite (exemple : int a = 89)
- Exécution des instructions du constructeur.

Lorsqu'il s'agit d'une classe qui hérite (B extends A) :
- Allocation mémoire pour l'intégralité des champs (B et A).
- Initialisation implicite de l'intégralité des champs (B et A).
- Initialisation explicite des champs de A.
- Exécution des instructions du constructeur de A.
- Initialisation explicite des champs de B
- Exécution des instructions du constructeur de B.

De cette manière, il n'y aura aucun problème en cas d'appel explicite du constructeur de la classe supérieure puisqu'il est connu.