Pausa para café #123. Construtor Java - Perguntas e respostas da entrevista técnica

Fonte: Hackenoon

O que é Construtor?

Construtor é um método especial definido em uma classe com o mesmo nome da classe. Um construtor Java é como um método que não possui um tipo de retorno. Os construtores desempenham o papel mais importante na inicialização de objetos e, neste artigo, listaremos exemplos de perguntas de entrevista que cobrem construtores em Java. Você também aprenderá sobre a importância dos construtores em Java, verá exemplos de código e outros detalhes importantes que o ajudarão a responder perguntas sobre construtores Java em uma entrevista.

Por que os construtores são necessários? Explique em detalhes

Digamos que temos uma classe chamada Student . E temos a variável de instância name e roll_number .

class Student{
String name;
int rollNo;
}

Agora, se criarmos 1000 objetos, a JVM inicializará esses valores com seu tipo padrão Name = null e rollNo = 0 . Não é possível identificar esses objetos individuais e atribuir valores a cada um dos objetos aumentará a quantidade de código, o que é considerado uma má prática de programação. Portanto, para evitar isso, são utilizados construtores. Ou seja, o propósito de um construtor em Java é inicializar o valor das variáveis ​​de instância da classe.

Que tipos de construtores existem em Java?

Existem três tipos diferentes de construtores em Java:

• Construtor padrão
• Construtor sem argumentos
• Construtor parametrizado

O que é construtor padrão em Java?

Um Construtor Padrão é um construtor criado pela JVM em tempo de execução se nenhum construtor estiver definido na classe. A principal tarefa do construtor padrão é inicializar os valores das instâncias de acordo com seu tipo padrão. Exemplo de construtor padrão em Java:

class DefaultConstructor{
int id;
String name;
}

Agora, para esta classe, se criarmos um objeto, dentro da JVM haverá um construtor padrão ao qual será fornecido um valor padrão.

DefaultConstructor df= new DefaultConstructor();

Agora, se imprimirmos o valor, obteremos:

O que é um construtor sem argumentos?

Um construtor sem argumento é um construtor que pode ser definido explicitamente para inicializar o valor das instâncias. Por exemplo:

class NoArgConstuctor{ int a; int b;

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

}

O que é um construtor parametrizado?

Um construtor parametrizado é um construtor que aceita um parâmetro para inicializar instâncias. Por exemplo:

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

Quais são as regras para definir um construtor?

Para definir construtores, você deve seguir diversas regras:

• O nome do construtor deve corresponder ao nome da classe.

• Não deve haver um tipo de retorno de construtor em Java.

• Os únicos modificadores aplicáveis ​​para construtores são:

  • público
  • padrão
  • protegido
  • privado

• Os construtores podem receber qualquer número de parâmetros.

• Os modificadores final, sincronizado, estático e abstrato não são permitidos em um construtor.

• O construtor não oferece suporte a uma instrução return em seu corpo.

• Pode haver exceções com uma instrução throw no construtor .

• É aceitável usar uma cláusula throws com um construtor.

• O construtor não deve gerar recursão.

Quando podemos usar um construtor privado?

Se não quisermos criar objetos de uma determinada classe externamente, podemos usar construtores fechados ou privados. Ao declarar os construtores privados, podemos criar objetos apenas dentro da classe. As classes singleton são um bom exemplo do uso de construtores privados.

Qual será o modificador de acesso padrão do construtor se não o definirmos explicitamente?

O modificador de acesso padrão de um construtor será sempre igual ao modificador de classe. Se a classe for pública, o construtor também será público. Se a classe for privada, o construtor também será privado. O mesmo acontecerá com outros modificadores de acesso.

Escreva a saída do trecho de código abaixo e 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();
}
}

O código acima irá imprimir: Obteremos esta saída porque se não incluirmos a palavra-chave super() ou this() no construtor na primeira linha, a JVM irá colocá-la automaticamente em tempo de execução. A JVM faz isso porque herda de outra classe e sua funcionalidade também será implementada na classe derivada. Assim, ao atribuir valores padrão às instâncias da classe base, a JVM adiciona a palavra-chave super() por padrão .

Revise o código e indique se ele é válido ou inválido. Explique o 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();
}
}

O código acima é inválido porque é o mesmo construtor dentro do construtor Scaler Academy . Isso cria recursão no construtor, o que não é permitido. Conseqüentemente, receberemos um erro em tempo de compilação associado à chamada ao construtor recursivo.

Podemos usar dois construtores em uma classe em Java?

Sim, podemos usar qualquer número de construtores em uma classe, sujeito a duas condições:

• Os parâmetros do construtor devem ser diferentes.
• Não deve haver recursão no construtor.

Exemplo. Considere dois construtores da mesma 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.");
}

Este código não é válido porque criará uma recursão. Um construtor sem argumentos chamará um construtor com parâmetros, e um construtor com parâmetros chamará um construtor sem argumentos.

Podemos substituir um construtor em Java?

Não, o conceito de sobrecarga de construtor não é aplicável em Java.

Um construtor pode ser final em Java?

Nenhum construtor pode ser definitivo. Isso ocorre porque as palavras-chave finais são usadas para interromper a substituição de um método em uma classe derivada. Mas em um construtor o conceito de substituição não se aplica, portanto não há necessidade de escrever a palavra-chave final . Se escrevermos a palavra-chave final no construtor, obteremos um erro em tempo de compilação chamado tipo de retorno obrigatório porque o compilador o trata como um método.

Um construtor pode ser estático em Java?

Não, um construtor Java não pode ser estático. Isso ocorre porque as palavras-chave estáticas são usadas quando queremos que um membro pertença a uma classe em vez de a um objeto. Mas os construtores destinam-se a inicializar objetos, portanto o compilador irá tratá-los como um método. Receberemos um erro de tipo de retorno obrigatório .

Descreva a diferença entre super(), super e this(), this

super() e this() são chamadas de construtor. É usado apenas para chamar o construtor da classe pai ou da classe atual. Observe que “super” e “this” são palavras-chave usadas para designar membros de uma instância de sua própria classe ou de uma classe base. Considere o código abaixo:

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

Neste trecho de código, this.message imprimirá a mensagem “ Welcome to Scaler Academy ” e super.message imprimirá “ Welcome to InterviewBit ”. É assim que essas duas palavras-chave são usadas para se referir a instâncias de membros das classes base e derivadas.

O que são destruidores? Existe um destruidor em Java?

Os destruidores são usados ​​para liberar memória adquirida por um programa. Por exemplo, se um programa necessita de memória durante sua execução, o destruidor libera essa memória para que outros programas possam utilizá-la. Não existe conceito de destruidor em Java porque o trabalho de liberação de memória em Java é feito pelo coletor de lixo.

O que é encadeamento de construtores em Java?

Quando um construtor é chamado de outro construtor, isso pode ser chamado de encadeamento de construtores. A chamada do construtor não precisa ser feita na mesma classe. Isso também pode ser feito para a classe pai. Por exemplo, considere a imagem abaixo. A seguir, podemos observar o código para inicializar o objeto com os valores dessas variáveis ​​de instância:

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

No código acima, estamos criando um objeto da classe Employee com os dados do funcionário e seu endereço. A classe de endereço Employee é herdada pela classe Employee . Agora, para instanciar um valor de objeto para um endereço, não atribuímos um valor explícito ao endereço do funcionário. Em vez disso, usamos o construtor da classe Employee Address para fazer isso . E com a ajuda de super(argumentos) formamos uma cadeia de construtores para inicializar os valores. Isso é o que é uma cadeia de construtores.

Determine a saída do programa a partir do código e explique sua resposta.

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

O código acima não imprimirá nada porque InterviewBit() não é um construtor aqui. Como as palavras-chave Void e int são usadas , ele se torna um método. Portanto, não chamamos o método. Não obteremos nenhuma saída porque para executar o método precisamos chamá-lo explicitamente no objeto.

Escreva um programa para copiar os valores de um objeto em um novo objeto usando um construtor

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