Construtores - Java

Hoje vou falar sobre construtores:

Construtores são esses caras que constroem as coisas, ou melhor, objetos. Não estranhe a foto que usei para ilustrar esse post, é apenas uma homenagem ao homem trabalhador. Aquele que trabalha sob o sol, pegando no pesado, para construir nossos lares e etc. Bom, mas não vamos nos desviar do assunto.

Uma coisa é verdade: toda classe em java tem pelo menos um construtor(até abstratas, enums), exceto interfaces. Decore isto.

Mas é claro que interfaces não tem construtores, elas não fazem nada! Mas não subestime-as, elas são importantes para fornecer um acoplamento fraco entre as classes. Outro dia vou abordar este assunto.

Então mais uma vez: Todas as classes (até os enums) tem pelo menos um construtor, exceto as interfaces.

Mas o que são esses construtores? Um construtor é um "método" que é executado sempre que uma classe é instanciada. Toda vez que você digitar a palavra chave new o construtor será executado e inicializará o objeto. As vezes passamos algum parâmetro tipo new (2, 2, 2) .

Quando fazemos isto estamos inicializando a classe com os dados parâmetros. O construtor serve para inicializar as variáveis de instância da classe, como também executar códigos legais toda vez que inicializar uma classe. Entenda códigos legais como coisas que você gostaria que fossem executadas toda vez que criar um objeto, ficou claro?

Vamos ver o que é um construtor na prática:

class A {
 A(){
  super(); 
  System.out.println("Executou construtor A");
  //Códigos legais aqui
 }
}

Veja que o construtor é como um método mas ele não tem um tipo de retorno, nem void. Também tem o mesmo nome da classe e sempre terá. Ele pode ter modificador de acesso, até private (mas saiba das implicações disto). O compilador criará automaticamente um construtor igual o mostrado acima caso você não codifique nenhum. Porque ele faz isto? 

Todo construtor executa primeiramente uma chamada super() ou this() dependendo do caso, quando executado. Somente uma dessas chamadas é válida antes do resto. Mesmo que você não coloque explicitamente, o compilador irá colocar um super() pra você porque em algum momento ele vai ter que inicializar sua superclasse antes de inicializar a classe em si. 

Então você deve se perguntar se a classe A tem uma superclasse porque não está herdando de ninguém. Errado! Todas as classes herdam de Object implicitamente. Object é tipo uma classe "mãe" no Java (ela fornece métodos como equals por exemplo).

Se temos duas classes A e B, com B herdando A, quando criamos uma instância de B os construtores são executados em forma de pilha: B chama A e A chama Object. Object é executado, A é executado e por último B:

OBJECT
A
B

Mais adiante vou mostrar o resultado disto. Antes de continuar vamos rever alguns conceitos. Quando você digitar:

class A {
}

Seu compilador irá adicionar automaticamente o construtor:

class A {
 A(){
  super(); 
 }
}

O contrutor criado por ele sempre será sem argumentos. E se digitar só:

class A {
 A(){
 }
}

Não tem problema, o compilador adicionará o super();
O compilador só não vai fazer nada se for adicionado um construtor sobrecarregado:

class A {
 A(String s){
  super(); 
  System.out.println("Executou construtor A");
  //Códigos legais aqui
 }
}

Isso mesmo! Construtores podem ser sobrecarregados (mas não sobrescritos porque não são herdados), mas lembre-se:

Se houver um construtor sobrecarregado qualquer, o compilador não vai criar outro automaticamente. 

Sabendo disto você não cairá em pegadinhas do tipo:

class A {
 A(String s){
  super(); 
  System.out.println("Executou construtor A");
  //Códigos legais aqui
 }
}

public class B extends A{
 
 public static void main(String[] args) {
  new B();
 }
 
}

Acontece que a classe B possui aquele construtor automático que falei anteriomente. E na classe A, por ter definido um construtor sobrecarregado, não temos o construtor padrão sem argumentos, então código não compila:

Exception in thread "main" java.lang.Error: Unresolved compilation problem:
Implicit super constructor A() is undefined for default constructor. Must define an explicit constructor

at B.(B.java:10)
at B.main(B.java:13)

Sempre tente detectar isto quando uma questão abordar construtores e como funciona a pilha. Logicamente o código terá mais alguma lógica obscura tentando lhe desviar do problema e tentando esconder o obvio. Neste caso, para resolver o problema, você mesmo deve criar construtor em A sem argumentos ou em B passando o parametro como pede:

 B(String s) {
  super(s);
 }

E a chamada a B deverá ser:

  new B(null);

Veja que o construtor de B recebe o parâmetro e o passa para a superclasse, isto é perfeitamente possível.

Um ponto importante é que nada pode ser feito sem que o construtor seja executado. Nenhum acesso a variável de instância ou método antes que o super() final seja chamado e construa Object. Isto que dizer que um objeto não pode ser utilizado até ser inicializado, o que é obvio, mas também significa que você não pode tentar sabotar o construtor do objeto antes de chamar super():

class A {
 A(String s){
  System.out.println("Antes de executar o super de Object");
  super(); // Problema!!!
  System.out.println("Executou construtor A");
  //Códigos legais aqui
 }
}

Outra coisa é que um construtor pode chamar outro. Um construtor só pode ser chamado dentro de outro. Isto que dizer que ou você chama outro construtor da mesma classe que tenha sido sobrecarregado utilizando o this() ou chama o da superclasse utilizando super(). Como já foi dito, somente uma dessas chamadas poderá ser feita dentro do contrutor e deverá ser a primeira coisa a ser feita.

public class B{
 B() {
  super();
  System.out.println("Executou o construtor padrão.");
 }

 B(String s){
  this();
  System.out.println("Chamou o construtor padrão.");
 }
 
 public static void main(String[] args) {
  new B(null);
 }
}

Veja que o código produz a seguinte saída:

Executou o construtor padrão.
Chamou o construtor padrão.

A saída é "invertida" por causa da pilha. O main chamou o construtor B sobrecarregado, antes de qualquer coisa ele chamou B padrão que chamou super(). Então Object foi criado e volta pra B padrão, então é executado. Volta para o B sobrecarregado e mostra que "Chamou.." no final, ele ja tinha chamado mas estava esperando os outros.

Agora veja o seguinte exemplo:

class A {
 void A(){
  super();
  System.out.println("Executou construtor A");
  //Códigos legais aqui
 }
}

O que tem de errado com a classe? Não... aquilo não é um construtor, é apenas um método qualquer porque ele tem um tipo de retorno e construtores não tem. Tome cuidado.

Só pra finalizar o post porque já está ficando cansativo, analise este código:

class A {
 A(){
  System.out.println("A");
 }
}

class B extends A{
 B() {
  System.out.println("B");
 }
}

public class C extends B{
 C() {
  System.out.println("C");
 }
 
 public static void main(String[] args) {
  new C();
 }
}

Qual será a saída?? Não vou responder...
Bons estudos e até a próxima!