Construtor padrão e com parâmetros: o que são, para que servem e como usar

Você reparou que, no tutorial passado, sobre como declarar e criar classe e instanciar objetos, nós fizemos:
Aluno fulano = new Aluno();

Você reparou como repetimos 'Aluno' duas vezes?
Por que? Não é inútil ou perda de tempo repetir isso?

Em Java - aliás, em programação - nada é à toa (se for, logo eles mudam). Tudo tem um motivo.

Nesse artigo você irá aprender sobre os Construtores (constructors) e saberá o motivo dessa repetição e como usufruir e ganhar muito tempo a partir deles


As explicações e exemplos deste tutorial são baseadas nos outros artigos desta seção:
O que são e para que servem Classes e Objetos em Java
Como criar uma Classe e declarar um Objeto
Acessando e modificando variáveis de Classes e Objetos

O que são construtores/constructor em Java


Quando usamos a keyword 'new' para criar um objeto de uma determinada classe estamos alocando um espaço na memória. Ao fazer isso, o Java requer que algumas variáveis sejam iniciadas com algum valor.
Esse ato de inicializar, ou construir, é feito pelos construtores, que são métodos - que iremos estudar mais a fundo em nossa apostila de Java logo mais.

O Java automaticamente inicializa as variáveis globais quando criamos um objeto de uma classe.
No artigo passado de nossa apostila, fizemos um exemplo com a classe "Aluno", onde criamos três variáveis: "nome", "notaMat" e "notaFis", que são consideradas variáveis globais da classe, pois não fazem parte de nenhum método.

Logo, elas devem ser inicializadas pelo Java. Para você ver como isso realmente acontece, vá na sua classe principal, que contém a 'main', e após a criação do objeto "patropi" da classe "aluno" adicione as seguintes linhas de código, de print, para você ver como essas variáveis da classe já possuem um valor, sem nem mesmo você ter atribuído nada:
Aluno patropi = new Aluno();
System.out.println(patropi.nome);
System.out.println(patropi.notaMat);
System.out.println(patropi.notaFis);

O resultado é:
null
0.0
0.0

Ou seja, por padrão, as strings são iniciadas com valores 'null' (nulos) e valores zeros para números.
Isso é o que ocorre automaticamente, quando nenhum construtor é especificado. Vamos mostrar como especificar construtores.


O que é e como utilizar o construtor padrão em Classes


Construtor é um método, em Java.
Embora não tenhamos estudado métodos ainda, diremos como utilizar. É bem simples, e em breve você aprenderá tudo sobre método em nosso curso de Java.

Métodos são um trecho de código que fazem uma coisa específica, em programação. Se já estudou C ou C++, lá eles são chamados de funções ou de rotinas ou sub-rotinas em outras linguagens, como Perl.

Podemos criar vários construtores. O padrão é aquele que não recebe nenhum parâmetro.
Em termos mais simples, é aquele que não recebe nenhuma informação. Ele sempre vai ser executado quando você criar um objeto.

Para criar um construtor, crie um método com o mesmo nome da classe.
Métodos tem a seguinte sintaxe:
nomeDoMetodo( tipoDoParametro nomeDosParametros) {
 // código dos métodos
}

Como nossa classe se chama "Aluno", nosso método é um construtor dessa classe e ela é padrão (não recebe parâmetros) e é 'public', ficará assim:
public Aluno(){
}

Para melhor visualizar a utilidade do construtor padrão, vamos adicionar um print:

public Aluno(){
        System.out.println("Objeto criado");
}

Ao rodar seu programa, você verá a mensagem "Objeto criado" sendo exibida logo após ter criado o objeto "patropi".
Esse método é chamado construtor default. Ao contrário do que muitos pensam, default não é padrão (embora usemos muito como se fosse).
Default é omissão. Quando estamos omitindo outros construtores - que recebem parâmetro - é esse construtor 'padrão' (default) que será chamado.

Note que ao criar o objeto, usamos "new Aluno();"  - logo, não passamos nenhum parâmetro. Então, chamamos claramente o construtor padrão.


Criando um construtor que recebe parâmetros


No nosso aplicativo que cadastro um aluno, seu nome e duas notas, estamos atribuindo os valores dessas variáveis direto no objeto:
patropi.nome = entrada.nextLine();
patropi.notaMat = entrada.nextDouble();
patropi.notaFis = entrada.nextDouble();

O que vamos fazer agora, para ilustrar como funciona os construtores que recebem parâmetros, é pedir esses dados antes e iniciar o objeto "patropi" com esses dados.
Por exemplo, vamos criar as variáveis "Nome", "NotaMat", "NotaFis" na 'main' e receber esses dados pela Scanner:
Nome = entrada.nextLine();
NotaMat = entrada.nextDouble();
NotaFis = entrada.nextDouble();

Agora vamos criar nosso construtor na classe "Aluno" que recebe esses três parâmetros: uma string e dois doubles.
Ele vai ficar assim:
public Aluno(String Nome, double NotaMat, double NotaFis){
        nome=Nome;
        notaMat=NotaMat;
        notaFis=NotaFis;
}



Isso pode parecer um pouco estranho ou complicado agora, mas quando estudar melhor métodos, fará todo o sentido do mundo e verá como é simples.
O que esse método faz é receber uma string "Nome", dois doubles "NotaMat" e "NotaFis" e atribuir eles aos valores da classe aluno.

Veja que nossa classe tem uma variável string "nome" e dois doubles "notaMat" e "notaFis", que seriam inicializados com 'null' e '0.0', conforme mostramos no início deste tutorial.
O que estamos fazendo com esse método é inicializar estas variáveis com outros valores! E que valores são estes? Ora, são os valores das variáveis "Nome" e "NotaMat" e "NotaFis", que definimos a partir da classe Scanner no método 'main'.

Embora estejamos engatinhando na orientação a objeto, vamos fazer uma coisa interessante e mostrar o quão poderosa e útil essa técnica é. Vamos adicionar na classe uma variável, um double de nome "media", e no construtor vamos adicionar uma linha de código:
media = (notaMat + notaFis)/2;

Ou seja, nosso construtor vai ficar:
public Aluno(String Nome, double NotaMat, double NotaFis){
        nome=Nome;
        notaMat=NotaMat;
        notaFis=NotaFis;
     
        media = (notaMat + notaFis)/2;
}


O que quer dizer isso?
Que quando iniciarmos nosso objeto com as notas, esse método vai automaticamente calcular a média dessas notas!
Você pode pensar "Mas já fazíamos isso na 'main', durante o print. Não é a mesma coisa?".
Imagine que você vai preencher os dados de 20 alunos.

Então vai colocar 20 vezes essa fórmula? Claro que não.
Aí é que reside a beleza das Classes & Objetos. Você declara essa fórmula uma única vez, e poderá usar ela sempre que criar um objeto!
Criou o objeto, iniciou ele com as variáveis, ele vai calcular automaticamente a média!
Para acessar essa variável basta fazer: patropi.media
E ela estará lá, bonitinha para você usar.


Como iniciar Objetos com parâmetros


Agora que criamos nossos métodos construtores padrão e com parâmetros, vamos mostrar como iniciar um objeto com dados.

No construtor padrão, vínhamos fazendo:
Aluno patropi = new Aluno();

Agora, que já temos as variáveis "Nome", "NotaMat" e "NotaFis" e um construtor que está preparado para receber esses três tipos de dados, podemos criar um objeto e lançar essas variáveis:
Aluno patropi = new Aluno( Nome, NotaMat, NotaFis);

Note que você só deve criar esse objeto depois de ter essas variáveis com os valores corretos, senão vai iniciar o objeto com valores errados.

Um detalhe importante é que o nome dessas variáveis, "Nome", "NotaMat" e "NotaFis", não precisam ser iguais aos nomes que declaramos lá no construtor da classe "Aluno". Poderíamos passar:
Aluno patropi = new Aluno( name, math, phys);

Desde que "name" seja uma string e "math" e "phys" doubles. Quando elas 'chegam' no construtor, elas 'chegam' com os nomes "Nome", "NotaMat" e "NotaFis".
Você se acostumará melhor sobre isso quando estudar métodos.


Classes com mais de um construtor

O que ocorre se deixarmos o construtor: Aluno()
e o construtor: public Aluno(String Nome, double NotaMat, double NotaFis)
juntos, na classe "Aluno"?

Nada. Aliás, é até recomendável. É um excelente costume.
Se você iniciar um objeto dessa classe sem nenhum parâmetro, o Java inicia o método construtor padrão (que mostra a mensagem "Objeto criado".
Se iniciar um objeto com 3 parâmetros, ele atribui esses valos que você passou aos valores do objeto e ainda calcula a média.
Você pode ainda criar outros métodos, que recebem só o nome do aluno, só a nota de matemática ou só de a física.

Enfim, os construtores são feitos para inicializar os atributos e preparar o objeto para o uso, seja lá qual for o uso que você queira dar. Se você utilizar vários construtores, o Java é inteligente o suficiente para saber qual método utilizar dependendo dos parâmetros que você passar.
Obviamente se criar dois construtores com a mesma lista de parâmetros, terá problemas.

Para mostrar um exemplo do uso de dois construtores - o padrão e o que recebe 3 parâmetros - , vamos criar dois objetos, o "donaFifi", logo no início, e veremos a mensagem "Objeto criado".
Depois pedimos os dados do aluno patropi e inicializamos o objeto "patropi" com esses dados. Em seguida, usamos as variáveis do objeto desse aluno, inclusive sua média, que foi calcula pelo construtor.

Veja como ficou o código:

PrimeiraClasse.java
import java.util.Scanner;
        
public class PrimeiraClasse {

    public static void main(String[] args) {
        Aluno donaFifi = new Aluno();
        String nome;
        Double notaMat,
               notaFis;
        
        Scanner entrada = new Scanner (System.in);
        
        System.out.print("Nome do aluno: ");
        nome = entrada.nextLine();
        
        System.out.print("Nota em Matemática: ");
        notaMat = entrada.nextDouble();
        
        System.out.print("Nota em Física: ");
        notaFis = entrada.nextDouble();
        
        Aluno patropi = new Aluno(nome, notaMat, notaFis);
        System.out.printf("O aluno \"%s\" tirou %2.2f em Matemática, "
                + "%2.2f em Física e obteve média %2.2f\n", patropi.nome,
                                                            patropi.notaMat,
                                                            patropi.notaFis,
                                                            patropi.media);
    }
}



Aluno.java
public class Aluno {
    public String nome;
    public double notaMat,
                  notaFis,
                  media;
   
    public Aluno(){
        System.out.println("Objeto criado");
    }
   
    public Aluno(String Nome, double NotaMat, double NotaFis){
        nome=Nome;
        notaMat=NotaMat;
        notaFis=NotaFis;
       
        media = (notaMat + notaFis)/2;
    }
}


7 comentários:

Mais Informática disse...

O melhor curso de java que vi até agora. Prático, sem frescuras e numa linguagem concisa e de fácil compreensão. Parabéns ao(s) construtor(es), quer dizer, autor(es)..rsrsrs

Luiz disse...

Os artigos estão muito claros, para quem está querendo aprender a programar indico o blog pela didática e exemplos de fácil compreensão. Parabéns

Anônimo disse...

Bom demais! Parabéns!

Anônimo disse...

Cara, eu adoro esse curso!

Java Progressico tem meu total respeito! :D

brainiac marco disse...

import java.util.Scanner;

public class alunoClasse {

public static void main(String[] args) {
//objeto patropi
Aluno patropi = new Aluno(); // puxa variaveis da classe Aluno
Scanner entrada = new Scanner (System.in);

System.out.print("Nome do aluno: ");
patropi.nome = entrada.nextLine();

System.out.print("Nota em Matemática: ");
patropi.notaMat = entrada.nextDouble();

System.out.print("Nota em Física: ");
patropi.notaFis = entrada.nextDouble();

//Exibindo os dados
System.out.printf("O aluno \"%s\" tirou %2.2f em Matemática, "
+ "%2.2f em Física e obteve média %2.2f\n", patropi.nome,
patropi.notaMat,
patropi.notaFis,
(patropi.notaMat+patropi.notaFis)/2);
//Objeto donaFifi
Aluno donaFifi;
donaFifi = new Aluno();
Scanner entra = new Scanner (System.in);

System.out.print("Nome do aluno: ");
donaFifi.nome = entra.nextLine();

System.out.print("Nota em Matemática: ");
donaFifi.notaMat = entra.nextDouble();

System.out.print("Nota em Física: ");
donaFifi.notaFis = entra.nextDouble();

//Exibindo os dados
System.out.printf("O aluno \"%s\" tirou %2.2f em Matemática, "
+ "%2.2f em Física e obteve média %2.2f\n", donaFifi.nome,
donaFifi.notaMat,
donaFifi.notaFis,
(donaFifi.notaMat+donaFifi.notaFis)/2);
}
}

Anônimo disse...

Claudio Lopes - Sou autodidata, tenho estudado sozinho através de material colhido na Internet, mas é a primeira vez que encontrei um material igual a este. Estou indo passo a passo, muito obrigado vocês são nota 10.

Herderson Couto disse...

Execelente conteúdo, parabéns.

Sabe quanto custa um bom livro de java?
Entre R$ 100,00 e R$300,00

Sabe quanto custa um bom curso presencial de Java?
Entre R$ 1.500,00 até R$ 4.000,00

Sabe quanto custa estudar pelo Java Progressivo?
Absolutamente nada.

Porém, também precisamos de sua ajuda e apoio.
Para isso, basta curtir nossa Fan Page e clicar no botão G+ do Google.