Le constructeur est-il prioritaire?
Ce que je sais, c'est que le compilateur écrit un constructeur par défaut sans argument dans le code d'octet. Mais si nous l'écrivons nous-mêmes, ce constructeur est appelé automatiquement. Ce phénomène est-il un constructeur primordial?
Ce que vous décrivez n'est pas primordial. Si vous ne spécifiez pas de constructeur par défaut, le compilateur créera un constructeur par défaut. S'il s'agit d'une sous-classe, elle appellera le constructeur parent par défaut ( super () ), elle initialisera également toutes les variables d'instance à une valeur par défaut déterminée par la valeur par défaut du type (0 pour les types numériques, false pour booléens, ou null pour les objets).
La substitution se produit lorsqu'une sous-classe a le même nom, le même nombre/type de paramètres et le même type de retour qu'une méthode d'instance de la superclasse. Dans ce cas, la sous-classe remplacera la méthode de la superclasse. Informations sur le remplacement ici .
Les constructeurs ne sont pas des méthodes normales et ils ne peuvent pas être "remplacés". Dire qu'un constructeur peut être surchargé impliquerait qu'un constructeur de superclasse serait visible et pourrait être appelé pour créer une instance d'une sous-classe. Ce n'est pas vrai ... une sous-classe n'a pas de constructeur par défaut (sauf un constructeur sans argument si la classe qu'elle étend en a un). Il doit déclarer explicitement tout autre constructeur, et ces constructeurs lui appartiennent et non à sa superclasse, même s'ils prennent les mêmes paramètres que les constructeurs de la superclasse.
Les choses que vous mentionnez sur les constructeurs par défaut no arg ne sont qu'un aspect du fonctionnement des constructeurs et n'ont rien à voir avec le remplacement.
Ce n'est jamais possible. Le remplacement du constructeur n'est jamais possible en Java.
Ceci est dû au fait,
Le constructeur ressemble à une méthode mais le nom doit être un nom de classe et aucune valeur de retour.
Overriding signifie ce que nous avons déclaré dans la classe Super, que nous devons déclarer exactement dans la sous-classe, il est appelé Overriding. Les noms de super classe et de sous-classe sont différents.
Si vous essayez d'écrire le constructeur de la classe Super dans la classe Sub, la classe Sub traitera cela comme une méthode et non comme un constructeur car le nom ne doit pas correspondre au nom de la classe Sub. Et cela donnera une erreur de compilation que les méthodes n'ont pas de valeur de retour. Nous devons donc déclarer nul, alors seulement il compilera.
Jetez un œil au code suivant:
Class One
{
....
One() { // Super Class constructor
....
}
One(int a) { // Super Class Constructor Overloading
....
}
}
Class Two extends One
{
One() { // this is a method not constructor
..... // because name should not match with Class name
}
Two() { // sub class constructor
....
}
Two(int b) { // sub class constructor overloading
....
}
}
Impossible de remplacer le constructeur. Le constructeur peut être considéré comme statique, la sous-classe ne peut pas remplacer son super constructeur.
Bien sûr, vous pouvez appeler la méthode protégée dans le constructeur de super classe, puis la remplacer dans la sous-classe pour changer le constructeur de super classe. Cependant, de nombreuses personnes suggèrent de ne pas utiliser cette astuce, afin de protéger le comportement des constructeurs de super classes. Par exemple, FindBugs vous avertira qu'un constructeur appelle une méthode non finale.
Vous pouvez avoir de nombreux constructeurs tant qu'ils prennent différents paramètres. Mais le compilateur qui place un constructeur par défaut n'est pas appelé "remplacement de constructeur".
Non, il n'est pas possible de remplacer un constructeur. Si nous essayons de le faire, une erreur de compilation se produira. Et ce n'est jamais possible en Java. Voyons l'exemple. Il vous demandera d'écrire un type de retour dans la méthode . signifie qu'il traitera ce constructeur surchargé comme une méthode et non comme un constructeur.
package com.sample.test;
class Animal{
public static void showMessage()
{
System.out.println("we are in Animal class");
}
}
class Dog extends Animal{
public void DogShow()
{
System.out.println("we are in Dog show class");
}
public static void showMessage()
{
System.out.println("we are in overriddn method of dog class");
}
}
public class AnimalTest {
public static void main(String [] args)
{
Animal animal = new Animal();
animal.showMessage();
Dog dog = new Dog();
dog.DogShow();
Animal animal2 = new Dog();
animal2.showMessage();
}
}
Parce qu'un constructeur ne peut pas être hérité dans Java et la substitution de méthode nécessite l'héritage. Par conséquent, il n'est pas applicable.
Mais si nous l'écrivons nous-mêmes, ce constructeur est appelé automatiquement.
Ce n'est pas correct. Le constructeur sans argument s'appelle si vous l'appelez, et que vous l'ayez écrit vous-même ou non. Il est également appelé automatiquement si vous ne codez pas un appel super (...) explicite dans une classe dérivée.
Rien de tout cela ne constitue une priorité pour le constructeur. Il n'y a rien de tel en Java. Il est constructeur surcharge, c'est-à-dire fournir différents jeux d'arguments.
méthode remplaçant dans Java est utilisé pour améliorer les performances du code récent écrit précédemment.
du code comme montre que nous créons ici une référence de classe de base et créons une instance physique de la classe dérivée. dans les constructeurs la surcharge est possible.
InputStream fis=new FileInputStream("a.txt");
int size=fis.available();
taille renverra le nombre total d'octets possible dans a.txt donc
Il convient également de noter que vous ne pouvez pas remplacer le constructeur de la sous-classe par le constructeur du nom de la superclasse. La règle d'OOPS indique qu'un constructeur doit avoir un nom comme nom de classe. Si nous essayons de remplacer le constructeur de la superclasse, il sera considéré comme une méthode inconnue sans type de retour.
Le constructeur ressemble à une méthode mais le nom doit être un nom de classe et aucune valeur de retour.
Overriding signifie ce que nous avons déclaré dans la classe Super, que nous devons déclarer exactement dans la sous-classe, il est appelé Overriding. Les noms de super classe et de sous-classe sont différents.
Si vous essayez d'écrire le constructeur de la classe Super dans la classe Sub, la classe Sub traitera cela comme une méthode et non comme un constructeur car le nom ne doit pas correspondre au nom de la classe Sub. Et cela donnera une erreur de compilation que les méthodes n'ont pas de valeur de retour. Nous devons donc déclarer nul, alors seulement il compilera.
La substitution du constructeur n'est pas possible pour la raison suivante.
Le nom du constructeur doit être le même nom que le nom de classe. Dans la pratique de l'héritage, vous devez créer deux classes avec des noms différents, donc deux constructeurs doivent avoir des noms différents. Il n'est donc pas possible de remplacer le constructeur et cette pensée n'a même pas de sens.
Votre exemple n'est pas un remplacement. Les remplacements se produisent techniquement dans une sous-classe, mais dans cet exemple, la méthode du constructeur est remplacée dans la classe d'origine.