INTRODUÇÃO A OBJETOS COM JAVA

TRATAMENTO DE EXCEÇÕES

• CONCEITO DE EXCEÇÃO, MECANISMO

• EXEMPLO: JOGO DE CARTAS

  • PARTE 1: BaralhoSeguro.java

  • PARTE 2: JogoDeCartasSeguro.java

/****************************************************
** Um baralho inteiro
** @author Jacques P. Sauvé
** @since 08/04/1999
****************************************************/

import java.util.*;
import java.lang.Math.*;

public class BaralhoSeguro {
   private Carta[] baralho;
   private int numeroDeCartas;

   public BaralhoSeguro() {
      baralho = new Carta[52];
      // enche o baralho
      numeroDeCartas = 0;
      /* poderiamos fazer laços aninhados aqui mas
       * teríamos que depender de conhecimento dos
       * inteiros que representam naipes.
       * Não queremos este acoplamento entre classes
       * para termos a liberdade de mudar uma classe
       * sem afetar a outra
       */
      for(int valor = Carta.AS; valor <= Carta.REI; valor++) {
         baralho[numeroDeCartas++] = new Carta(valor, Carta.PAUS);
         baralho[numeroDeCartas++] = new Carta(valor, Carta.OURO);
         baralho[numeroDeCartas++] = new Carta(valor, Carta.COPAS);
         baralho[numeroDeCartas++] = new Carta(valor, Carta.ESPADA);
      }
   }

   public void baralhar() {
      int posição;
      for(posição = 0; posição < numeroDeCartas - 1; posição++) {
         // escolhe uma posição aleatória
         // entre posição e numeroDeCartas-1
         int posAleatória = posição +
               (int)((numeroDeCartas - posição) * Math.random());
         // troca as cartas em posição e posAleatória
         Carta temp = baralho[posição];
         baralho[posição] = baralho[posAleatória];
         baralho[posAleatória] = temp;
      }
   }

   public Carta pegaCarta() throws NoSuchElementException {
      if(numeroDeCartas == 0) throw new
            NoSuchElementException("Baralho esta vazio");
      return baralho[--numeroDeCartas];
   }
}


/****************************************************
** Um jogo de cartas simples
** @author Jacques P. Sauvé
** @since 08/04/1999
****************************************************/

import java.util.*;
import corejava.*;

public class JogoDeCartasSeguro {
   private int suasVitórias;   // pontuação
   private int minhasVitórias;

   public JogoDeCartasSeguro() {
      suasVitórias = 0;
      minhasVitórias = 0;
   }

   public void joga(BaralhoSeguro baralho, int rodadas)
         throws NoSuchElementException {
      for(int i = 0; i < rodadas; i++) {
         Carta suaCarta = baralho.pegaCarta();
         System.out.print("Sua carta: " + suaCarta + " ");
         Carta minhaCarta = baralho.pegaCarta();
         System.out.print("Minha carta: " + minhaCarta + " ");
         int comp = minhaCarta.compareTo(suaCarta);
         if(comp < 0) {
            System.out.println("Voce ganha.");
            suasVitórias++;
         } else if(comp > 0) {
            System.out.println("Eu ganho.");
            minhasVitórias++;
         } else {
            System.out.println("Empate.");
         }
      }
      System.out.println("Voce ganhou " + suasVitórias +
            " vezes, eu ganhei " + minhasVitórias + " vezes, " +
            (rodadas-suasVitórias-minhasVitórias) + " empates.");
   }

   public static void main(String[] args) {
      int rodadas;
      while((rodadas = Console.readInt(
            "Quantas rodadas quer jogar?")) <= 0) {
         System.err.println(
            "Forneca um numero positivo, por favor.");
      }

      JogoDeCartasSeguro jogo = new JogoDeCartasSeguro();
      // Seria melhor criar o baralho e misturar as cartas
      // no construtor do jogo mas queremos mostrar a
      // passagem de um objeto como parametro
      BaralhoSeguro baralho = new BaralhoSeguro();
      baralho.baralhar();
      try {
         jogo.joga(baralho, rodadas);
      } catch(NoSuchElementException e) {
         System.err.println(
            "Problema durante o jogo: " + e.getMessage());
      }
   }
}

HERANÇA E POLIMORFISMO

• GENERALIZAÇÃO E ESPECIALIZAÇÃO, HERANÇA, SUBCLASSE, SUPERCLASSE, HIERARQUIA, CLASSE OBJECT, CLASSES ABSTRATAS, CASTING, SUPER, POLIMORFISMO

• EXEMPLO: Mailbox.java

/**
 * @version 1.0 8 de maio de 1999
 * @author Jacques Sauvé,
 * baseado num exemplo do livro CoreJava 2
 */

import java.net.*;
import java.util.*;
import java.applet.*;
import corejava.*;

abstract class Message {
   private String sender;

   public Message(String from) { sender = from; }
   public abstract void play();
   public String getSender() { return sender; }
   
}

class TextMessage extends Message {
   private String text;

   public TextMessage(String from, String t) {
      super(from);
      text = t;
   }
   public void play() { System.out.println(text); }
}

class VoiceMessage extends Message {
   private String filename;

   public VoiceMessage(String from, String f) {
      super(from);
      filename = f;
   }
   
   public void play() {
      try {
         URL u = new URL("file", "localhost", filename);
         AudioClip clip = Applet.newAudioClip(u);
         clip.play();
      } catch(Exception e) {
         System.out.println("Can't open " + filename);
      }
   }   
}


class Mailbox {
   private ArrayList messages = new ArrayList();

   public Message remove() {
      if(messages.size() == 0) return null;
      return (Message)messages.remove(0);
   }
   
   public void insert(Message m) {
      messages.add(m);
   }
   
   public String status() {
      int nmesg = messages.size();
      if(nmesg == 0) return "Mailbox empty";
      else if(nmesg == 1) return "1 message";
      else return nmesg + " messages";
   }
   
   public static void main(String[] args) {
      Mailbox mbox = new Mailbox();
      while(true) {
         System.out.println(mbox.status());
         String cmd = Console.readLine(
            "play, text, voice, quit> ");
         if (cmd.equals("play")) {
            // Usar Message nos preparar para polimorfismo
            Message m = mbox.remove();
            if(m != null) {
               System.out.println("From: " + m.getSender());
               m.play(); // toca, polimorficamente
            }
         } else if(cmd.equals("text")) {
            String from = Console.readLine("Your name: ");
            String msg = "";
            String line = "";
            System.out.println(
               "Enter message, 'exit' when done");
                         
            while( !(line = Console.readLine()).equals("exit") ) {
               msg = msg + line + "\n";
            }
            mbox.insert(new TextMessage(from, msg));
         } else if (cmd.equals("voice")) {
            String from = Console.readLine("Your name: ");
            String msg = Console.readLine("Audio file name: ");         
            mbox.insert(new VoiceMessage(from, msg));
         } else if (cmd.equals("quit")) {
            System.exit(0);
         }
      }            
   }
}

INTERFACES

• HERANÇA DE IMPLEMENTAÇÃO E HERANÇA DE INTERFACE, HERANÇA MÚLTIPLA, POLIMORFISMO SEM RESTRIÇÕES DE HIERARQUIA

• QUEREMOS UM "CARRO COM ATRIBUTOS"

• COMEÇAMOS COM UMA CLASSE BÁSICA DE ATRIBUTOS PROJETADA PARA MANTER PARES DE NOME-VALOR

  • NOMES DE ATRIBUTOS SÃO STRINGS TAIS COMO "COR" OU "LOCALIZAÇÃO"

  • ATRIBUTOS PODEM SER DE QUALQUER TIPO E USAMOS PORTANTO UMA VARIÁVEL DE CLASSE Object

class Atributo {
   private String nome;
   private Object valor = null;

   public Atributo( String nome ) {
      this.nome = nome;
   }

   public Atributo( String nome, Object valor ) {
      this.nome = nome;
      this.valor = valor;
   }

   public String getNome() {
      return nome;
   }

   public Object getValor() {
      return valor;
   }

   public Object setValor( Object novoValor ) {
      Object valorVelho = valor;
      valor = novoValor;
      return valorVelho;
   }

   public String toString() {
      return nome + "='" + valor + "'";
   }
}

• PARA FAZER UM CARRO COM ATRIBUTOS, ESTENDER ATRIBUTO NÃO SERIA BOM POIS QUEREMOS ESTENDER CARRO

class CarroComAtributos  extends Carro implements ComAtributos {
   ...
}

public interface ComAtributos {
   // adiciona um atributo ao objeto
   void adiciona(Atributo novoAtributo);
   // verifica se o objeto tem um dado atributo
   Atributo localiza(String nomeAtributo);
   // remove um atributo do objeto
   Atributo remove(String nomeAtributo);
   // retorna uma lista de atributos do objeto
   Iterator atribs();
}

• UMA IMPLEMENTAÇÃO GENÉRICA REAPROVEITÁVEL

import java.util.*;
class ImplComAtributos implements ComAtributos {
   protected HashMap tabelaAtributos = new HashMap();

   public void adiciona(Atributo novoAtributo) {
      tabelaAtributos.put(novoAtributo.getNome(),
            novoAtributo); // put(key,value)
   }
   public Atributo localiza(String nome) {
      return (Atributo)tabelaAtributos.get(nome);
   }
   public Atributo remove(String nome) {
      return (Atributo)tabelaAtributos.remove(nome);
   }
   public Iterator atribs() {
      return tabelaAtributos.iterator();
   }
}

• USANDO A IMPLEMENTAÇÃO GENÉRICA (COMPOSIÇÃO E DELEGAÇÃO (OU FORWARDING))

class CarroComAtributos extends Carro
                        implements ComAtributos {
   ImplComAtributos implAtributos = new ImplComAtributos();

   // herda todos os metodos de carro

   CarroComAtributos() {
      super();
   }

   CarroComAtributos(String name, Carro umCarro) {
      super(nome, umCarro);
   }

   // Use forwarding para todos os metodos de ComAtributos
   public void adiciona(Atributo novoAtributo) {
      implAtributos.adiciona(novoAtributo);
   }

   public Atributo localiza(String nome) {
      return implAtributos.localiza(nome);
   }

   public Atributo remove(String nome) {
      return implAtributos.remove(nome);
   }

   public Iterator atribs() {
      return implAtributos.atribs();
   }
}

• O POLIMORFISMO COM INTERFACES

  • QUALQUER LUGAR ONDE QUISERMOS MANIPULAR OBJETOS COM ATRIBUTOS, PODEREMOS USAR O TIPO ComAtributos

  • ISSO ACABA SENDO POLIMORFISMO MAS SEM NECESSIDADE DE TER OBJETOS PERTENCENDO A UMA MESMA HIERARQUIA

  • ISSO É MUITO PODEROSO!

java4.htm programa