Sobrecarga de construtor em Java: o que é e exemplos de programas

O que é construtor em Java?

Construtor é um método especial usado para inicializar um objeto recém-criado e é chamado logo após a memória ser alocada para o objeto. Ele pode ser usado para inicializar os objetos com os valores desejados ou valores padrão no momento da criação do objeto. Não é obrigatório para o codificador escrever um construtor para uma classe.

Se nenhum construtor definido pelo usuário for fornecido para uma classe, o compilador inicializa as variáveis ​​de membro com seus valores padrão.

  • tipos de dados numéricos são definidos como 0
  • tipos de dados char são definidos como caractere nulo ('\0')
  • variáveis ​​de referência são definidas como nulas

Neste tutorial, você aprenderá

Regras para criar um construtor Java

  1. Tem o mesmo nome como a classe
  2. Não deve retornar um valor nem mesmo anular

Exemplo 1: Crie seu primeiro construtor em Java

Passo 1) Digite o seguintewing programa construtor em Editor Java.

class Demo{
      int  value1;
      int  value2;
      Demo(){
         value1 = 10;
         value2 = 20;
         System.out.println("Inside Constructor");
     }
 
     public void display(){
        System.out.println("Value1 === "+value1);
        System.out.println("Value2 === "+value2);
    }
 
   public static void main(String args[]){
       Demo d1 = new Demo();
      d1.display();
  }
}

Passo 2) Salve, execute e compile o programa construtor em Java e observe a saída.

Resultado esperado:

Inside Constructor
Value1 === 10
Value2 === 20

Sobrecarga de construtor em Java

A sobrecarga do construtor Java é uma técnica na qual uma classe pode ter qualquer número de construtores que diferem na lista de parâmetros. O compilador diferencia esses construtores levando em consideração o número de parâmetros na lista e seu tipo.

Exemplos de construtores válidos para a classe Account são

Account(int a);
Account (int a,int b);
Account (String a,int b);

Exemplo 2: Para entender a sobrecarga do construtor em Java

Passo 1) Digite o código no editor.

class Demo{
      int  value1;
      int  value2;
      /*Demo(){
       value1 = 10;
       value2 = 20;
       System.out.println("Inside 1st Constructor");
     }*/
     Demo(int a){
      value1 = a;
      System.out.println("Inside 2nd Constructor");
    }
    Demo(int a,int b){
    value1 = a;
    value2 = b;
    System.out.println("Inside 3rd Constructor");
   }
   public void display(){
      System.out.println("Value1 === "+value1);
      System.out.println("Value2 === "+value2);
  }
  public static void main(String args[]){
    Demo d1 = new Demo();
    Demo d2 = new Demo(30);
    Demo d3 = new Demo(30,40);
    d1.display();
    d2.display();
    d3.display();
 }
}

Passo 2) Salve, compile e execute o código.

Passo 3) Erro = ?. Tente depurar o erro antes de prosseguir para a próxima etapa de sobrecarga do construtor Java

Passo 4) Cada classe tem um padrão Construtor em Java. Construtor Java sobrecarregado padrão para aula de demonstração is Demonstração(). Caso você não forneça este construtor, o compilador o cria para você e inicializa as variáveis ​​com os valores padrão. Você pode optar por substituir esse construtor padrão e inicializar as variáveis ​​com os valores desejados, conforme mostrado no Exemplo 1.

Mas se você especificar um construtor parametrizado como Demo(int a) e quiser usar o construtor padrão Java Demo(), é obrigatório especificá-lo.

Em outras palavras, caso seu construtor de sobrecarga em Java seja substituído e você queira usar o construtor padrão Java, ele precisa ser especificado.

Passo 5) Remova o comentário da linha 4-8. Salve, compile e execute o código.

Encadeamento de Construtor

Considere um cenário em que uma classe base é estendida por um filho. Sempre que um objeto da classe filha é criado, o construtor da classe pai é invocado primeiro. Isso é chamado Encadeamento de construtor.

3 exemplo: Para entender o encadeamento de construtores

Passo 1) Copie o seguintewing código no editor.

class Demo{
   int  value1;
   int  value2;
    Demo(){
      value1 = 1;
      value2 = 2;
      System.out.println("Inside 1st Parent Constructor");
   }
   Demo(int a){
      value1 = a;
      System.out.println("Inside 2nd Parent Constructor");
   }
  public void display(){
     System.out.println("Value1 === "+value1);
     System.out.println("Value2 === "+value2);
  }
  public static void main(String args[]){
     DemoChild d1 = new DemoChild();
     d1.display();
  }
}
class DemoChild extends Demo{
    int value3;
    int value4;
    DemoChild(){
    //super(5);
     value3 = 3;
     value4 = 4;
    System.out.println("Inside the Constructor of Child");
    }
    public void display(){
      System.out.println("Value1 === "+value1);
      System.out.println("Value2 === "+value2);
      System.out.println("Value1 === "+value3);
      System.out.println("Value2 === "+value4);
   }
}

Passo 2) Execute o código. Ówing para o encadeamento de construtores, quando o objeto da classe filha DemoChild é criado, o construtor Demo() da classe pai é invocado primeiro e later o construtor DemoChild() do filho é criado.

Resultado esperado:

Inside 1st Parent Constructor
Inside the Constructor of Child
Value1 === 1
Value2 === 2
Value1 === 3
Value2 === 4

Passo 3) Você pode observar que o construtor da classe pai Demo foi substituído. E se você quiser chamar o construtor substituído Demo(int a) em vez do construtor padrão Demo() quando seu objeto filho for criado?

Nesses casos, você pode usar a palavra-chave "super" para chamar construtores substituídos da classe pai.

Sintaxe:-

super();
--or--
super(parameter list);

Exemplo: Se o seu construtor for como Demonstração(Nome da String,int a), você especificará super(“Java”,5). Se usada, a palavra-chave super precisa ser a primeira linha do código no construtor da classe filha.

Passo 4) Remova o comentário da linha 26 e execute o código. Observe a saída.

Saída:

Inside 2nd Parent Constructor
Inside the Constructor of Child
Value1 === 5
Value2 === 0
Value1 === 3
Value2 === 4