Conteúdo do Curso
Java Avançado
Java Avançado
Construtor
Como simplificar a inicialização de classes?
Inicializar cada campo toda vez pode ser trabalhoso. Para esses casos, as classes possuem construtores. A sintaxe para um construtor é a seguinte:
Main.java
modifier ClassName(ParameterType parameter1, ParameterType parameter2) { this.parameter1 = parameter1; this.parameter2 = parameter2; }
Análise de cada termo apresentado:
modifier: Refere-se ao modificador de acesso, que geralmente épublicpara construtores. Situações em que um construtor pode ter outro modificador de acesso serão abordadas em curso separado;ClassName: Nome da classe na qual o construtor está sendo criado;ParameterType: Tipo do parâmetro utilizado no construtor. É importante atentar-se, pois esse parâmetro deve ser do mesmo tipo do campo na classe; Por exemplo: Se a classe possui dois parâmetros,String nameeint age, então o construtor deve ter os mesmos parâmetros (caso seja necessário inicializar todos os campos pelo construtor). Caso seja necessário inicializar apenas um campo específico da classe pelo construtor, por exemplo,name, deve-se utilizar apenas um parâmetro com o mesmo tipo e nome do campo na classe;- Em seguida, dentro do corpo do construtor, os valores são atribuídos aos campos da classe utilizando os valores passados como parâmetro.
Palavra-chave "this"
Com a ajuda da palavra-chave this, é possível referenciar o campo da classe no qual escrevemos o valor dessa palavra-chave. Por exemplo, quando temos uma classe com dois campos: name e age, podemos escrever this.name dentro do construtor ou método, e isso irá se referir especificamente ao campo da classe, e não à variável local passada como parâmetro para esse construtor ou método. Dessa forma, é possível inicializar os campos da classe por meio do construtor utilizando a sintaxe: this.name = name;.
Exemplo
Veja um exemplo de construtor em uma classe que nos ajuda a inicializar todos os campos para tornar mais claro:
Person.java
class Person { String name; int age; String gender; public Person(String name, int age, String gender) { this.name = name; this.age = age; this.gender = gender; } }
Temos uma classe chamada Person com três campos. Cada um desses campos foi adicionado ao construtor utilizando a palavra-chave this. Portanto, o construtor inicializa os campos com os valores dos parâmetros. Vamos utilizar esse construtor no método main para que você possa ver que os campos são inicializados com o que passamos como parâmetros:
Main.java
package com.example; class Person { String name; int age; String gender; public Person(String name, int age, String gender) { this.name = name; this.age = age; this.gender = gender; } } public class Main { public static void main(String[] args) { Person bob = new Person("Bob", 20, "Male"); System.out.println("Bob's name: " + bob.name + ", Bob's age: " + bob.age + ", Bob's gender: " + bob.gender); } }
Inicializamos o objeto Person chamado bob utilizando o construtor ao passar o name, age e gender como parâmetros. Em seguida, imprimimos seus parâmetros na tela e verificamos que o objeto possui os valores dos campos conforme especificado nos parâmetros do construtor.
Sobrecarga de construtor
O construtor também pode ser sobrecarregado e não abranger a inicialização de todos os campos da classe. Por exemplo, se não quisermos especificar o gênero de Alice, podemos sobrecarregar o construtor para aceitar apenas 2 parâmetros e inicializar os campos com eles:
Main.java
package com.example; class Person { String name; int age; String gender; public Person(String name, int age, String gender) { this.name = name; this.age = age; this.gender = gender; } public Person(String name, int age) { this.name = name; this.age = age; } } public class Main { public static void main(String[] args) { Person bob = new Person("Bob", 20, "Male"); System.out.println("Bob's name: " + bob.name + ", Bob's age: " + bob.age + ", Bob's gender: " + bob.gender); Person alice = new Person("Alice", 17); System.out.println("Alice's name: " + alice.name + ", Alice's age: " + alice.age); } }
Pode-se concluir que um construtor, assim como um método, pode ser sobrecarregado e aceitar diferentes quantidades e tipos de parâmetros.
Construtor padrão
Um construtor padrão é um construtor que não recebe parâmetros e não inicializa nenhum campo. Ele existe em todas as classes por padrão se elas não possuírem outro tipo de construtor, por isso é chamado de construtor padrão. Sempre que criamos um objeto de qualquer classe, utilizamos um construtor. Para utilizar o construtor padrão quando já existe um construtor que aceita parâmetros, também é necessário escrever um construtor vazio:
Main.java
package com.example; class Person { String name; int age; String gender; public Person(String name, int age, String gender) { this.name = name; this.age = age; this.gender = gender; } public Person(String name, int age) { this.name = name; this.age = age; } public Person() { } } public class Main { public static void main(String[] args) { Person bob = new Person("Bob", 20, "Male"); System.out.println("Bob's name: " + bob.name + ", Bob's age: " + bob.age + ", Bob's gender: " + bob.gender); Person alice = new Person("Alice", 17); System.out.println("Alice's name: " + alice.name + ", Alice's age: " + alice.age); Person john = new Person(); System.out.println("John's name: " + john.name + ", John's age: " + john.age); } }
Utilizamos 3 construtores diferentes para inicializar cada um dos objetos Person. Como podemos ver no último exemplo, John não possui nome nem idade porque esses campos não foram inicializados para o objeto. Assim, é possível sobrecarregar o construtor quantas vezes forem necessárias e criar objetos por meio dele.
1. Qual das seguintes afirmações sobre construtores é verdadeira?
2. Qual é o propósito de um construtor em Java?
3. Qual dos seguintes trechos de código demonstra a forma correta de criar um construtor parametrizado?
Obrigado pelo seu feedback!
