Bonjour à tous,
 
Je sais bien qu'en Java, on ne peut pas hériter du constructeur d'une classe mère.
Si la classe mère A a 5 surcharges de constructeurs (avec des paramètres différents), ensuite la classe fille B qui hérite de A n'aura pas ses constructeurs utilisables.
Si je fais: new A(param1, param2),
Je ne pourrai pas faire: new B(param1, param2)
Je devrai à chaque fois redéfinir le constructeur de A dans B (ce qui est lourd...).
 
Et attention, je sais que je peux redéfinir les attributs de A grâce au mot clef super !!! Là n'est pas ma question !!!
 
Ma question est clairement : "Pourquoi les concepteurs de Java n'ont pas autorisés l'héritage de constructeur ?"  
Je cherche ces informations pour un exposé.
 
D'avance merci pour vos réponses.  
 
ps: comme ce n'est pas le seul forum auquel je m'adresse :
1. Si c'est pour me dire que ce n'est pas possible d'hériter du constructeur mais seulement des méthodes, merci, je sais... une fois de plus, là n'est pas ma question
2. Je suis au courant pour le mot-clef super... idem point 1 !!!
3. Google est mon ami mais n'est pas capable de me donner ma réponse ! Il sait juste me dire ce que je sais déjà (à savoir les points 1 et 2...)
4. Sincèrement merci si vous avez une réponse qui peut m'aider

 
Je ne suis pas de cet avis, ou alors tu veux dire autre chose.
Code très simple et bâclé :
 
public class A {
public A()
{
    System.out.println("A" );
}
}
 
public class B extends A {
public B()
{
    System.out.println("B" );
}
}
 
public class Test {
    public static void main(String[] args) {
 new Test();
    }
    public Test()
    {
 new B();
    }
}
 
On lance "Test" et on voit bien :
A
B
 
Donc le constructeur de A est AUSSI appelé implicitement grâce à l'héritage. Tu voudrais quoi ? Fais le code de ce que tu voudrais faire et donne le résultat attendu même si ça ne compile pas.

Je vois bien le besoin et langue au chat.
Pour info, C++0x va fournir ça comme fonctionnalité.

bugbreeder, dans l'exemple que tu me montres là, ta classe B appelle le constructeur par défaut de A. Cependant, tu n'hérites pas du constructeur. Essaye de surcharger ton constructeur et n'utilises pas le mot-clef super. Tu verras que ton compilo gueulera...

Si on prend le code suivant :
 

 
Maintenant, imaginons que l'héritage de constructeur soit possible, on devrait pouvoir appeler le constructeur de A qui prend un int en argument. Problème : le champ "titi" de B ne sera pas initialisé dans ce cas. Comme il est déclaré "final", ça devra casser à la compilation. On devra donc explicitement surcharger le constructeur, le déclarer "private" (parce qu'on n'en a pas besoin) et initialiser titi avec une valeur bidon. Ça complique beaucoup pour rien. Et si dans le futur, A est changée pour ajouter encore un constructeur, il faudra aller le surcharger explicitement dans B. Lourd...