Enviar um café pro programador

Pode me ajudar a transformar cafeína em código?

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

21 comentários:

Rafael Ramos 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

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.

Unknown disse...

Execelente conteúdo, parabéns.

junior disse...

Muito boa essas aulas estou acompanhando e criando meus próprios códigos creio estar indo muito bem valeu pelo bom conteúdo disponiibilizado.
Meu código dessa aula:
public class PrimeiraClasse
{
public static void main(String[] Args)
{
Aluno jair= new Aluno("Jair Ferreira Camilo", "Rua Martinho Fontes", 9060101, 33242004);

System.out.println(jair.nome);
jair.getAluno();

}
}

import java.util.Scanner;
public class Aluno
{
String nome, endereco;
int cpf, telefone;

public Aluno (String nom, String enderec,int cp,int telefon)
{
nome= nom;
endereco=enderec;
cpf=cp;
telefone=telefon;
}
public void getAluno()
{
System.out.println("Aluno: "+ nome);
System.out.println("Endereco: "+ endereco);
System.out.println("CPF: "+ cpf);
System.out.println("Telefone: "+ telefone);
}
public void setAluno()
{
Scanner entrada= new Scanner(System.in);
System.out.println("Informe o nome do aluno:");
nome= entrada.next();
System.out.println("Informe o endereco do aluno:");
endereco= entrada.next();
System.out.println("Informe o cpf do aluno:");
cpf= entrada.nextInt();
System.out.println("Informe o telefone do aluno:");
telefone= entrada.nextInt();


}

}

Unknown disse...

Opa, bom dia! P\ que serve apenas o construtor vazio se eu não criar um construtor com parametros? A ideia da pergunta é: To instanciando em um managedbean e com construtor ou não no model não percebi diferença alguma.
Desde já obrigado!

Ekrausz disse...

Muito bom o curso, já aprendi bem mais aqui do que eu aprendi no curso q fiz antes...(ta certo que tive q ler essa pagina 7X pra fixar bem) mas finalmente consegui e decidi compartilhar meu alivio de finalmente entender rsrsrsrsrs.

Meu Wifi tá um lixo disse...

Até agora tava pegando super bem a matérias, mas não to conseguindop digerir as informaçoes daqui... to bem perdido, algumas coisas nao ficaram claras pra mim, começou a complicar na parte de Criando um construtor que recebe parâmetros , nao entendi onde usar as Variaveis:
Nome = entrada.nextLine();
NotaMat = entrada.nextDouble();
NotaFis = entrada.nextDouble();

fica com aviso de erro se coloco depois do main... cara to com aquela agonia de estar preso em algo e nao conseguir entender, se algm poder me ajudar, nem q seja por email, pelo amor de Deus... hehehehehehhe

orehganu@gmail.com
por favor agradeço desde jah.... pq to gostando muito de aprender Java =D

Clebson disse...

Bem, gosto muito desse curso, tanto que já salvei a maioria das paginas para estudar em offline quando fica sem internet rsrs
estou criando meu proprio projeto, mas como ainda estou no inicio do curso ainda nao sei muita coisa.
estava tendo problemas quanto a criar uma parte do projeto que pedia um usuario (String) e senha (String, para usar letras e numeros). O problema é que eu prefiro deixar o usuario e a senha em uma outra classe (classe Users) separada da 'main', por julgar mais seguro. Depois de ler e reler algumas vezes a parte 'Acessando e modificando variáveis de Classes e Objetos' acabei conseguindo atribuir os valores das variaveis que estavam dentro da 'Users' na 'main'.
Obrigado pelo curso!

Anônimo disse...

aiaiai...
tá começando a ficar puxado :)

Alguém disse...

para o DarkStar e quem mais sentiu dificuldades.
Eu tbm tive e quebrei a cabeça até chegar a um resultado de acordo com o q está sendo ensinado.
Então, o código ficou assim:

(//A partir do main da classe principal: PrimeiraClasse)

public static void main(String[] args) {
Scanner entrada = new Scanner (System.in);

String Nome = entrada.nextLine();
double NotaMat = entrada.nextDouble();
double NotaFis = entrada.nextDouble();


Aluno patropi = new Aluno(Nome, NotaMat, NotaFis);
System.out.println(patropi.media);
_________

(//agora, na classe Aluno, o código inteiro ficou assim:)

package primeiraclasse;

public class Aluno {

public Aluno(String Nome, double NotaMat, double NotaFis){
nome=Nome;
notaMat=NotaMat;
notaFis=NotaFis;
this.media = (notaMat + notaFis)/2;
}

public String nome;
public double
notaMat,
notaFis,
media ;
}
_______

Caso devesse ter ficado diferente, eu peço ajuda, hehehe.

Anônimo disse...

My Name: Gabriel Silvio

Não entendi muito bem a partir da parte "Como Iniciar Construtores que recebem parâmetro...
public Aluno(String Nome, double NotaMat, double NotaFis){
nome=Nome;
notaMat=NotaMat;
notaFis=NotaFis;
}

Não entendi o porque nome recebe Nome, notaMat recebe NotaMat, etc. E em momento algum usamos essas variaveis com inicial maiúscula... se alguém puder me ajudar....

Grupo Xadrez disse...

Boa noite, Aqui e o Etevaldo, tenho uma duvida, Crie uma classe que esta deva possuir:
Construtor que os atributos são: Código, Nome do Cliente, Descrição do pedido e os métodos são: Modifica o nome do cliente, modifica a descrição do pedido, Retorna o nome do cliente..

Anônimo disse...

Cara, muito bom.
Infelizmente tive que trancar a faculdade mais decidi voltar a estudar alguma linguagem de programação por conta própria, acabei chegando no seu site e que site!
Vlw por dedicar seu tempo para ensinar, ótimo curso!!!

Unknown disse...

import java.util.Scanner;

public class PrimeiraClasse {

public static void main(String[] args) {

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("Nome: %s Nota Mat: %2.2f Fis: %2.2f Media: %2.2f \n", patropi.nome,
patropi.notaMat,
patropi.notaFis,
patropi.media);
}

///////////////Classe aluno

package primeiraclasse;



public class Aluno {
public String nome;
public double notaMat, notaFis, media ;


public Aluno(String Nome, double NotaMat, double NotaFis){
nome=Nome;
notaMat=NotaMat;
notaFis=NotaFis;

media = (notaMat + notaFis)/2;
}
}

Unknown disse...

Realmente tem pessoas que sabem passar conhecimento envolvendo conceitos complexos de maneira transparente e inteligível para os iniciantes. Parabens! Muito bom curso!!

Unknown disse...

public Aluno(String Nome, double NotaMat, double NotaFis){
nome=Nome;
notaMat=NotaMat;
notaFis=NotaFis;

media = (notaMat + notaFis)/2;
}

Olá! pode me tirar uma dúvida?
Criei a classe, criei a main, tudo igual ao texto.. mas na hora de imprimir a média gerada por esse método construtor ela sai 0.0... pode me ajudar? detalhe que o Scanner está com nextDouble(); também em ambas as notas.. e quando eu testo se salvou a nota na variável do objeto, elas salvam. Exemplo: quero testar se a notaMat recebeu a nota 8. Digito 8, depois imprimo o conteúdo dessa variável. Dá certo, só falta a parte da média. Consegue me explicar?

Anônimo disse...

Estive verificando em alguns livros. Construtor NÃO É UM MÉTODO

Contribuir com o Java Progressivo

Que tal apoiar e fazer crescer o ensino da programação no Brasil ?

Ajudar nosso país a crescer e se desenvolver cada vez mais, tecnologicamente?

Clica abaixo pra saber mais!

Apoiar o Projeto Progressivo


Tutoriais de Java