Peut-on avoir un type de retour pour un constructeur en Java?

Le code suivant donne une erreur de compilation:

class parent {
  parent(int a){}
}

class child extends parent{}

Erreur:

Main.java:6: cannot find symbol
symbol  : constructor parent()
location: class parent
class child extends parent{}
^
1 error

J'ai essayé de faire des choses différentes, et a constaté que l'ajout d'un type de retour pour le constructeur parent se débarrasser de l'erreur!!!

class parent {
  int parent(int a){}
}

class child extends parent{}

J'ai lu que les constructeurs ne devraient pas avoir de type de retour, qui, clairement, n'est pas correct de tous les temps. Donc ma question est de savoir quand doit-on avoir le type de retour pour le constructeur?

source d'informationauteur user421814

18

Sur le constructeur n'ayant pas de type de retour

Constructeur ne doit pas avoir un type de retour. Par définition, si une méthode a un type de retour, ce n'est pas un constructeur.

JLS 8.8 Constructeur Déclarations

Un constructeur est utilisé dans la création d'un objet est une instance d'une classe. [Le nom doit correspondre au nom de la classe, mais, à tous autres égards, le constructeur déclaration ressemble à une déclaration de méthode qui n'a pas de type de résultat.

Sur les constructeurs par défaut

L'extrait suivant donne une erreur de compilation:
```
class Parent {
   Parent(int a){}
}

class Child extends Parent{

   //DOES NOT COMPILE!!
   //Implicit super constructor parent() is undefined for default constructor.
   //Must define an explicit constructor

}
```
La raison n'est pas à cause d'un type de retour dans un constructeur, mais parce que, puisque vous n'avez pas à fournir TOUT constructeur de Childun par défaut constructeur est automatiquement créé pour vous par le compilateur. Cependant, ce constructeur par défaut essaie d'appeler le constructeur par défaut de la classe mère Parentqui ne PAS avoir un constructeur par défaut. C'EST la source fo l'erreur de compilation.

Voici les spécifications du constructeur par défaut:
JLS 8.8.9 Constructeur par Défaut

Si une classe contient aucun constructeur déclarations, puis un constructeur par défaut qui ne prend pas de paramètres est automatiquement fourni:
- Si la classe d'être déclaré est le premier de la classe Objectpuis le constructeur par défaut est vide corps.
- Autrement, le constructeur par défaut ne prend aucun paramètre et appelle simplement la superclasse constructeur sans arguments.
La suite est une solution simple:
```
class Parent {
   Parent(int a){}
}

class Child extends Parent{

   //compiles fine!
   Child() {
      super(42);
   }

}
```
Sur les méthodes ayant le même nom que le constructeur

L'extrait de code suivant NE compiler:
```
//COMPILES FINE!!

class Parent  {

   //method has same name as class, but not a constructor
   int Parent(int a) {
      System.out.println("Yipppee!!!");
      return 42;
   }

   //no explicit constructor, so default constructor is provided
}

class Child extends Parent {

   //no explicit constructor, so default constructor is provided

}
```
Il est en fait aucun constructeur explicite dans l'extrait ci-dessus. Ce que vous avez est une méthode qui a le même nom que la classe. C'est autorisé, mais déconseillé:

JLS 8.4 des Déclarations de Méthode de

Un class peut déclarer une méthode avec le même nom que le class ou d'un champ, membre class ou membre interface de la classe, mais cela est déconseillé comme une question de style.

Vous trouverez que si vous créez un new Parent() ou un new Child()"Yipppee!!!" sera PAS être affichés sur la sortie standard. La méthode n'est pas appelée lors de la création puisqu'il n'est pas un constructeur.
29

Dans cas 1 l'enfant de la classe n'a pas de constructeur de sorte que le compilateur ajoute un constructeur par défaut pour vous et ajoute également un appel au constructeur de la superclasse. Si votre enfant en classe de manière efficace ressemble:
```
class child extends parent {
 child() {
  super();
 }
}
```
l'appel super() recherche un zéro argument du constructeur de la classe de base, puisqu'il n'y a pas de tel constructeur, vous obtenez le message d'erreur.

Dans cas 2 parent parent de la classe n'a pas de constructeur

int parent(int x) {} est pas un constructeur, car il a un type de retour. C'est juste une méthode qui a le nom de la classe. L'enfant de la classe n'a pas de constructeur. Ainsi, le compilateur ajoute constructeur par défaut pour les enfants et les parents et ajoute également appel à super constructeur de la classe:
```
class parent {
 parent() {
  super(); //calls Object class ctor.
 }
  int parent(int x) {} //not a ctor.
}

class child extends parent {
 child() {
  super();
 }
}
```
4
- lorsque vous étendez une classe qui ne possède pas de constructeur par défaut, vous devez fournir un constructeur qui appelle qui superconstructor - c'est pourquoi l'erreur de compilation, qui est:
Implicite super constructeur parent() n'est pas défini pour le constructeur par défaut. Devez définir explicitement un constructeur
- lorsque vous ajoutez un type de retour, ce n'est plus un constructeur, c'est une méthode, et le ci-dessus ne s'applique pas
À l'avenir de lire les messages d'erreur de la première, et d'essayer à la raison (ou trouver) ce qu'il implique.
2

Constructeurs ne pas avoir un type de retour. Les constructeurs sont appelés à créer une instance de ce type. Essentiellement ce qui est "retourné" à partir d'un constructeur est une instance de ce type de prêt pour l'utilisation.
2

les constructeurs ne sont pas de type de retour

essayez de la remplacer par:

class parent 
{
parent(int a){}
}

class child extends parent
{
  child(int a){
    super(a);
  }
}

1

Techniquement, vous n'avez pas ajouter un type de retour pour le constructeur, mais il a changé le constructeur dans une méthode qui vient de se passer d'être du même nom que la classe. Ce que vous devriez avoir fait appel super(int)donc:
```
class parent 
{
parent(int a){}
}

class child extends parent{ child(int a){ super(a); } }
```
Votre code pour child implicitement essaie de le faire:
```
class child extends parent{ child(){ super(); } }
```
Qui est, il tente d'appeler un zéro argument du constructeur dans parentqui ne peuvent évidemment pas être fait comme il n'a qu'un seul constructeur, qui prend un int argument.
1

Déjà répondu par codaddict mais deux commentaires.
Par le code java de la convention de classes commencent par une majuscule (il est également utile d'ajouter le modificateur).
Si vous avez d'erreur de compilation, puis le mettre, tous dur le cas ici était clair sans elle.
0

Tout ce que vous avez fait par l'ajout l'int est de transformer le "constructeur" dans une méthode qui a de visibilité par défaut et ensuite parce que vous n'avez pas spécifié un constructeur, il suffit d'ajouter un constructeur par défaut pour vous au moment de la compilation.

Si vous voulez le compiler, vous devrez spécifier un constructeur par défaut, qui est ce que la classe Enfant est à la recherche d', tels que:
```
  class parent 
    {
      parent(int a){}

      parent(){}
    }

class child extends parent{}
```
0

1) Il est préférable de commencer les cours avec une lettre majuscule, et les méthodes avec un lowr cas lettre.

2) Lorsque vous ne créez pas un Constructeur pour une classe, il a un défaut constructeur vide.

3) Lors de l'héritage d'une classe, vous devez remplacer au moins l'un de ses constructeurs, et si vous ne spécifiez pas, vous héritent automatiquement le constructeur vide.

Le code que vous avez soumises si l'enfant a un constructeur d'appel super(int i)si la classe mère n'avait pas de constructeur (alors qu'il aurait le vide par défaut constructeur) ou si la classe parent spécifiquement mis en œuvre le constructeur vide.

Cela fonctionne.
```
public class Parent {
    public Parent(int i) { }
    public Parent() { }
}

public class Child {
}
```
Le vide de la classe Enfant se comporte comme si elle était écrite comme ceci:
```
public class Child {
    public Child() {
        super();
    }
}
```
0

Les constructeurs n'ont pas de type de retour.Constructeur retourne une instance de ce type.Le constructeur doit avoir le même nom que la classe.

Vous devez vous connecter pour publier un commentaire.

Sur le constructeur n'ayant pas de type de retour

JLS 8.8 Constructeur Déclarations

Sur les constructeurs par défaut

JLS 8.8.9 Constructeur par Défaut

Sur les méthodes ayant le même nom que le constructeur

JLS 8.4 des Déclarations de Méthode de