Appel Constructor d'un autre constructeur

Question

je veux faire quelque chose comme ça

public class Class1 
    { 
     public Class1() 
     { 

     } 
     public Class1(int a) 
     { 

     } 
    } 
    public class Class2 :Class1 
    { 
     public Class2(int a) 
     { 

     } 
     public Class2(): base(2) 
     { 
     this(2); // new Class2(2); 
     } 

    } 

Je sais que cela ne peut pas être atteint en Java (peut utiliser un entre (super ou cela) dans la première ligne)

Mais d'une manière ou d'une autre, j'ai besoin de ce genre de travail pour y parvenir? Moyens appelant le constructeur paramétré de la classe de base et paramétrée de la classe de base dans le constructeur par défaut de la classe dérivée.

Answer 1

MSDN article sur les constructeurs est assez bon. Voici quelques bits pertinents:

Un constructeur peut utiliser le mot-clé de base pour appeler le constructeur d'une classe de base .
....
Un constructeur peut invoquer un autre constructeur dans le même objet en utilisant ce mot-clé. Comme base, cela peut être utilisé avec ou sans paramètres, et tous les paramètres dans le constructeur sont disponibles en tant que paramètres à cela, ou en tant que partie d'une expression.

Cela devrait fonctionner:

public class Class1 
{ 
    public Class1() 
    { 

    } 
    public Class1(int a) 
    { 

    } 
} 
public class Class2 :Class1 
{ 
    public Class2(int a) : base(a) 
    { 

    } 
    public Class2(): this(2) 
    { 
    } 

} 

Answer 2

La réponse d'Igor est un bel exemple de la façon dont vous devriez écrire les constructeurs dans cette situation. Pour traiter le cas plus général de votre phrase finale: vous ne pouvez pas enchaîner à plus d'un constructeur. Vous ne pouvez pas appeler un constructeur de base et un autre constructeur de la classe en cours.

Il existe deux modèles typiques pour les constructeurs surchargés. Dans le premier modèle, l'ensemble des surcharges de la classe dérivée correspond à peu près à l'ensemble des surcharges de la classe de base - vous essayez de faire croire à la classe dérivée qu'elle a hérité des constructeurs, effectivement. (Les constructeurs eux-mêmes ne sont pas hérités, mais si vous fournissez les mêmes signatures, cela ressemble à l'appelant.) C'est généralement le cas lorsque votre classe dérivée n'a pas besoin d'informations supplémentaires. Bien sûr, chaque constructeur peut avoir des paramètres supplémentaires, et seulement transmettre un sous-ensemble au constructeur de base, mais cela peut commencer à se compliquer. Dans le deuxième modèle, vous avez plusieurs constructeurs dans la classe dérivée, chacun appelant un constructeur "maître" dans la même classe (dérivée). Ce constructeur maître a le plus de paramètres, car il doit être capable de gérer tout spécifié par l'un des autres constructeurs. Parfois, le constructeur principal doit être privé, si certaines combinaisons n'ont pas de sens, mais sont pratiques à spécifier dans un endroit où vous savez que vous ne pouvez atteindre le code via un constructeur public sensible. Dans ce cas, seulement ce constructeur "maître" enchaîne directement au constructeur de la classe de base. Ceci est généralement utilisé lorsque la classe dérivée a plusieurs informations supplémentaires au-delà de ce dont la classe de base a besoin.

Il y a des hybrides de ce modèle où vous avez plusieurs maîtres avec des "groupes" de surcharges qui appellent les maîtres ... mais je vous conseille d'essayer de rester simple quand c'est possible. Pensez également à la possibilité de fournir des méthodes statiques en lieu et place de constructeurs - ce qui peut rendre le code plus lisible car vous pouvez nommer les méthodes par leur fonction/leurs paramètres - voir TimeSpan.FromMinutes par exemple.

Answer 3

C'est impossible dans les deux langues (pour une bonne raison). Sinon, vous appelerez les constructeurs de base plusieurs fois en raison de l'appel de base implicite s'il n'y a pas de base explicite ou de ceci. Cela pourrait conduire à un comportement indésirable.