Programação Web em Java
Autor: Kayo Bruno | Publicado: 2012-02-11T17:30:00-08:00

Sejam bem vindos, esta é a décima aula de Programação Web em Java.

Hoje iremos aprofundar alguns conceitos de orientação a objeto .

Décima Primeira Aula: &nbsp;Classes, Interfaces e Polimorfismo

Classes e Interfaces, Conceitos

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: um 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.


Tipos de Dados

Existem dois tipos de dados em Java, os tipos primitivos e os tipos objetos.

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.

Modelo de definição de uma Classe:

[acesso] [abstract/final] class NomeDaClasse
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; [extends NomeClassePai]
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; [implements NomeDaInterface...] {
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; //construtores
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; //métodos membros
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; //campos membros
}


Exemplo de Sintaxe

public class ContaBancaria {
 ...
}

Membros das Classes

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.

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.

Modelo de Construtor

[acesso] NomedaClasse ([argumentos...]) {
&nbsp; &nbsp;//corpo do construtor
}

Exemplo de Sintaxe Construtor

public class ContaBancaria {
&nbsp; public ContaBancaria(){ // veja que o nome do construtor é o mesmo da classe
  saldo=0;
&nbsp; }
}

Exemplo de Sintaxe de Múltiplos Construtores

public class ContaBancaria {
 public ContaBancaria(){
  saldo=0;
 }
 public ContaBancaria(int saldoInicial){
  saldo=saldoInicial;
 }
}

Métodos

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.

Modelo de Método

[acesso] tipoRetorno nomeDoMétodo ([argumentos...]) {
&nbsp; &nbsp; //corpo do método
}

Exemplo de Método

public class ContaBancaria {
 public int getSaldo(){
  return saldo;
 }
}

Sobrecarga de métodos

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.

Exemplo:

int x=minhaClasse.getSaldo(“total”); //chamará o segundo método.

Campos

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.

Modelo de Campo

[acesso] tipoDeDado nomeCampo [= valor];

Exemplos de Campos


public class ContaBancaria {
 public int saldo; // &lt;&lt; campo
 public Date ultimaTransacao; // &lt;&lt; campo
 public List transacoes; // &lt;&lt; campo
}

Juntando tudo

public class ContaBancaria {
&nbsp; private int saldo; // campo
&nbsp; public ContaBancaria() { &nbsp;//construtor
&nbsp; &nbsp; &nbsp; &nbsp; saldo= 0;


&nbsp; }
&nbsp; public void retirada(int valor) { &nbsp;//método
&nbsp; &nbsp; &nbsp; &nbsp; saldo = saldo – valor;
&nbsp; }
&nbsp; public void deposito (int valor) { &nbsp;//método
&nbsp; &nbsp; &nbsp; &nbsp;  saldo = saldo + valor;
&nbsp; }
}

Controle de Acesso

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.

Herança

É 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 =&gt; ContaCorrente
ContaBancaria =&gt; ContaPoupanca

Interfaces

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.

Modelo de Interfaces

[acesso] interface NomeDaInterface
&nbsp; &nbsp; [extends ListaDeNomeDeInterface...] {
&nbsp; &nbsp; &nbsp; //declaração de métodos
}

Exemplo de Interface

public interface ContaBancaria {
&nbsp; public void retirada (int valor); &nbsp;//nenhum método é definido na interface, somende declarado


&nbsp; public void deposito (int valor);
&nbsp; public int getSaldo ();
}

Como utilizar uma Interface?

Uma vez definido uma interface, podemos escrever classes, ou mesmo outras interfaces que implementam (implement) ou extendam (extends) 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.

Exemplo usando a Interface

public class ContaPoupanca implements ContaBancaria {
&nbsp; &nbsp; private int saldo;
&nbsp; &nbsp; public ContaPoupanca (int saldoinicial) {
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp;saldo= saldoinicial;
&nbsp; &nbsp; }
&nbsp; &nbsp; public void somaJuros(int juros){ &nbsp; &nbsp;//função particular de ContaPoupanca
 saldo=saldo+(saldo*(juros)/100);
&nbsp; &nbsp; }
&nbsp; &nbsp; //implementando métodos da interface ContaBancaria:
&nbsp; &nbsp; public void retirada (int valor) {
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp;saldo= saldo – valor;
&nbsp; &nbsp; }
&nbsp; &nbsp; public void deposito (int valor) {
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp;saldo = saldo + valor;
&nbsp; &nbsp; }
&nbsp; &nbsp; public int getSaldo () {
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp;return saldo;
&nbsp; &nbsp; }
}

Classes Abstratas

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.

Exemplo de Classe Abstrata

public abstract class ContaBancaria {
&nbsp; &nbsp;private int saldo; // campo
&nbsp; &nbsp;public void retirada(int valor); //função não definida pela classe abstrata, porque difere de tipo de conta bancária para outra.
&nbsp; &nbsp;public void deposito (int valor) {
&nbsp; &nbsp; &nbsp; &nbsp;  saldo = saldo + valor;
&nbsp; &nbsp;}
}

Exemplo extendendo uma Classe Abstrata

public class ContaCorrente extends ContaBancaria {
 public ContaCorrente(){
  saldo=0;
 }
 public void retirada(int valor){
  if((saldo-valor)&lt;0) {
   throw new RuntimeException (“Insuficiencia de fundos”);
  } else {
   saldo=saldo-valor;
  }
 }
}

Exemplo de outro tipo de Conta Bancaria:

public class ContaCorrenteEspecial extends ContaBancaria {
 private limiteChequeEspecial;
 public ContaCorrenteEspecial(){
  saldo=0;
  limiteChequeEspecial=1000;
 }
 public void retirada(int valor){
  if((saldo-valor)&lt;limiteChequeEspecial) {
&nbsp;   throw new RuntimeException (“Estourado Limite Cheque Especial”);
  } else {
   saldo=saldo-valor;
  }
 }
}

Polimorfismo

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.

A classe Object

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.

Sobreposição de métodos (overriding)

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).

Modificando um método da Superclass

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.

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.

Usando o método equals padrã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.


Modificando nossa função “equals”, usando overriding:


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
  }
 }
 ...
}

Usando nova função “equals”

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
Usando variáveis do tipo Superclass

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).

Chamada de métodos em tempo de execução

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.

Exemplo usando ContaCorrente e ContaCorrenteEspecial

ContaBancaria c1 = new ContaCorrente(10);
ContaBancaria c2 = new ContaCorrenteEspecial(10);
c1.retirada(12); //chamará ContaCorrente.retirada(int) &nbsp;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.