Pausa caffè #123. Costruttore Java: domande e risposte al colloquio tecnico

Fonte: Hackenoon

Cos'è Costruttore?

Il costruttore è un metodo speciale definito in una classe con lo stesso nome del nome della classe. Un costruttore Java è come un metodo che non ha un tipo restituito. I costruttori svolgono il ruolo più importante nell'inizializzazione degli oggetti e in questo articolo elencheremo domande di intervista di esempio che riguardano i costruttori in Java. Imparerai anche l'importanza dei costruttori Java, vedrai esempi di codice e altri dettagli importanti che ti aiuteranno a rispondere alle domande sui costruttori Java in un'intervista.

Perché sono necessari i costruttori? Spiega in dettaglio

Supponiamo di avere una classe denominata Student . E abbiamo la variabile di istanza name e roll_number .

class Student{
String name;
int rollNo;
}

Ora, se creiamo 1000 oggetti, la JVM inizializzerà questi valori con il suo tipo predefinito Name = null e rollNo = 0 . Identificare questi singoli oggetti non è possibile e assegnare valori a ciascuno degli oggetti aumenterà la quantità di codice, il che è considerato una cattiva pratica di programmazione. Pertanto, per evitare ciò, vengono utilizzati i costruttori. Cioè, lo scopo di un costruttore in Java è inizializzare il valore delle variabili di istanza della classe.

Quali tipi di costruttori ci sono in Java?

In Java esistono tre diversi tipi di costruttori:

• Costruttore predefinito
• Costruttore senza argomenti
• Costruttore parametrizzato

Cos'è il costruttore predefinito in Java?

Un costruttore predefinito è un costruttore creato dalla JVM in fase di esecuzione se nella classe non è definito alcun costruttore. Il compito principale del costruttore predefinito è inizializzare i valori delle istanze in base al loro tipo predefinito. Esempio di costruttore predefinito in Java:

class DefaultConstructor{
int id;
String name;
}

Ora per questa classe, se creiamo un oggetto, all'interno della JVM ci sarà un costruttore predefinito a cui viene assegnato un valore predefinito.

DefaultConstructor df= new DefaultConstructor();

Ora se stampiamo il valore otterremo:

Cos'è un costruttore senza argomenti?

Un costruttore senza argomenti è un costruttore che può essere definito esplicitamente per inizializzare il valore delle istanze. Per esempio:

class NoArgConstuctor{ int a; int b;

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

}

Cos'è un costruttore parametrizzato?

Un costruttore con parametri è un costruttore che accetta un parametro per inizializzare le istanze. Per esempio:

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

Quali sono le regole per definire un costruttore?

Per definire i costruttori, è necessario seguire diverse regole:

• Il nome del costruttore deve corrispondere al nome della classe.

• Non dovrebbe esserci un tipo restituito dal costruttore in Java.

• Gli unici modificatori applicabili per i costruttori sono:

  • pubblico
  • predefinito
  • protetto
  • privato

• I costruttori possono accettare un numero qualsiasi di parametri.

• I modificatori final, sincronizzato, statico e astratto non sono consentiti in un costruttore.

• Il costruttore non supporta un'istruzione return all'interno del proprio corpo.

• Possono esserci eccezioni con un'istruzione Throw nel costruttore .

• È accettabile utilizzare una clausola Throws con un costruttore.

• Il costruttore non dovrebbe generare ricorsione.

Quando possiamo usare un costruttore privato?

Se non vogliamo creare oggetti di una determinata classe dall'esterno, possiamo utilizzare costruttori chiusi o privati. Dichiarando privati ​​i costruttori, possiamo creare oggetti solo all'interno della classe. Le classi Singleton sono un buon esempio dell'uso di costruttori privati.

Quale sarà il modificatore di accesso del costruttore predefinito se non lo definiamo esplicitamente?

Il modificatore di accesso predefinito di un costruttore sarà sempre lo stesso del modificatore di classe. Se la classe è pubblica, anche il costruttore sarà pubblico. Se la classe è privata, anche il costruttore sarà privato. Lo stesso accadrà con altri modificatori di accesso.

Scrivi l'output dello snippet di codice seguente e spiegalo

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

Il codice sopra verrà stampato: Otterremo questo output perché se non includiamo la parola chiave super() o this() nel costruttore sulla prima riga, la JVM la inserirà automaticamente in fase di runtime. La JVM fa questo perché eredita da un'altra classe e la sua funzionalità verrà implementata anche nella classe derivata. Pertanto, quando si assegnano valori predefiniti alle istanze della classe base, la JVM aggiunge la parola chiave super() per impostazione predefinita .

Esamina il codice e indica se è valido o non valido. Spiegare il motivo

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

Il codice precedente non è valido perché è lo stesso costruttore all'interno del costruttore Scaler Academy . Ciò crea ricorsione nel costruttore, cosa non consentita. Di conseguenza, riceveremo un errore in fase di compilazione associato alla chiamata al costruttore ricorsivo.

Possiamo usare due costruttori in una classe in Java?

Sì, possiamo utilizzare un numero qualsiasi di costruttori in una classe, a due condizioni:

• I parametri del costruttore devono essere diversi.
• Non dovrebbe esserci alcuna ricorsione nel costruttore.

Esempio. Considera due costruttori della stessa 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.");
}

Questo codice non è valido perché creerà una ricorsione. Un costruttore senza argomenti chiamerà un costruttore con parametri e un costruttore con parametri chiamerà un costruttore senza argomenti.

Possiamo sovrascrivere un costruttore in Java?

No, il concetto di sovraccarico del costruttore non è applicabile in Java.

Un costruttore può essere definitivo in Java?

Nessun costruttore può essere definitivo. Questo perché le parole chiave finali vengono utilizzate per interrompere l'override di un metodo in una classe derivata. Ma in un costruttore il concetto di overriding non si applica, quindi non è necessario scrivere la parola chiave finale . Se scriviamo la parola chiave finale nel costruttore, otterremo un errore in fase di compilazione chiamato tipo restituito richiesto perché il compilatore lo tratta come un metodo.

Un costruttore può essere statico in Java?

No, un costruttore Java non può essere statico. Questo perché le parole chiave statiche vengono utilizzate quando vogliamo che un membro appartenga a una classe anziché a un oggetto. Ma i costruttori hanno lo scopo di inizializzare gli oggetti, quindi il compilatore lo tratterà come un metodo. Riceveremo un errore di tipo restituito obbligatorio .

Descrivi la differenza tra super(), super e this(), this

super() e this() sono chiamate del costruttore. Viene utilizzato solo per chiamare il costruttore della classe genitore o della classe corrente. Tieni presente che "super" e "this" sono parole chiave utilizzate per designare i membri di un'istanza della propria classe o di una classe base. Considera il codice seguente:

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 questo frammento di codice, this.message stamperà il messaggio " Benvenuto in Scaler Academy " e super.message stamperà " Benvenuto in InterviewBit ". Questo è il modo in cui queste due parole chiave vengono utilizzate per fare riferimento alle istanze dei membri delle classi base e derivate.

Cosa sono i distruttori? Esiste un distruttore in Java?

I distruttori vengono utilizzati per liberare la memoria acquisita da un programma. Ad esempio, se un programma necessita di memoria durante la sua esecuzione, il distruttore libera quella memoria in modo che altri programmi possano utilizzarla. Non esiste il concetto di distruttore in Java perché il lavoro di liberazione della memoria in Java è gestito dal garbage collector.

Cos'è il concatenamento del costruttore in Java?

Quando un costruttore viene chiamato da un altro costruttore, questo può essere chiamato concatenamento di costruttori. Non è necessario che la chiamata del costruttore venga effettuata sulla stessa classe. Questo può essere fatto anche per la classe genitore. Ad esempio, considera l'immagine qui sotto. Successivamente, possiamo guardare il codice per inizializzare l'oggetto con i valori di queste variabili di istanza:

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

Nel codice sopra, stiamo creando un oggetto classe Employee con i dettagli del dipendente e il suo indirizzo. La classe dell'indirizzo Employee è ereditata dalla classe Employee . Ora, per istanziare un valore oggetto per un indirizzo, non assegniamo un valore esplicito all'indirizzo del dipendente. Per farlo utilizziamo invece il costruttore della classe Employee Address . E con l'aiuto di super(argomenti) formiamo una catena di costruttori per inizializzare i valori. Ecco cos'è una catena di costruttori.

Determina l'output del programma dal codice e spiega la tua risposta.

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

Il codice precedente non stamperà nulla perché InterviewBit() non è un costruttore qui. Poiché vengono utilizzate le parole chiave Void e int , diventa un metodo. Pertanto non chiamiamo il metodo. Non otterremo alcun output perché per eseguire il metodo dobbiamo chiamarlo esplicitamente sull'oggetto.

Scrivi un programma per copiare i valori di un oggetto in un nuovo oggetto utilizzando un costruttore

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