Kaffeepause Nr. 123. Java Constructor – Fragen und Antworten zu technischen Vorstellungsgesprächen

Quelle: Hackenoon

Was ist Konstruktor?

Der Konstruktor ist eine spezielle Methode, die in einer Klasse mit demselben Namen wie der Klassenname definiert ist. Ein Java-Konstruktor ist wie eine Methode, die keinen Rückgabetyp hat. Konstruktoren spielen die wichtigste Rolle bei der Initialisierung von Objekten. In diesem Artikel werden wir Beispielinterviewfragen zu Konstruktoren in Java auflisten. Außerdem erfahren Sie mehr über die Bedeutung von Konstruktoren in Java, sehen sich Codebeispiele und andere wichtige Details an, die Ihnen bei der Beantwortung von Fragen zu Java-Konstruktoren in einem Interview helfen.

Warum werden Konstrukteure benötigt? Erkläre im Detail

Nehmen wir an, wir haben eine Klasse namens Student . Und wir haben den Instanzvariablennamen und roll_number .

class Student{
String name;
int rollNo;
}

Wenn wir nun 1000 Objekte erstellen, initialisiert die JVM diese Werte mit ihrem Standardtyp Name = null und rollNo = 0 . Es ist nicht möglich, diese einzelnen Objekte zu identifizieren, und das Zuweisen von Werten zu jedem der Objekte erhöht die Codemenge, was als schlechte Programmierpraxis gilt. Um dies zu vermeiden, werden daher Konstruktoren verwendet. Das heißt, der Zweck eines Konstruktors in Java besteht darin, den Wert von Klasseninstanzvariablen zu initialisieren.

Welche Arten von Konstruktoren gibt es in Java?

In Java gibt es drei verschiedene Arten von Konstruktoren:

• Standardkonstruktor
• Konstruktor ohne Argumente
• Parametrisierter Konstruktor

Was ist der Standardkonstruktor in Java?

Ein Standardkonstruktor ist ein Konstruktor, der von der JVM zur Laufzeit erstellt wird, wenn in der Klasse kein Konstruktor definiert ist. Die Hauptaufgabe des Standardkonstruktors besteht darin, die Werte von Instanzen entsprechend ihrem Standardtyp zu initialisieren. Beispiel eines Standardkonstruktors in Java:

class DefaultConstructor{
int id;
String name;
}

Wenn wir nun für diese Klasse ein Objekt erstellen, gibt es in der JVM einen Standardkonstruktor, dem ein Standardwert zugewiesen wird.

DefaultConstructor df= new DefaultConstructor();

Wenn wir nun den Wert ausdrucken, erhalten wir:

Was ist ein No-Argument-Konstruktor?

Ein Konstruktor ohne Argumente ist ein Konstruktor, der explizit definiert werden kann, um den Wert von Instanzen zu initialisieren. Zum Beispiel:

class NoArgConstuctor{ int a; int b;

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

}

Was ist ein parametrisierter Konstruktor?

Ein parametrisierter Konstruktor ist ein Konstruktor, der einen Parameter zum Initialisieren von Instanzen akzeptiert. Zum Beispiel:

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

Welche Regeln gelten für die Definition eines Konstruktors?

Um Konstruktoren zu definieren, müssen Sie mehrere Regeln befolgen:

• Der Konstruktorname muss mit dem Klassennamen übereinstimmen.

• In Java sollte es keinen Konstruktor-Rückgabetyp geben.

• Die einzigen anwendbaren Modifikatoren für Konstruktoren sind:

  • öffentlich
  • Standard
  • geschützt
  • Privat

• Konstruktoren können eine beliebige Anzahl von Parametern annehmen.

• Die Modifikatoren final, synchronisiert, static und abstract sind in einem Konstruktor nicht erlaubt.

• Der Konstruktor unterstützt keine Return- Anweisung in seinem Hauptteil.

• Bei einer throw- Anweisung im Konstruktor kann es zu Ausnahmen kommen .

• Es ist akzeptabel, eine throws-Klausel mit einem Konstruktor zu verwenden .

• Der Konstruktor sollte keine Rekursion erzeugen.

Wann können wir einen privaten Konstruktor verwenden?

Wenn wir keine Objekte einer bestimmten Klasse von außen erstellen möchten, können wir geschlossene oder private Konstruktoren verwenden. Indem wir Konstruktoren als privat deklarieren, können wir Objekte nur innerhalb der Klasse erstellen. Singleton- Klassen sind ein gutes Beispiel für die Verwendung privater Konstruktoren.

Was ist der Standard-Konstruktor-Zugriffsmodifikator, wenn wir ihn nicht explizit definieren?

Der Standardzugriffsmodifikator eines Konstruktors ist immer derselbe wie der Klassenmodifikator. Wenn die Klasse öffentlich ist, ist auch der Konstruktor öffentlich. Wenn die Klasse privat ist, ist auch der Konstruktor privat. Das Gleiche passiert mit anderen Zugriffsmodifikatoren.

Schreiben Sie die Ausgabe des folgenden Codeausschnitts und erklären Sie sie

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();
}
}

Der obige Code wird gedruckt: Wir erhalten diese Ausgabe, denn wenn wir das Schlüsselwort super() oder this() nicht in der ersten Zeile des Konstruktors einschließen, fügt die JVM es automatisch zur Laufzeit ein. Die JVM tut dies, weil sie von einer anderen Klasse erbt und ihre Funktionalität auch in der abgeleiteten Klasse implementiert wird. Daher fügt die JVM beim Zuweisen von Standardwerten zu Basisklasseninstanzen standardmäßig das Schlüsselwort super() hinzu .

Überprüfen Sie den Code und geben Sie an, ob er gültig oder ungültig ist. Erklären Sie den Grund

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();
}
}

Der obige Code ist ungültig, da es sich um denselben Konstruktor innerhalb des Scaler Academy- Konstruktors handelt . Dadurch entsteht eine Rekursion im Konstruktor, die nicht zulässig ist. Dementsprechend erhalten wir einen Kompilierungsfehler im Zusammenhang mit dem Aufruf des rekursiven Konstruktors.

Können wir in Java zwei Konstruktoren in einer Klasse verwenden?

Ja, wir können unter zwei Bedingungen beliebig viele Konstruktoren in einer Klasse verwenden:

• Die Konstruktorparameter müssen unterschiedlich sein.
• Es sollte keine Rekursion im Konstruktor geben.

Beispiel. Betrachten Sie zwei Konstruktoren derselben InterviewBit- Klasse :

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.");
}

Dieser Code ist ungültig, da er eine Rekursion erstellt. Ein Konstruktor ohne Argumente ruft einen Konstruktor mit Parametern auf, und ein Konstruktor mit Parametern ruft einen Konstruktor ohne Argumente auf.

Können wir einen Konstruktor in Java überschreiben?

Nein, das Konzept der Konstruktorüberladung ist in Java nicht anwendbar.

Kann ein Konstruktor in Java final sein?

Kein Konstruktor kann endgültig sein. Dies liegt daran, dass die Schlüsselwörter final verwendet werden, um das Überschreiben einer Methode in einer abgeleiteten Klasse zu verhindern. In einem Konstruktor gilt das Konzept des Überschreibens jedoch nicht, sodass das letzte Schlüsselwort nicht geschrieben werden muss . Wenn wir das letzte Schlüsselwort in den Konstruktor schreiben, erhalten wir beim Kompilieren einen Fehler namens „ Required Return Type“ , da der Compiler ihn als Methode behandelt.

Kann ein Konstruktor in Java statisch sein?

Nein, ein Java-Konstruktor kann nicht statisch sein. Dies liegt daran, dass die statischen Schlüsselwörter verwendet werden, wenn wir möchten, dass ein Mitglied zu einer Klasse und nicht zu einem Objekt gehört. Da Konstruktoren jedoch dazu gedacht sind, Objekte zu initialisieren, behandelt der Compiler sie als Methode. Wir erhalten einen erforderlichen Rückgabetypfehler .

Beschreiben Sie den Unterschied zwischen super(), super und this(), this

super() und this() sind Konstruktoraufrufe. Es wird nur verwendet, um den Konstruktor der übergeordneten Klasse oder der aktuellen Klasse aufzurufen. Beachten Sie, dass „super“ und „this“ Schlüsselwörter sind, die zur Bezeichnung von Mitgliedern einer Instanz ihrer eigenen Klasse oder einer Basisklasse verwendet werden. Betrachten Sie den folgenden Code:

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();
	}
}

In diesem Codeausschnitt gibt this.message die Nachricht „ Willkommen bei Scaler Academy “ und super.message „ Willkommen bei InterviewBit “ aus. Auf diese Weise werden diese beiden Schlüsselwörter verwendet, um auf Mitgliedsinstanzen der Basis- und abgeleiteten Klassen zu verweisen.

Was sind Destruktoren? Gibt es in Java einen Destruktor?

Destruktoren werden verwendet, um von einem Programm erworbenen Speicher freizugeben. Wenn beispielsweise ein Programm während seiner Ausführung Speicher benötigt, gibt der Destruktor diesen Speicher frei, damit andere Programme ihn verwenden können. In Java gibt es kein Konzept für einen Destruktor, da die Arbeit der Speicherfreigabe in Java vom Garbage Collector übernommen wird.

Was ist Konstruktorverkettung in Java?

Wenn ein Konstruktor von einem anderen Konstruktor aufgerufen wird, kann dies als Konstruktorverkettung bezeichnet werden. Der Konstruktoraufruf muss nicht für dieselbe Klasse erfolgen. Dies kann auch für die übergeordnete Klasse durchgeführt werden. Betrachten Sie als Beispiel das Bild unten. Als nächstes können wir uns den Code ansehen, um das Objekt mit den Werten dieser Instanzvariablen zu initialisieren:

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");
}

Im obigen Code erstellen wir ein Mitarbeiterklassenobjekt mit den Mitarbeiterdetails und seiner Adresse. Die Adressklasse „Employee“ wird von der Klasse „Employee“ geerbt . Um nun einen Objektwert für eine Adresse zu instanziieren, weisen wir der Adresse des Mitarbeiters keinen expliziten Wert zu. Stattdessen verwenden wir dazu den Konstruktor der Employee Address- Klasse . Und mit Hilfe von Super(argumenten) bilden wir eine Kette von Konstruktoren, um die Werte zu initialisieren. Das ist eine Konstruktorkette.

Bestimmen Sie die Programmausgabe aus dem Code und erläutern Sie Ihre Antwort.

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();
}

Der obige Code gibt nichts aus, da InterviewBit() hier kein Konstruktor ist. Da die Schlüsselwörter Void und int verwendet werden , wird es zu einer Methode. Deshalb rufen wir die Methode nicht auf. Wir erhalten keine Ausgabe, da wir die Methode zum Ausführen explizit für das Objekt aufrufen müssen.

Schreiben Sie ein Programm, um die Werte eines Objekts mithilfe eines Konstruktors in ein neues Objekt zu kopieren

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);
}