ABSTRACT CLASSE ABSTRATA
private int idade; }
class Funcionario extends Pessoa { protected double salario; }
Desta maneira, quando precisarmos ter a informação sobre o RG, basta adicionar um novo atributo na classe Pessoa que as subclasses o herdarão (desde tal atributo não seja private).
8.2 - Classe abstrata
O que exatamente vem a ser a nossa classe Pessoa? Nosso banco possui apenas clientes e funcionários, então faz algum sentido ter um objeto da classe Pessoa? Estamos usando esta classe apenas para herdar os atributos em comum, e também para tirar proveito do polimorfismo.
Sem contar que, da maneira que foi feito o sistema, é possível criar um objeto do tipo Pessoa, que não é nem Cliente nem Funcionario. Isso é inadmissível se o sistema fosse bem feito (toda pessoa no nosso banco tem que ser um cliente ou um funcionário, não apenas uma Pessoa, obviamente isso depende das regras do nosso negócio).
Quando precisamos bloquear o acesso a uma classe para que ela não possa ser instanciada e para que somente suas filhas possam ser criadas, usamos a palavra chave abstract:
abstract class Pessoa { String nome; String cpf;
public String getIdentificacao() { return this.nome;
} }
Se ela não pode ser instanciada, para que serve? Somente para o polimorfismo e herança dos atributos.
Vamos então herdar dessa classe, reescrevendo o método getIdentificacao. No nosso banco, quando precisamos saber quem é o funcionário, basta o nome dele; já quando se trata de clientes, precisamos também do CPF por segurança.
class Cliente extends Pessoa { private String endereco; private int idade;
public String getIdentificacao() {
return this.nome + “, “ + this.cpf; }
}
class Funcionario extends Pessoa { protected double salario;
public String getIdentificacao() { return this.nome;
} }
Nossas classes podem funcionar com algum ControleDeEntrada que conte
MÉTODO ABSTRATO
quantas pessoas entram no prédio por dia:
class ControleDeEntrada {
private int numeroDePessoas = 0; public void entra(Pessoa pessoa) {
this.numeroDePessoas += 1;
System.out.println(pessoa.getIdentificacao() + “ acabou de entrar.”); }
public double getNumeroDePessoas() { return this.numeroDePessoas; }
public static void main(String args[]) {
// cria um controle de entrada para ser usado
ControleDeEntrada entrada = new ControleDeEntrada();
// entra um cliente
Cliente cliente = new Cliente(); entrada.entra(cliente);
// entra um funcionário
Funcionario funcionario = new Funcionario(); entrada.entra(funcionario);
System.out.println("Hoje entraram: " + entrada.getNumeroDePessoas() + “ pessoas”);
} }
Da próxima vez que nosso PetShop desejar vender um outro tipo de Pessoa (um fornecedor, por exemplo), basta criarmos uma classe que estende de Pessoa e ela estará funcionando no sistema. Pode ser que quem crie essa nova classe nem seja quem desenvolveu o sistema inicial, mas mesmo assim a classe vai funcionar em conjunto com ela.
Mas qual é a real vantagem de uma classe abstrata? Poderíamos ter feito isto com uma herança comum. Por enquanto, a única diferença é que não podemos instanciar um objeto do tipo Pessoa.
8.3 - Métodos abstratos
Se não tivéssemos reescrito o método getIdentificacao, esse método seria herdado da classe mãe, fazendo com que ele devolvesse o próprio nome. Cada pessoa em nosso banco tem uma regra diferente para ser identificada.
Será então que faz algum sentido ter esse método na classe Pessoa? Será que existe um tipo de identificação para todas as pessoas? Será que a classe Pessoa é capaz de identificar todos as pessoas? Acho que não... cada classe filha terá um método diferente de identificação...
Poderíamos então jogar fora esse método da classe Pessoa? O problema é que se ele não existisse, não poderíamos chamar o método apenas com uma referência a um Pessoa, pois ninguém garante que essa referência aponta para um objeto que possui esse método.
Existe um recurso em Java que, em uma classe abstrata, podemos escrever que determinado método será sempre escrito pelas classes filhas. Isto é, um método abstrato.
Ele indica que todas as classes filhas devem escrever esse método.
Como declarar um método abstrato
Às vezes não fica claro como declarar um método abstrato.
Basta escrever a palavra chave abstract na assinatura do mesmo e colocar um ponto e vírgula em vez de abre e fecha chaves!
abstract class Pessoa { String nome; String cpf;
public abstract String getIdentificacao();
// adicionar os métodos get e set aqui!
}
Repare que não colocamos o corpo do método, e usamos a palavra chave abstract para definir o mesmo.
Qualquer classe que estender a classe Pessoa será obrigada a reescrever este método, tornando-o “concreto”. Se não reescreverem esse método, um erro de compilação ocorrerá.
O método do ControleDeEntrada é:
public void entra(Pessoa pessoa) { this.numeroDePessoas += 1;
System.out.println(pessoa.getIdentificacao() + “ acabou de entrar.”); }
Como posso acessar o método getIdentificacao se ele não existe na classe Pessoa?
Já que o método é abstrato, com certeza suas subclasses têm esse método, o que garante que essa invocação de método não vai falhar. Basta pensar que uma referência do tipo Pessoa nunca aponta para um objeto que não tem o método getIdentificacao, pois não é possível instanciar uma classe abstrata, apenas as “concretas”.
8.4 - Um outro exemplo
Nosso banco deseja todo dia de manhã atualizar as contas bancárias de todas as pessoas. Temos dois tipos de conta, a ContaCorrente e a ContaPoupanca. A ContaPoupanca atualiza todo dia uma pequena porcentagem, já a ContaCorrente só precisa atualizar-se com um fator de correção mensal.
1. class Conta {
2. private double saldo = 0.0; 3.
4. public void retira(double valor) {
5. this.saldo -= valor;
6. }
7.
8. public void deposita(double valor) {
9. this.saldo += valor;
10. } 11.
12. public double getSaldo() {
13. return this.saldo();
14. } 15. }
1. class ContaCorrente extends Conta {
2. private double limiteDoChequeEspecial = 1000.0; 3. private double gastosNoChequeEspecial = 100.0; 4.
5. public void atualiza() {
6. super.retira(this.gastosNoChequeEspecial * 0.08);
7. }
8. }
1. class ContaPoupanca extends Conta { 2. private double correcaoMensal; 3.
4. public void atualiza() {
5. super.deposita(this.saldo * this.correcaoMensal);
6. }
7. }
O que não está legal aqui? Por enquanto usamos herança para herdar um pouco de código, e assim não ter de reescreve-lo. Mas já frisamos que essa não é a grande vantagem de se usar herança, a idéia é utilizar o polimorfismo adquirido. Podemos nos referenciar a uma ContaCorrente e ContaPoupanca como sendo uma Conta:
class AtualizadorDeSaldos { private Conta[] contas;
public void setContas(Conta[] contas) { this.contas = contas;
}
public void atualizaSaldos() {
for (Conta conta : this.contas) {
conta.atualiza(); // não compila!!! }
} }
Este código acima não compila! Se tenho uma referência para uma Conta, quem garante que o objeto referenciado tem o método atualiza? Ninguém. Podemos então coloca-lo na classe Conta:
class Conta {
protected double saldo;
public void retira(double valor) { this.saldo -= valor;
}
public void deposita(double valor) { this.saldo -= valor;
}
public double getSaldo() { return this.saldo(); }
public void atualiza() {
// não faz nada, serve só para o polimorfismo
} }
O que ainda não está legal? Cada tipo de Conta, isto é, cada subclasse de Conta sabe como se atualizar. Só que quando herdamos de Conta nós já herdamos o
método atualiza, o que não nos obriga a reescreve-lo. Além disso, no nosso sistema não faz sentido existir um objeto que é realmente da classe Conta, essa classe é só um conceito, uma idéia, ela é abstrata! Assim como seu método atualiza, o qual queremos forçar que as subclasse reescrevam.
abstract class Conta {
protected double saldo;
public void retira(double valor) { this.saldo -= valor;
}
public void deposita(double valor) { this.saldo += valor;
}
public double getSaldo() { return this.saldo; }
public abstract void atualiza(); }
Podemos então testar esses conceitos criando 2 Contas (uma de cada tipo) e chamando o método atualiza de cada uma delas:
public class TesteClassesAbstratas {
public static void main (String args[]) {
//criamos as contas
Conta[] contas = new Conta[2]; contas[0] = new ContaPoupanca(); contas[1] = new ContaCorrente();
//iteramos e chamamos atualiza
for (Conta conta : contas) { conta.atualiza(); }
} }
8.5 - Para saber mais...
1-) Se eu não reescrever um método da minha classe mãe que é abstrato o código não irá compilar. Mas pode haver uma outra solução: posso declarar essa classe também abstrata!
2-) Uma classe que estende uma classe normal também pode ser abstrata! Ela não poderá ser instanciada, mas sua classe pai sim!
3-) Uma classe abstrata não precisa necessariamente ter um método abstrato.
8.6 - Exercícios
1-) Repare que a nossa classe Conta é uma excelente candidata para uma classe abstrata. Porque? Que métodos seriam interessantes candidatos a serem abstratos?
Transforme a classe Conta para abstrata, tente dar um new nela e compile o código.
abstract class Conta {
// ...
}
2-) Se agora não podemos dar new em Conta, qual é a utilidade de ter um método que recebe uma referência a Conta como argumento?
3-) Transforme o método atualiza() da classe Conta para abstrato. Compile o código. Qual é o problema com a classe ContaPoupanca?
abstract class Conta {
abstract void atualiza(double taxaSelic); }
4-) Reescreva o método atualiza() na classe Poupanca para que a classe possa compilar normalmente.
5-) (opcional) Existe outra maneira da classe ContaCorrente compilar se você não reescrever o método abstrato?
6-) (opcional) Pra que ter o método atualiza na classe Conta se ele não faz nada? O que acontece se simplesmente apagamos esse método da classe Conta, e deixamos o método atualiza nas filhas?
7-) (opcional) Não podemos dar new em Conta, mas porque então podemos dar new em Conta[10], por exemplo?
8-) (opcional) Você pode chamar o método atualiza de dentro da própria classe Conta? Porque?
9
Orientação à Objetos – Interfaces
“O homem absurdo é aquele que nunca muda.” Georges Clemenceau -
Ao término desse capítulo, você será capaz de:
• dizer o que é uma interface e as diferenças entre herança e implementação; • escrever uma interface em Java.
9.1 - Aumentando nosso exemplo
O Sistema de Controle do Banco pode ser acessado, além dos Gerentes, pelos Diretores do Banco. Então, teríamos uma classe Diretor:
class Diretor extends Funcionario { int senha;
// ...
}
A equipe que cuida do banco de dados do Sistema de Controle nos pediu um relatório com as senhas de todos os funcionários que acessam o sistema. O gerente de TI corre para nosso ex programador júnior e pergunta se o sistema foi bem desenhado para que ele possa fazer esse relatório rapidamente. Como podemos proceder?
class RelatorioSenhas {
void adiciona(Funcionario funcionario) {
// como chamo o método getSenha? não posso!
} }
O relatório baseado na classe escrita acima estará aceitando qualquer tipo de Funcionario, ele tendo acesso ao sistema ou não.
Além disso, ninguém me garante que posso chamar o método getSenha, pois nem todo Funcionario o tem. Como poderíamos então receber tanto o Gerente quanto o Diretor? A idéia mais simples seria:
class RelatorioSenhas {
void adiciona(Gerente gerente) {
System.out.println(gerente.getNome());
System.out.println(“Senha: ” + gerente.getSenha()); }
void adiciona(Diretor diretor) {
System.out.println(diretor.getNome());
System.out.println(“Senha: ” + diretor.getSenha()); }