Quel est le type de retour d'un constructeur en java?
car nous savons que nous n'avons pas à ajouter de type de retour à un constructeur Java.
class Sample{
.....
Sample(){
........
}
}
dans L'Objectif C, si nous créons un constructeur, il renvoie un pointeur à sa classe. Mais il 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 converti à une méthode qui retourne une référence à sa propre classe??
comme ceci:
class Sample{
.....
Sample Sample(){
........
return this;
}
}
est-ce que le compilateur ajoute un retour tapez une référence à la même classe de constructeur? Ce qui se passe à un constructeur? Une référence pour étudier ça?
EDIT:
en fait, je veux que les réponses soient au niveau du code octet ou au niveau JVM ou même en dessous.
8 réponses
beaucoup ont répondu comment les constructeurs sont définis en Java.
au niveau de la JVM, les initialisateurs statiques et les constructeurs sont des méthodes qui renvoient le vide. Les initialisateurs statiques sont des méthodes statiques, cependant les constructeurs utilisent this et n'ont pas besoin de retourner quoi que ce soit. C'est parce que l'appelant est responsable de la création de l'objet (pas le constructeur)
si vous essayez de créer seulement un objet en code octet sans appeler un constructeur vous obtenir une exception verifyerror. Cependant sur l'oracle JVM vous pouvez utiliser dangereux.allocateInstance () pour créer un objet sans appeler un constructeur,
l'initialiseur statique est appelé <cinit> qui ne prend aucun argument et le constructeur est appelé <init> . Les deux ont un type de retour de vide.
pour la plupart, cela est caché du développeur Java (à moins qu'ils ne génèrent du code octet) cependant la seule fois où vous voyez ces "méthodes" dans stack traces (bien que vous ne pouvez pas voir un type de retour)
bien que les constructeurs soient similaires aux méthodes, ce ne sont pas des méthodes. Elles n'ont pas de type de retour, ne sont pas héritées et ne peuvent pas être cachées ou supplantées par des sous-classes.
Les constructeurs sont invoqués par des expressions de création d'instance de classe (essentiellement, l'utilisation de new ), par l'invocation explicite d'autres constructeurs (en utilisant la syntaxe this(...) ou super(...) ), et par l'opérateur de concaténation de chaîne. Il n'y a pas d'autre moyen d'invoquer un constructeur (en en particulier, ils ne peuvent pas être invoqués comme d'autres méthodes).
Voir l'Article 8.8 du Java Language Specification pour plus d'info.
le constructeur Est converti à une méthode qui retourne une référence à sa propre classe??
Non mais oui, s'il est spécifié de le faire.
est-ce que le compilateur ajoute un renvoi de type a à la même classe au constructeur ??
Non il ne
ce qui arrive à un constructeur??
C'est la méthode qui s'exécute lorsque l'objet est créé. Typiquement, en utilisant le mot-clé "Nouveau". Il peut effectuer une tâche préliminaire, ou retourner quelque chose ou assigner certaines valeurs pendant la construction.
toute référence à l'étude de la présente.??
les Constructeurs sont similaires aux méthodes, sauf qu'ils utilisent le nom de la classe et n'ont pas de type de retour. Le but de l'utilisation de constructors est de créer un objet (une instance d'une classe) et de l'allouer (via le mot-clé new ) dans la mémoire (le tas) et aussi d'initialiser tous les champs disponibles.
les constructeurs sont invoqués via le mot clé java spécial new , qui crée (et initialise) un objet du type concret spécifié.
je suppose qu'on peut 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
le constructeur renvoie la référence de classe de la classe pour laquelle il est appelé.Par exemple:
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);
}
}
ici après avoir appelé le constructeur A(...) , ce constructeur retournera la référence du type de classe A à l'appelant( i.e. A a = new A(4) ).
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;
}
}
n'est utilisé que pour initialiser l'élément de classe et
- le nom du constructeur et le nom de classe sont identiques
- constructeur ne peut pas avoir le type de retour
- Constructeur toujours appelée lorsque l'objet est créé
- constructeur toujours public