View source for Classes Internas (Java)/Gatos Iteráveis

{{TOCright}}
A tarefa nestes exemplos é definir um gato iterável. Esta tarefa é realizada nos exemplos 1 a 5 de formas diferentes, embora produzindo sempre o mesmo resultado (excepto onde indicado). O exemplo 6 ilustra aspectos de polimorfismo relacionado com as várias partes de um gato construído desta forma.

Iterar implica a capacidade de obter múltiplas entidades a partir de um gato. Embora seja perfeitamente possível definir iteradores independentes da linguagem Java, é mais conveniente usar os conceitos Java para iteração, pois permitem utilizar algoritmos pré-definidos para iteradores (tirando partido do polimosfismo) e utilizar a sintaxe especial ''for-each'', aplicável a entidades iteráveis e ''arrays'' (i.e., entidade primitivas com dimensão fixa).

Assim, serão implementadas duas interfaces pré-definidas em Java. A primeira das interfaces é '''java.lang.Iterable<T>''' e é implementada pelas classes que representam, em cada caso, o conceito de gato. Em geral, esta interface é implementada por qualquer entidade que representa um qualquer tipo de colecção de objectos.

A segunda interface é '''java.util.Iterator<T>''' e é implementada pelos iteradores definidos para as entidades iteráveis. Note-se que alguns dos exemplos de implementação serão internos, embora esta interface seja exterior a todas as classes.

== Caso 1: definição de duas classes independentes ==

Este exemplo apresenta o conceito de Gato como iterável, mas não disponibiliza nesse conceito nenhuma definição para o tipo do iterador. Esta situação implica que o iterador tem de ser definido depois da classe do gato estar terminada. Pode implicar ainda que a classe do gato tenha de disponibilizar uma interface pública para permitir a definição e funcionamento do iterador (sem a qual o iterador pode não ter acesso às estruturas internas do gato).

=== Classe do conceito gato: Cat ===

Os métodos '''size()''' e '''part(int i)''' são utilizados pelo iterador, mas expõem aspectos da implementação internada do gato.

Note-se que o método '''iterador()''', imposto pela interface '''Iterable<T>''', retorna a um iterador para a instância da classe do gato à qual é pedido o iterador. Como as intâncias das classes do iterador e do gato não têm nenhuma relação especial, é necessário informar o iterador sobre o gato a iterar.
<java5>
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
public class Cat implements Iterable<CatPart> {
  private List<CatPart> _parts = new ArrayList<CatPart>();

  public Cat(int nparts) {
    for (int i = 0; i < nparts; i++)
      _parts.add(new CatPart(i));
  }

  public int size() { return _parts.size(); }

  public CatPart part(int i) { return _parts.get(i); }

  public Iterator<CatPart> iterator() {
    return new CatIterator(this);
  }

}
</java5>

=== Classe do iterador: CatIterator ===

Esta classe implementa a interface '''Iterator<T>''', em que '''T''' é uma parte do gato. A interface obriga à implementação dos métodos '''hasNext''', '''next''' e '''remove'''. Estas implementações são feitas com base no índice gerido pelo iterador e na intância de gato passada no construtor.

<java5>
import java.util.Iterator;
public class CatIterator implements Iterator<CatPart> {
  Cat _cat;
  int _index = 0;
  public CatIterator(Cat cat) { _cat = cat; }
  public boolean hasNext() { return _index < _cat.size(); }
  public CatPart next() { return _cat.part(_index++); }
  public void remove() { throw new UnsupportedOperationException(); }
}
</java5>

=== Classe de parte de gato: CatPart ===

Esta é uma classe muito simples que serve apenas para ilustrar a construção de um gato a partir de partes de gato. Neste exemplo, não é feita nenhuma distinção entre as várias partes (em exemplos mais elaborados, o polimorfismo de inclusão vai permitir continuar a ignorar as diferenças na maior parte, se não em todos, dos casos). O único método definido (além do construtor) é o método '''toString''', para permitir obter alguma informação útil (distinguir as partes) quando se imprime um gato.

<java5>
public class CatPart {
  private int _i;
  public CatPart(int i) { _i = i; }
  public String toString() { return "PART #" + _i; }
}
</java5>

=== Aplicação exemplo ===

Esta aplicação ilustra a utilização dos conceitos acima. Note-se que o modo de iteração utilizado (''for-each'') é válido para entidades que implementem o conceito '''java.util.Iterable<T>''' e para arrays primitivos.

<java5>
public class App {
  public static void main(String[] args) {
    Cat cat = new Cat(5);
    for (CatPart part: cat)
      System.out.println(part);
  }
}
</java5>

=== Como Executar ===

O processo de execução é o habitual. Primeiro, é necessário compilar as classes:

 javac App.java CatIterator.java Cat.java CatPart.java

Em segundo lugar, executa-se a partir da classe que contém o método '''main''':

 java App

O resultado é:

<text>
PART #0
PART #1
PART #2
PART #3
PART #4
</text>

== Caso 2: reutilização de iteradores ==

Este caso é como o primeiro, i.e., temos um gato que não define nenhum iterador específico. No entanto, ao contrário do primeiro caso, onde se definiu uma classe para iterar o gato, neste caso observamos que o iterador no caso anterior apenas iterava a lista de partes do gato. Como tanto o iterador do gato (no exemplo anterior), como o iterador da lista, implementam '''Iterator<CatPart>''', é possível poupar a definição de uma classe e reutilizar o iterador da lista.

=== Classe do conceito gato: Cat ===

O gato fica assim definido:

<java5>
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
public class Cat implements Iterable<CatPart> {
  private List<CatPart> _parts = new ArrayList<CatPart>();

  public Cat(int nparts) {
    for (int i = 0; i < nparts; i++)
      _parts.add(new CatPart(i));
  }

  public Iterator<CatPart> iterator() {
    return _parts.iterator();
  }

}
</java5>

A classe '''CatIterator''' deixa de ser necessária e as restantes permanecem inalteradas.

Note-se como a reutilização de um conceito equivalente (para esta situação) permitiu ainda simplificar o código da classe gato.

=== Como Executar ===

O processo de execução é o habitual. Primeiro, é necessário compilar as classes:

 javac App.java Cat.java CatPart.java

Em segundo lugar, executa-se a partir da classe que contém o método '''main''':

 java App

O resultado é:

<text>
PART #0
PART #1
PART #2
PART #3
PART #4
</text>

== Caso 3: usando classes internas ==

No caso 1, o iterador de gatos era uma instância de uma classe definida especialmente para esse efeito. No caso 2, o processo de iteração era levado a cabo através de um iterador já definido (o iterador de uma lista, tal como implementado pela classe '''java.util.ArrayList<T>'''. O segundo exemplo mostrava apenas como é possível reutilizar o iterador de uma estrutura interna a um objecto para fornecer essa funcionalidade ao objecto que a contém.

Note-se que, tal como no caso 2, apenas é necessária a definição das classes '''Cat''' (para o conceito gato), '''CatPart''' (partes abstractas do gato) e '''App''' (a aplicação). A classe do iterador está contida na da classe gato. Estas duas classes são como nos casos anteriores.

=== Classe do conceito gato: Cat ===

Neste exemplo, volta-se a considerar uma classe específica para a iteração, mas melhora-se a implementação da classe de iteração, por forma a não ser necessária a interface adicional de suporte (métodos '''size''' e '''part''' de gato). Neste aspecto, a classe gato é semelhante à do caso 2. A nova classe de iteração recorre ao mecanismo das classes internas Java.

<java5>
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
public class Cat implements Iterable<CatPart> {
  private List<CatPart> _parts = new ArrayList<CatPart>();

  private class CatIterator implements Iterator<CatPart> {
    int _index = 0;
    public boolean hasNext() { return _index < _parts.size(); }
    public CatPart next() { return _parts.get(_index++); }
    public void remove() { throw new UnsupportedOperationException(); }
  }

  public Cat(int nparts) {
    for (int i = 0; i < nparts; i++)
      _parts.add(new CatPart(i));
  }

  public Iterator<CatPart> iterator() {
    return new CatIterator();
  }

}
</java5>

Note-se que a definição de '''CatIterator''' é agora privada da classe '''Cat''' e que apenas pode ser vista como uma implementação de '''java.util.Iterator<CatPart>'''. A interface adicional do caso 1 não é necessária neste caso, pois, como a classe do iterador é interna, dispõe de acesso ao estado do gato em iteração. Além deste aspecto, a definição da classe gato é semelhante à de casos anteriores.

=== Como Executar ===

O processo de execução é o habitual. Primeiro, é necessário compilar as classes:

 javac App.java Cat.java CatPart.java

Note-se que, além dos ficheiros .class resultantes da compilação das classes indicadas, aparece agora o ficheiro '''Cat$CatIterator.class''' (correspondente à classe interna).

A execução é exactamente como nos casos anteriores.

== Caso 4: usando classe interna a um método ==

== Caso 5: usando classe anónima ==

== Caso 6: usando classes anónimas e polimorfismo ==

== Leitura adicional ==

Ver o manual de Java, para os conceitos acima.
* http://docs.oracle.com/javase/7/docs/api/java/lang/Iterable.html
* http://docs.oracle.com/javase/7/docs/api/java/util/Comparator.html

[[Category:Ensino]]
[[Category:PO]]
[[category:PO Exemplos]]