Pause café #123. Constructeur Java - Questions et réponses d'entretien technique

Source : Hackenoon

Qu'est-ce que le constructeur ?

Le constructeur est une méthode spéciale définie dans une classe portant le même nom que le nom de la classe. Un constructeur Java est comme une méthode qui n'a pas de type de retour. Les constructeurs jouent le rôle le plus important dans l'initialisation des objets et dans cet article, nous listerons des exemples de questions d'entretien qui couvrent les constructeurs en Java. Vous découvrirez également l'importance des constructeurs en Java, consulterez des exemples de code et d'autres détails importants qui vous aideront à répondre aux questions sur les constructeurs Java lors d'un entretien.

Pourquoi les constructeurs sont-ils nécessaires ? Expliquer en détail

Disons que nous avons une classe nommée Student . Et nous avons le nom de la variable d'instance et roll_number .

class Student{
String name;
int rollNo;
}

Désormais, si nous créons 1000 objets, alors la JVM initialisera ces valeurs avec son type par défaut Name = null et rollNo = 0 . L'identification de ces objets individuels n'est pas possible et l'attribution de valeurs à chacun des objets augmentera la quantité de code, ce qui est considéré comme une mauvaise pratique de programmation. Par conséquent, pour éviter cela, des constructeurs sont utilisés. Autrement dit, le but d'un constructeur en Java est d'initialiser la valeur des variables d'instance de classe.

Quels types de constructeurs existe-t-il en Java ?

Il existe trois types différents de constructeurs en Java :

• Constructeur par défaut
• Constructeur sans argument
• Constructeur paramétré

Qu’est-ce que le constructeur par défaut en Java ?

Un constructeur par défaut est un constructeur créé par la JVM au moment de l'exécution si aucun constructeur n'est défini dans la classe. La tâche principale du constructeur par défaut est d'initialiser les valeurs des instances en fonction de leur type par défaut. Exemple de constructeur par défaut en Java :

class DefaultConstructor{
int id;
String name;
}

Maintenant, pour cette classe, si nous créons un objet, alors à l'intérieur de la JVM, il y aura un constructeur par défaut qui recevra une valeur par défaut.

DefaultConstructor df= new DefaultConstructor();

Maintenant, si nous imprimons la valeur, nous obtiendrons :

Qu'est-ce qu'un constructeur sans argument ?

Un constructeur sans argument est un constructeur qui peut être explicitement défini pour initialiser la valeur des instances. Par exemple:

class NoArgConstuctor{ int a; int b;

//No Argument Constructor
NoArgConstuctor(){
a = 10;
b = 20;
}

}

Qu'est-ce qu'un constructeur paramétré ?

Un constructeur paramétré est un constructeur qui accepte un paramètre pour initialiser les instances. Par exemple:

class ParameterizedConstuctor{
String name;
int age;
//Parameterized Constructor
ParameterizedConstuctor(String name, int age){
this.name = name;
this.age = age;
}
}

Quelles sont les règles pour définir un constructeur ?

Pour définir des constructeurs, vous devez suivre plusieurs règles :

• Le nom du constructeur doit correspondre au nom de la classe.

• Il ne devrait pas y avoir de type de retour constructeur en Java.

• Les seuls modificateurs applicables pour les constructeurs sont :

  • publique
  • défaut
  • protégé
  • privé

• Les constructeurs peuvent prendre n'importe quel nombre de paramètres.

• Les modificateurs final, synchronisé, statique et abstrait ne sont pas autorisés dans un constructeur.

• Le constructeur ne prend pas en charge une instruction return dans son corps.

• Il peut y avoir des exceptions avec une instruction throw dans le constructeur .

• Il est acceptable d'utiliser une clause throws avec un constructeur.

• Le constructeur ne doit pas générer de récursion.

Quand peut-on faire appel à un constructeur privé ?

Si nous ne voulons pas créer des objets d'une certaine classe de l'extérieur, nous pouvons utiliser des constructeurs fermés ou privés. En déclarant les constructeurs privés, nous pouvons créer des objets uniquement au sein de la classe. Les classes Singleton sont un bon exemple d’utilisation de constructeurs privés.

Quel sera le modificateur d'accès au constructeur par défaut si nous ne le définissons pas explicitement ?

Le modificateur d'accès par défaut d'un constructeur sera toujours le même que le modificateur de classe. Si la classe est publique, alors le constructeur sera également public. Si la classe est privée, alors le constructeur sera également privé. La même chose se produira avec d’autres modificateurs d’accès.

Écrivez le résultat de l'extrait de code ci-dessous et expliquez

class InterviewBit{
InterviewBit(){
System.out.println(" Welcome to InterviewBit ");
}
}
class ScalerAcademy extends InterviewBit{
ScalerAcademy(){
System.out.println(" Welcome to Scaler Academy by InterviewBit");
}
}
class Main{
public static void main(String[] args) {
ScalerAcademy sc = new ScalerAcademy();
}
}

Le code ci-dessus s'imprimera : Nous obtiendrons ce résultat car si nous n'incluons pas le mot-clé super() ou this() dans le constructeur sur la première ligne, la JVM le mettra automatiquement au moment de l'exécution. La JVM fait cela car elle hérite d'une autre classe et ses fonctionnalités seront également implémentées dans la classe dérivée. Ainsi, lors de l'attribution de valeurs par défaut aux instances de classe de base, la JVM ajoute le mot-clé super() par défaut .

Vérifiez le code et indiquez s'il est valide ou non valide. Expliquez la raison

class InterviewBit{
InterviewBit(){
System.out.println(" Welcome to InterviewBit ");
}
}
class ScalerAcademy extends InterviewBit{
ScalerAcademy(){
this();
System.out.println(" Welcome to Scaler Academy by InterviewBit");
}
}
class Main{
public static void main(String[] args) {
ScalerAcademy sc = new ScalerAcademy();
}
}

Le code ci-dessus n'est pas valide car il s'agit du même constructeur dans le constructeur Scaler Academy . Cela crée une récursion dans le constructeur, ce qui n'est pas autorisé. En conséquence, nous recevrons une erreur de compilation associée à l'appel au constructeur récursif.

Pouvons-nous utiliser deux constructeurs dans une classe en Java ?

Oui, nous pouvons utiliser n'importe quel nombre de constructeurs dans une classe, sous réserve de deux conditions :

• Les paramètres du constructeur doivent être différents.
• Il ne devrait y avoir aucune récursion dans le constructeur.

Exemple. Considérons deux constructeurs de la même classe InterviewBit :

InterviewBit(){
    this("Scaler"); // Calling parameterized constructor
    System.out.println(" No Argument Constructor");
}
InterviewBit(String name){
    this(); // Calling no-arg constructor
    System.out.println(" Constructor with Parameters.");
}

Ce code n'est pas valide car il créera une récursion. Un constructeur sans arguments appellera un constructeur avec paramètres, et un constructeur avec paramètres appellera un constructeur sans arguments.

Pouvons-nous remplacer un constructeur en Java ?

Non, le concept de surcharge de constructeur n'est pas applicable en Java.

Un constructeur peut-il être final en Java ?

Aucun constructeur ne peut être définitif. En effet, les mots-clés final sont utilisés pour arrêter de remplacer une méthode dans une classe dérivée. Mais dans un constructeur, la notion de substitution ne s'applique pas, il n'est donc pas nécessaire d'écrire le mot-clé final . Si nous écrivons le mot-clé final dans le constructeur, nous obtiendrons une erreur de compilation appelée type de retour requis car le compilateur le traite comme une méthode.

Un constructeur peut-il être statique en Java ?

Non, un constructeur Java ne peut pas être statique. En effet, les mots-clés statiques sont utilisés lorsque nous souhaitons qu'un membre appartienne à une classe plutôt qu'à un objet. Mais les constructeurs sont censés initialiser des objets, le compilateur les traitera donc comme une méthode. Nous obtiendrons une erreur de type de retour obligatoire .

Décrivez la différence entre super(), super et this(), this

super() et this() sont des appels de constructeur. Il sert uniquement à appeler le constructeur de la classe parent ou de la classe actuelle. Notez que « super » et « this » sont des mots-clés utilisés pour désigner les membres d'une instance de sa propre classe ou d'une classe de base. Considérez le code ci-dessous :

class InterviewBit{
    String message = " Welcome to InterviewBit";
}
public class Scaler extends InterviewBit
{
    String message = " Welcome to Scaler Academy";
    public void printMethod(){
        //this will print the message variable of the current class.
        System.out.println(this.message);

        //this will print the message variable of Base class.
        System.out.println(super.message);
    }
	public static void main(String[] args) {
		Scaler sa = new Scaler();
		sa.printMethod();
	}
}

Dans cet extrait de code, this.message affichera le message « Bienvenue dans Scaler Academy » et super.message affichera « Bienvenue dans InterviewBit ». C'est ainsi que ces deux mots-clés sont utilisés pour faire référence aux instances membres des classes de base et dérivées.

Que sont les destructeurs ? Un destructeur existe-t-il en Java ?

Les destructeurs sont utilisés pour libérer la mémoire acquise par un programme. Par exemple, si un programme a besoin de mémoire lors de son exécution, le destructeur libère cette mémoire afin que d'autres programmes puissent l'utiliser. Il n'y a pas de concept de destructeur en Java car le travail de libération de mémoire en Java est géré par le garbage collector.

Qu’est-ce que le chaînage de constructeurs en Java ?

Lorsqu'un constructeur est appelé depuis un autre constructeur, cela peut être appelé chaînage de constructeurs. L'appel du constructeur ne doit pas nécessairement être effectué sur la même classe. Cela peut également être fait pour la classe parent. Pour un exemple, considérons l’image ci-dessous. Ensuite, nous pouvons regarder le code pour initialiser l'objet avec les valeurs de ces variables d'instance :

class EmployeeAddess{
    int pinCode;
    String address;
    String mobNo;
    EmployeeAddress(int pinCode, String address, String mobNo){
        this.pinCode = pinCodel
        this.address = address;
        this.mobNo = mobNo;
    }
}
class Employees extends EmployeeAddress{
    int ID;
    String name;
    String designation;
    String department;
    Employee(int ID, String name, String designation,String department,
                    int pinCode, String address, String mobNo){

        //Calling Constructor for Base class to initialize the object.
        //This can be a constructor chaining.
        super(pinCode, address, mobNo);
        this.ID = ID;
        this.name = name;
        this.designation = designation;
        this.department = department;
    }
}
public class Main{
    Employee emp = new Employee(101, "XYX", "SDE", "Cloud", 123456, "no 150, xys, xys, INDIA", "999999999");
}

Dans le code ci-dessus, nous créons un objet de classe Employee avec les détails de l'employé et son adresse. La classe d'adresse Employee est héritée de la classe Employee . Désormais, pour instancier une valeur d'objet pour une adresse, nous n'attribuons pas de valeur explicite à l'adresse de l'employé. Au lieu de cela, nous utilisons le constructeur de la classe Employee Address pour ce faire . Et avec l'aide de super(arguments) nous formons une chaîne de constructeurs pour initialiser les valeurs. C'est ce qu'est une chaîne de constructeurs.

Déterminez la sortie du programme à partir du code et expliquez votre réponse.

class InterviewBit{
void InterviewBit(){
System.out.println(" Java Constructor interview questions by InterviewBit");
}
int InterviewBit(int val){
System.out.println(" Java Constructor. And Value = "+val);
}
}
public class Main{
InterviewBit ib1 = new InterviewBit();
InterviewBit ib2 = new InterviewBit();
}

Le code ci-dessus n'imprimera rien car InterviewBit() n'est pas ici un constructeur. Puisque les mots-clés Void et int sont utilisés , cela devient une méthode. Nous n’appelons donc pas la méthode. Nous n’obtiendrons aucun résultat car pour exécuter la méthode, nous devons l’appeler explicitement sur l’objet.

Écrire un programme pour copier les valeurs d'un objet dans un nouvel objet à l'aide d'un constructeur

class Rectangle{
    int length;
    int breadth;
    Rectangle(int length, int breadth){
        this.length = length;
        this.breadth = breadth;
    }

    //Overloaded Constructor for copying the value of old Object to new object
    Rectangle(Rectangle obj){
        this.length = obj.length;
        this.breadth = obj.breadth;
    }
}
public class Main{
    Rectangle obj1 = new Rectangle(10, 5);

    //New Object of rectangle class will be created with the value from obj1.
    Rectangle obj2 = new Rectangle(obj1);
}