Conteúdo do Curso
Java Avançado
Java Avançado
Getter e Setter
A melhor maneira de contornar o modificador de acesso private
Todos os programadores Java utilizam construções chamadas getters e setters.
Getters e setters são métodos que seguem um padrão específico. Eles são usados para contornar o modificador de acesso private e manipular campos de outra classe de forma eficaz.
O que fazem getters e setters?
De forma simples, o setter permite atribuir um valor a um campo específico protegido pelo modificador de acesso private, enquanto o getter permite recuperar o valor de um campo protegido pelo modificador de acesso private.
A sintaxe para um getter e um setter:
Main.java
// getter public fieldType getFieldName() { return field; } // setter public void setFieldName(fieldType field) { this.field = field; }
Como pode ser visto no código acima, utilizamos a convenção de nomenclatura para os métodos getFieldName() e setFieldName(). Portanto, se tivermos um campo private String name e criarmos um getter e um setter com os nomes getName() e setName(), respectivamente. Vale ressaltar também que o getter retorna um valor do mesmo tipo do campo name, enquanto o setter recebe um parâmetro do mesmo tipo do campo name.
Isso nos permite acessar campos que estão protegidos pelo modificador de acesso private.
Vamos analisar um exemplo de acesso a um campo private da classe Person na classe main:
Main.java
package com.example; public class Main { public static void main(String[] args) { Person bob = new Person(); bob.setName("Bob"); System.out.println(bob.getName()); } } class Person { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } }
Como pode ser observado, utiliza-se o setter para definir um valor para o campo name, e em seguida utiliza-se o getter para exibir o valor do campo name na tela. Atenção à sintaxe do getter e setter, bem como ao fato de que o campo name na classe Person está protegido pelo modificador de acesso private.
Construtor vs Getter/Setter
Qual é a melhor abordagem: inicialização por meio de um construtor + sobrescrita do método toString(), ou utilização de getters e setters?
É preferível utilizar getters e setters para acessar campos protegidos pelo modificador de acesso private. Isso proporciona maior flexibilidade ao código e melhora sua legibilidade. Ao visualizar o uso do método getName() no código, entende-se imediatamente que esse método recupera o campo chamado name. O mesmo ocorre ao observar o uso do método setName(), compreende-se de imediato que está sendo atribuído um valor específico ao campo do objeto da classe em que é utilizado. Se outras pessoas lerem seu código, ficarão satisfeitas ao encontrar getters e setters.
Vale ressaltar também que cada campo necessita de seu próprio getter e setter. Se uma classe possui dois campos protegidos pelo modificador de acesso private, a classe deve conter um getter para cada campo, ou seja, dois getters e dois setters.
Vamos analisar um exemplo em que adicionamos um campo age à classe Person:
Main.java
package com.example; public class Main { public static void main(String[] args) { Person bob = new Person(); bob.setName("Bob"); bob.setAge(27); System.out.println("Person's name: " + bob.getName() + ", Person's age: " + bob.getAge()); } } class Person { private String name; private int age; public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } }
Como você pode ver, criamos um getter e um setter para cada campo da classe Person. No método main, inicializamos os campos utilizando o setter e exibimos seus valores na tela utilizando o getter. O uso desses métodos é muito conveniente, e você irá utilizá-los com frequência no futuro.
1. Qual é o propósito de utilizar getters e setters?
2. Qual é a sintaxe de um método getter em Java?
3. Qual é a sintaxe de um método setter em Java?
Obrigado pelo seu feedback!
