Pausa para el café #123. Java Constructor: preguntas y respuestas de la entrevista técnica

Fuente: Hackenoon

¿Qué es Constructor?

Constructor es un método especial definido en una clase con el mismo nombre que el nombre de la clase. Un constructor de Java es como un método que no tiene tipo de retorno. Los constructores desempeñan el papel más importante en la inicialización de objetos y en este artículo enumeraremos ejemplos de preguntas de entrevista que cubren los constructores en Java. También aprenderá sobre la importancia de los constructores en Java, verá ejemplos de código y otros detalles importantes que lo ayudarán a responder preguntas sobre los constructores de Java en una entrevista.

¿Por qué se necesitan constructores? Explicar con detalle

Digamos que tenemos una clase llamada Estudiante . Y tenemos el nombre de la variable de instancia y roll_number .

class Student{
String name;
int rollNo;
}

Ahora, si creamos 1000 objetos, entonces la JVM inicializará estos valores con su tipo predeterminado Name = null y rollNo = 0 . No es posible identificar estos objetos individuales y asignar valores a cada uno de los objetos aumentará la cantidad de código, lo que se considera una mala práctica de programación. Por tanto, para evitar esto se utilizan constructores. Es decir, el propósito de un constructor en Java es inicializar el valor de las variables de instancia de clase.

¿Qué tipos de constructores existen en Java?

Hay tres tipos diferentes de constructores en Java:

• Constructor predeterminado
• Constructor sin argumentos
• Constructor parametrizado

¿Qué es el constructor predeterminado en Java?

Un constructor predeterminado es un constructor creado por la JVM en tiempo de ejecución si no hay ningún constructor definido en la clase. El trabajo principal del constructor predeterminado es inicializar los valores de las instancias según su tipo predeterminado. Ejemplo de constructor predeterminado en Java:

class DefaultConstructor{
int id;
String name;
}

Ahora, para esta clase, si creamos un objeto, dentro de la JVM habrá un constructor predeterminado al que se le asignará un valor predeterminado.

DefaultConstructor df= new DefaultConstructor();

Ahora si imprimimos el valor obtendremos:

¿Qué es un constructor sin argumentos?

Un constructor sin argumentos es un constructor que se puede definir explícitamente para inicializar el valor de las instancias. Por ejemplo:

class NoArgConstuctor{ int a; int b;

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

}

¿Qué es un constructor parametrizado?

Un constructor parametrizado es un constructor que acepta un parámetro para inicializar instancias. Por ejemplo:

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

¿Cuáles son las reglas para definir un constructor?

Para definir constructores, debes seguir varias reglas:

• El nombre del constructor debe coincidir con el nombre de la clase.

• No debería haber un tipo de retorno de constructor en Java.

• Los únicos modificadores aplicables para los constructores son:

  • público
  • por defecto
  • protegido
  • privado

• Los constructores pueden tomar cualquier número de parámetros.

• Los modificadores final, sincronizado, estático y abstracto no están permitidos en un constructor.

• El constructor no admite una declaración de devolución dentro de su cuerpo.

• Puede haber excepciones con una declaración throw en el constructor .

• Es aceptable utilizar una cláusula throws con un constructor.

• El constructor no debería generar recursividad.

¿Cuándo podemos recurrir a un constructor privado?

Si no queremos crear objetos de una determinada clase desde el exterior, podemos utilizar constructores cerrados o privados. Al declarar los constructores privados, podemos crear objetos sólo dentro de la clase. Las clases singleton son un buen ejemplo del uso de constructores privados.

¿Cuál será el modificador de acceso al constructor predeterminado si no lo definimos explícitamente?

El modificador de acceso predeterminado de un constructor siempre será el mismo que el modificador de clase. Si la clase es pública, el constructor también lo será. Si la clase es privada, el constructor también lo será. Lo mismo ocurrirá con otros modificadores de acceso.

Escriba el resultado del siguiente fragmento de código y explique

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

El código anterior se imprimirá: Obtendremos este resultado porque si no incluimos la palabra clave super() o this() en el constructor en la primera línea, la JVM la colocará automáticamente en tiempo de ejecución. La JVM hace esto porque hereda de otra clase y su funcionalidad también se implementará en la clase derivada. Por lo tanto, al asignar valores predeterminados a instancias de clase base, la JVM agrega la palabra clave super() de forma predeterminada .

Revisa el código e indica si es válido o no válido. explica la razon

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

El código anterior no es válido porque es el mismo constructor dentro del constructor de Scaler Academy . Esto crea recursividad en el constructor, lo cual no está permitido. En consecuencia, recibiremos un error en tiempo de compilación asociado con la llamada al constructor recursivo.

¿Podemos usar dos constructores en una clase en Java?

Sí, podemos usar cualquier número de constructores en una clase, sujeto a dos condiciones:

• Los parámetros del constructor deben ser diferentes.
• No debería haber recursividad en el constructor.

Ejemplo. Considere dos constructores de la misma clase 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.");
}

Este código no es válido porque creará una recursividad. Un constructor sin argumentos llamará a un constructor con parámetros, y un constructor con parámetros llamará a un constructor sin argumentos.

¿Podemos anular un constructor en Java?

No, el concepto de sobrecarga de constructores no es aplicable en Java.

¿Puede un constructor ser definitivo en Java?

Ningún constructor puede ser definitivo. Esto se debe a que las palabras clave finales se utilizan para dejar de anular un método en una clase derivada. Pero en un constructor, el concepto de anulación no se aplica, por lo que no es necesario escribir la palabra clave final . Si escribimos la palabra clave final en el constructor, obtendremos un error en tiempo de compilación llamado tipo de retorno requerido porque el compilador lo trata como un método.

¿Puede un constructor ser estático en Java?

No, un constructor de Java no puede ser estático. Esto se debe a que las palabras clave estáticas se utilizan cuando queremos que un miembro pertenezca a una clase en lugar de a un objeto. Pero los constructores están destinados a inicializar objetos, por lo que el compilador los tratará como un método. Recibiremos un error de tipo de devolución requerido .

Describe la diferencia entre super(), super y this(), this

super() y this() son llamadas al constructor. Solo se usa para llamar al constructor de la clase principal o de la clase actual. Tenga en cuenta que "super" y "this" son palabras clave utilizadas para designar miembros de una instancia de su propia clase o una clase base. Considere el siguiente código:

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

En este fragmento de código, this.message imprimirá el mensaje " Bienvenido a Scaler Academy " y super.message imprimirá " Bienvenido a InterviewBit ". Así es como se utilizan estas dos palabras clave para hacer referencia a instancias miembro de las clases base y derivadas.

¿Qué son los destructores? ¿Existe un destructor en Java?

Los destructores se utilizan para liberar memoria adquirida por un programa. Por ejemplo, si un programa necesita memoria durante su ejecución, el destructor libera esa memoria para que otros programas puedan usarla. No existe el concepto de destructor en Java porque el trabajo de liberar memoria en Java lo maneja el recolector de basura.

¿Qué es el encadenamiento de constructores en Java?

Cuando se llama a un constructor desde otro constructor, esto se puede llamar encadenamiento de constructores. No es necesario realizar la llamada al constructor en la misma clase. Esto también se puede hacer para la clase principal. Por ejemplo, considere la imagen a continuación. A continuación, podemos mirar el código para inicializar el objeto con los valores de estas variables de instancia:

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

En el código anterior, estamos creando un objeto de clase Empleado con los detalles del empleado y su dirección. La clase de dirección de Empleado es heredada por la clase de Empleado . Ahora, para crear una instancia de un valor de objeto para una dirección, no asignamos un valor explícito a la dirección del empleado. En su lugar, utilizamos el constructor de la clase Dirección de empleado para hacer esto . Y con la ayuda de super(argumentos) formamos una cadena de constructores para inicializar los valores. Eso es lo que es una cadena constructora.

Determine el resultado del programa a partir del código y explique su respuesta.

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

El código anterior no imprimirá nada porque InterviewBit() no es un constructor aquí. Dado que se utilizan las palabras clave Void e int , se convierte en un método. Por lo tanto no llamamos al método. No obtendremos ningún resultado porque para ejecutar el método necesitamos llamarlo explícitamente en el objeto.

Escriba un programa para copiar los valores de un objeto en un nuevo objeto usando un constructor

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