Sejam bem vindos, esta é a décima aula de Programação Web em Java, para saber mais sobre o curso, começe em Curso de Programação Web em Java - CPWJ.
Hoje iremos aprofundar alguns conceitos de orientação a objeto .
Vamos começar com uma revisão de alguns conceitos já passados na última aula:
Classe: um modelo para um Objeto
Interface: uma especificação
Instância: um objeto de uma Classe ou Interface fisicamente representado na memória
Membros de uma Classe:
Método: uma conjunto sequencial de instruções
Campo: variável associada com um objeto particular
Campo estático: variável compartilada entre todos os objetos de uma classe.
Existem dois tipos de dados em Java, os tipos primitivos e os tipos objetos.
Usar a palavra chave “new” para criar um objeto. Este comando irá reservar espaço para um novo objeto na memória, chamar o construtor do objeto e retornar o endereço para o novo objeto.
[acesso] [abstract/final] class NomeDaClasse
[extends NomeClassePai]
[implements NomeDaInterface...] {
//construtores
//métodos membros
//campos membros
}
public class ContaBancaria {
…
}
Ao escrever uma classe nós podemos definir os seguintes membros:
Construtores
Métodos e campos
Métodos e campos estáticos
Classes alinhadas
Vamos detalhar cada um dos membros, começando pelos Construtores.
São os métodos chamados automaticamente na criação dos objetos. Deve ter o mesmo nome da classe que a possue. Tem o objetivo de realizar a inicialização de um objeto da classe.
[acesso] NomedaClasse ([argumentos...]) {
//corpo do construtor
}
public class ContaBancaria {
public ContaBancaria(){ // veja que o nome do construtor é o mesmo da classe
saldo=0;
}
}
public class ContaBancaria {
public ContaBancaria(){
saldo=0;
}
public ContaBancaria(int saldoInicial){
saldo=saldoInicial;
}
}
Apesar de possuir o mesmo nome são construtores diferentes, pois possuem parâmetros diferentes.
Métodos são usados para realizar funções modificando o estado dos objetos. Podem ter vários parâmetros, e retornar um único valor. Nos casos que não retornam valor deve ser utilizado a parlavra chave void.
[acesso] tipoRetorno nomeDoMétodo ([argumentos...]) {
//corpo do método
}
public class ContaBancaria {
public int getSaldo(){
return saldo;
}
}
Uma classe pode possuir dois métodos com mesmo nome, desde que os seus argumentos sejam diferentes.
Por exemplo:
int getSaldo() {…}
int getSaldo(String tipo) {…}
Java reconhece qual método deverá executar verificando quantos e que tipos de parâmetros são apresentados na chamada.
int x=minhaClasse.getSaldo(“total”); //chamará o segundo método.
Um campo é como uma variável e armazena um estado do objeto. É sempre relacionado a um tipo de dado que determina o que ele pode armazenar.
[acesso] tipoDeDado nomeCampo [= valor];
public class ContaBancaria {
public int saldo;
public Date ultimaTransacao;
public List transacoes;
}
public class ContaBancaria {
private int saldo; // campo
public ContaBancaria() { //construtor
saldo= 0;
}
public void retirada(int valor) { //método
saldo = saldo – valor;
}
public void deposito (int valor) { //método
saldo = saldo + valor;
}
}
Para controlar o acesso aos dados membros temos 4 tipos de acesso direrentes que determinam que classes tem acesso:
public – qualquer outra classe
protected - somente subclasses
(default) – somente classes no mesmo pacote (package)
private – somente acessível por métodos da mesma classe
Estes níveis de acesso são usados para garantir a abstração e encapsulamento dos objetos.
É o mecanismo que permite uma classe herdar funcionalidades de outra classe, permitindo abstração de dados e procedimentos e diminuindo a complexidade de grandes sistemas de dados.
Usamos herança quando duas idéias tem diferentes comportamentos mas com funcionalidades sobrepostas:
ContaBancaria => ContaCorrente
ContaBancaria => ContaPoupanca
Uma interface é uma especificação de uma classe. Declara-se métodos, mas não os define. Não tem contrutores. O objetivo é expecificar um padrão de uso (interface) de um conjunto de classes diferentes.
[acesso] interface NomeDaInterface
[extends ListaDeNomeDeInterface...] {
//declaração de métodos
}
public interface ContaBancaria {
public void retirada (int valor); //nenhum método é definido na interface, somende declarado
public void deposito (int valor);
public int getSaldo ();
}
Uma vez definido uma interface, podemos escrever classes, ou mesmo outras interfaces que implementam (implement) ou extendam (extend) esta interface.
Quando uma classe implementa uma interface, esta classe deve possuir em seu corpo cada um dos métodos declarados desta interface. Se uma classe implementa mais de uma interface, ela deve possuir cada uma dos métodos de cada uma das interfaces que implementa.
public class ContaPoupanca implements ContaBancaria {
private int saldo;
public ContaPoupanca (int saldoinicial) {
saldo= saldoinicial;
}
public void somaJuros(int juros){ //função particular de ContaPoupanca
saldo=saldo+(saldo*(juros)/100);
}
//implementando métodos da interface ContaBancaria:
public void retirada (int valor) {
saldo= saldo – valor;
}
public void deposito (int valor) {
saldo = saldo + valor;
}
public int getSaldo () {
return saldo;
}
}
São uma mistura de interfaces e classes, podendo definir métodos e possuir campos. Porém podem apresentar métodos somente declarados, e não definidos.
A idéia é capturar o estado de uma idéia e também sua funcionalidade.
public abstract class ContaBancaria {
private int saldo; // campo
public void retirada(int valor); //função não definida pela classe abstrata, porque difere de tipo de conta bancária para outra.
public void deposito (int valor) {
saldo = saldo + valor;
}
}
public class ContaCorrente extends ContaBancaria {
public ContaCorrente(){
saldo=0;
}
public void retirada(int valor){
if((saldo-valor)<0) {
throw new RuntimeException (“Insuficiencia de fundos”);
} else {
saldo=saldo-valor;
}
}
}
public class ContaCorrenteEspecial extends ContaBancaria {
private limiteChequeEspecial;
public ContaCorrenteEspecial(){
saldo=0;
limiteChequeEspecial=1000;
}
public void retirada(int valor){
if((saldo-valor)<limiteChequeEspecial) {
throw new RuntimeException (“Estourado Limite Cheque Especial”);
} else {
saldo=saldo-valor;
}
}
}
Consiste na capacidade de objetos de tipos diferentes responder a métodos de mesmo nome e tipo. Isso acontece quando usamos herança. A máquina virtual java automaticamente determina qual das funções devem ser executadas.
Quando uma classe não extende nenhuma outra classe, implicitamente ela extende a classe java.lang.Object. Esta é uma classe da biblioteca java que contém um conjunto de métodos que assim ficam disponíveis para qualquer classe que você definir. os principais métodos da classe Object são: clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString e wait.
Se uma classe A extende uma classe B, então B é a classe pai (superclass) de A. E, a classe A é uma classe filha (subclass) de B. Quando a classe pai possui um método definido, a classe filha pode ter um método com mesmo nome e tipo para modificar o comportamento do método da classe pai. Isso chama-se sobreposição (overriding).
A classe Object possui um método chamado equals que verifica se dois objetos são o mesmo, isto é, se duas variáveis estão apontando para o mesmo objeto. (revisem a última aula se não entenderam)
Porém em alguns tipos de objetos a noção de igualdade dá-se de maneira totalmente distinta. No nosso exemplo de conta bancária, igualdade poderia dizer que duas contas possuem o mesmo saldo. Graças ao polimorfismo e sobreposição é possível mudar o método equals para realizar exatamente esta verificação.
ContaCorrente c1 = new ContaCorrente(100);
ContaCorrente c2 = new ContaCorrente(100);
c1.equals(c1); // verdadeiro
c2.equals(c2); // verdadeiro
c1.equals(c2); // falso, como são dois objetos a função equals retorna falso.
public class ContaCorrente extends ContaBancaria {
…
public boolean equals (Object aux){
if(aux instanceof ContaCorrente){ //verifica se tipo de dado do parâmetro está correto
ContaCorrente aux2 = (ContaBancaria) aux;
return saldo == aux2.saldo; //retorna true se saldo igual
} else {
return false; //se tipo incorreto não é igual
}
}
…
}
ContaCorrente c1 = new ContaCorrente(100);
ContaCorrente c2 = new ContaCorrente(100);
c1.equals(c1); // verdadeiro
c2.equals(c2); // verdadeiro
c1.equals(c2); // verdadeiro, pois agora o que se compara é o saldo, não a posição do objeto
Variáveis de um tipo podem armazenar dados de tipos subclasses
Object o1 = new ContaCorrente(100); //Object é superclass de qualquer classe
Object o2 = new ContaCorrente(100);
Object é o tipo em tempo de Compilação (compile-time) e ContaCorrente é o tipo em tempo de execução (runtime).
Quando chamamos um método por uma variável do tipo superclass mas com um objeto subclass armazenado, o método executado será o do subclass. No nosso exemplo, chamar o método o1.equals(o2), iria chamar a função “equals” definida em ContaCorrente.
Isso acontece porque Java escolhe o método a ser chamado em tempo de execução e não em tempo de compilação.
ContaBancaria c1 = new ContaCorrente(10);
ContaBancaria c2 = new ContaCorrenteEspecial(10);
c1.retirada(12); //chamará ContaCorrente.retirada(int) e causará uma exceção por insuficiência de saldo
c2.retirada(12); //chamará ContaCorrenteEspecial.retirada(int) e não apresentará problemas.
As vantagem de uso de tipos abstratos como demonstrado aqui é que os detalhes de implementação são mais simples de modificar sem mudanças nas classes que usam estes tipos abstratos.
Nas próxima aula iremos lidar com coleções e listas para fixar exatamente estes conceitos. Porém isso vai ser somente em 22 de janeiro, pois estou entrando em férias, e me reservei no direito de aproveitar os 20 primeiros dias do ano sem nenhuma preocupação. Estarei me casando no dia 12 de janeiro, e só vou voltar a este site quando voltar a trabalhar também na faculdade e na Sabesp.
Para quem acompanha os artigos astronômicos, só irei postar se for algo realmente extraordinário. Um abraço e boas férias.
Dúvidas? vá para o fórum.
[...] Décima Primeira Aula: 18 de dezembro | Classes, Interfaces e Polimorfismo [...]
Ei, parabéns pelo casamento!!!! Muitas felicidades!!!
Só fiquei sabendo agora que terminei de ler a aula 11
Tecnoclata responde
Pior que a papelada atrasou e o casamento será só no dia 9 de fevereiro. De qualquer forma obrigado pelas felicitações.
[Responder]