Encapsulation: private fields, getters, setters
Proteger seus dados
- Encapsulamento significa esconder os dados de um objeto e alterá-los apenas através de métodos.
privatebloqueia o acesso direto por código externo não relacionado. Ele não valida valores: construtores e métodos mutadores devem aplicar as regras do objeto themselves.- As ferramentas principais são as palavras
privateepublic.
Campos private
- Marque as variáveis de instância
privatepara que o código em classes não relacionadas não possa tocá-las diretamente. - Métodos dentro da mesma classe ainda podem usá-las.
- Este é o estilo padrão para AP CSA: os campos são
private. O primeiro exemplo aceita intencionalmente um início negativo;mainestá na mesma classe, portanto pode ler esse campo privado. Ele imprime-50.0, expondo a validação ausente.
public class BankAccount {
private double balance; // hidden from outside code
public BankAccount(double start) {
this.balance = start;
}
public static void main(String[] args) {
BankAccount account = new BankAccount(-50);
System.out.println(account.balance); // -50.0: private alone does not validate
}
}
Acessores (getters)
- Um campo é privado, então adicionamos um método
publicpara ler ele. - Um método que retorna um campo é chamado de acessor ou getter.
- Geralmente começa com
get, comogetBalance().
public class BankAccount {
private double balance;
public BankAccount(double start) {
this.balance = start;
}
public double getBalance() {
return this.balance;
}
public static void main(String[] args) {
BankAccount account = new BankAccount(100);
System.out.println(account.getBalance()); // 100.0
}
}
Mutadores (setters)
- Um método que altera o estado do objeto é um mutador. Um setter é um tipo, geralmente definindo um campo com um valor fornecido;
deposité um mutador que adiciona ao saldo. - Ele pode verificar o novo valor primeiro e recusar um mau.
- Abaixo, o construtor rejeita um início negativo e
depositignora montantes não positivos. Esses exemplos assumem valores finitos dedouble; as verificações mostradas aplicam as regras declaradas, não todos os requisitos bancários possíveis.
public class BankAccount {
private double balance;
public BankAccount(double start) {
if (start < 0) {
throw new IllegalArgumentException("Start must be nonnegative");
}
this.balance = start;
}
public void deposit(double amount) {
if (amount > 0) {
this.balance = this.balance + amount;
}
}
public double getBalance() {
return this.balance;
}
public static void main(String[] args) {
BankAccount account = new BankAccount(100);
account.deposit(-500);
System.out.println(account.getBalance()); // 100.0
account.deposit(50);
System.out.println(account.getBalance()); // 150.0
try {
new BankAccount(-50);
} catch (IllegalArgumentException error) {
System.out.println("Negative start rejected");
}
}
}
static vs instance
- Um campo de instance pertence a um objeto. Cada objeto tem o seu próprio.
- Um campo
staticpertence à classe em si — ele é compartilhado por todos os objetos. - Abaixo,
countaumenta em 1 sempre que umRoboté construído. Ele conta construções, não o número de objetos ainda vivos; descartar uma referência não o diminui.
public class Robot {
private static int count = 0; // shared by all robots
public Robot() {
count = count + 1;
}
public static int getCount() {
return count;
}
public static void main(String[] args) {
Robot first = new Robot();
Robot second = new Robot();
System.out.println(Robot.getCount()); // 2 constructions
}
}
toString()
toString()retorna texto que descreve o objeto.- Java o chama automaticamente quando você imprime o objeto ou o concatena com texto usando
+. OObject.toString()herdado usa o nome da classe,@e um código hash hexadecimal; esse texto não é um endereço de memória garantido. - Ele não recebe parâmetros e retorna um
String.
public class Point {
private int x;
private int y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
public String toString() {
return "(" + this.x + ", " + this.y + ")";
}
public static void main(String[] args) {
Point point = new Point(3, 4);
System.out.println(point); // (3, 4)
System.out.println("Point: " + point); // Point: (3, 4)
}
}
Erros comuns
- Torne os campos
privatee acesse-os através de getters e setters. - Um setter pode verificar um valor antes de armazená-lo.
Agora você tenta
- Preencha cada classe conforme seu contrato de construtor e método declarado;
privatesozinho não o aplica. - Um Harness oculto constrói o objeto, chama os métodos e verifica os resultados.
- Estas tarefas de aula não possuem um botão
mainindependente nem um botão Executar. Verificar resposta compila sua aula com a estrutura fornecida, executa suas chamadas e fornece feedback. Os exemplos completos acima têm seus próprios botões Executar.
Dificuldade 3/5 · Moedas 200 + pequeno bônus na primeira conclusão hoje
Complete BankAccount. Assume start is nonnegative and all additions fit in int. Keep balance private. deposit(amount) adds the amount only if it is greater than 0. withdraw(amount) subtracts only if the amount is greater than 0 e not more than the balance (no overdraft). getBalance() returns the balance.
Clique em Executar para ver a saída aqui.
Dificuldade 3/5 · Moedas 200 + pequeno bônus na primeira conclusão hoje
Complete Temperature. The constructor stores an int degrees in a private field. toString() returns the degrees followed by C — for 21 it returns 21C.
Clique em Executar para ver a saída aqui.
Dificuldade 3/5 · Moedas 200 + pequeno bônus na primeira conclusão hoje
Complete Widget. A private static campo count starts at 0. Every time a Widget is built, the constructor adds 1 to count. The static método getCount() returns how many widgets have been built.
Clique em Executar para ver a saída aqui.