web-dev-qa-db-fra.com

Quel est le type de retour d'un constructeur en Java?

Comme nous savons qu'il n'est pas nécessaire d'ajouter de type de retour à un constructeur Java.

class Sample{
  .....
  Sample(){
    ........
  }
}

En Objective C, si nous créons un constructeur, il retourne un pointeur sur sa classe. Mais ce n'est pas obligatoire, je pense.

AClass *anObject = [[AClass alloc] init];//init is the constructor with return type a pointer to AClass

De même, le constructeur est-il converti en une méthode qui renvoie une référence à sa propre classe?

Comme ça:

class Sample{
    .....
    Sample Sample(){
      ........

      return this;
    }
}

Le compilateur ajoute-t-il un retour à une référence à la même classe pour le constructeur?

MODIFIER:

En fait, je veux que les réponses soient au niveau du code octet ou de la machine virtuelle Java ou même au-dessous.

javaconstructorjvmbytecode
15
sonu thomas

Beaucoup ont répondu à la définition des constructeurs en Java. 

Au niveau de la JVM, les initialiseurs et les constructeurs statiques sont des méthodes qui renvoient void. Les initialiseurs statiques sont des méthodes statiques, cependant les constructeurs utilisent this et n'ont pas besoin de renvoyer quoi que ce soit. Ceci est dû au fait que l'appelant est responsable de la création de l'objet (pas du constructeur).

Si vous essayez de créer uniquement un objet en code d'octet sans appeler de constructeur, vous obtenez une VerifyError. Cependant, sur la machine virtuelle Java Oracle, vous pouvez utiliser Unsafe.allocateInstance () pour créer un objet sans appeler de constructeur.

L'initialiseur statique s'appelle <cinit> qui ne prend aucun argument et le constructeur s'appelle <init>. Les deux ont un type de retour vide.

Pour la plupart, ceci est caché du développeur Java (à moins qu'il ne génère du code octet), mais c'est la seule fois que vous voyez ces "méthodes" dans les traces de pile (bien que vous ne voyiez pas de type de retour)

17
Peter Lawrey

Bien que les constructeurs soient similaires aux méthodes, ce ne sont pas des méthodes. Ils n'ont pas de type de retour, ne sont pas hérités et ne peuvent pas être masqués ni remplacés par des sous-classes.

Les constructeurs sont appelés par des expressions de création d'instance de classe (essentiellement, l'utilisation de new), par un appel explicite à partir d'autres constructeurs (à l'aide de la syntaxe this(...) ou super(...)) et par l'opérateur de concaténation de chaînes. Il n'y a pas d'autre moyen d'invoquer un constructeur (en particulier, ils ne peuvent pas être invoqués comme les autres méthodes).

Voir Section 8.8 de la spécification du langage Java pour plus d'informations.

3
Ted Hopp

Le constructeur est-il converti en une méthode qui renvoie une référence à sa propre classe?

Non mais oui, s'il est spécifié de le faire.

Le compilateur ajoute-t-il une valeur de retour à la même classe une référence à la même classe?

Non ce n'est pas

Qu'est-ce qui arrive à un constructeur ??

C'est la méthode qui s'exécute lorsque l'objet est créé. En règle générale, en utilisant "nouveau" mot-clé. Il peut effectuer une tâche préliminaire, renvoyer quelque chose ou assigner des valeurs lors de la construction.

Toute référence pour étudier cela.

3
Starx

Les constructeurs sont similaires aux méthodes, sauf qu'ils utilisent le nom de la classe et n'ont aucun type de retour. L'utilisation de constructeurs a pour seul objectif de créer un objet (une instance d'une classe) et de l'allouer (via le mot clé new) dans la mémoire (le segment de mémoire) et d'initialiser les champs éventuels.

2
Eng.Fouad

Les constructeurs sont appelés via le mot clé spécial Java new, qui crée (et initialise) un objet du type concret spécifié.

Je suppose que vous pourriez dire que la combinaison de new et du constructeur choisi "retourne" un objet, qui en Java est bien sûr un pointeur sous les couvertures

1
Bohemian

Le type de retour du constructeur est le type de classe correspondant.

package com.ie.test;
import Java.lang.reflect.*;

public class a {
    public  a() {
        super();
        System.out.println("*** no-arg constructor ***");
    }

    public static void main(String[] args) {

        Constructor[] constructors =  a.class.getConstructors();

        for (Constructor constructor:constructors) {

            int i =  constructor.getModifiers();
            AnnotatedType annotatedType =  constructor.getAnnotatedReturnType();
            System.out.println("***********Returntype *******"+annotatedType.getType());
            System.out.println("*******constructor *****"+Modifier.toString(i));
        }

        Method[] methods =  a.class.getDeclaredMethods();

        for (Method method:methods) {
            int i =  method.getModifiers();
            //  Class c =  method.getReturnType();
            AnnotatedType annotatedType =  method.getAnnotatedReturnType();
            System.out.println("***********Returntype *******"+annotatedType.getType());
            //   System.out.println(c);
            System.out.println("*******methods*******"+Modifier.toString(i));
        }
    }

    public int m1() {
        System.out.println("***************");
        return 0;
    }
}
0
Venkat IndianEagle

Le constructeur retourne la référence de classe de la classe pour laquelle il s'appelle.E.g.-

class A {
    int x;
    A(int a) {
        x = a;
    }
}
class B {
    public static void main(String asd[]) {
        A a = new A(4);
        System.out.println(a);
    }
}

Après avoir appelé le constructeur A(...), ce constructeur retournera la référence du type de la classe A à l'appelant (c'est-à-dire A a = new A(4)).

0
vikasa