Tópicos

  • Implementação de código com classes internas
  • Comparação de objectos
  • O exercício de C++ deve ser entregue, em papel, na aula prática da semana de 2014/10/27 - ex06cpp.pdf

    Exercício 1: Interfaces java.lang.Comparable e java.util.Comparator

    A interface Comparable<T> exige às classes que a implementam a criação de um método ( T é um tipo)

    int compareTo(T other)

    Este método permite estabelecer uma ordem natural sobre objectos do tipo utilizado para parametrizar a interface. Colecções desses objectos podem então ser ordenadas utilizando métodos pré-definidos (e.g., Collections.sort ou Arrays.sort).

    O método compareTo deve retornar um inteiro menor que zero, zero, ou maior que zero, caso um objecto seja "menor", igual ( equals), ou "maior" que outro objecto. Como a referência null não representa nenhum objecto, se passada como argumento, não deverá ser retornado nenhum valor, devendo as implementações lançar NullPointerException. No exemplo seguite, a ordem natural é definida pela idade do gato.

    public class Cat implements Comparable<Cat> {
      private int _age;
      private String _name;
      public Cat(int age, String name) { _age = age; _name = name; }
      public int getAge() { return _age; }
      public String getName() { return _name; }
      public int compareTo(Cat cat) {
        if (cat == null) throw new NullPointerException();
        return _age - cat.getAge();
      }
    }

    Recordar que equals deve retornar false quando é passada uma referência null como argumento.

    Semelhante ao uso da interface Comparable<T>, mas sem definir uma ordem natural para os objectos de uma classe, a interface Comparator<T> permite criar classes (implementações), cujos objectos representam funções de comparação entre dois objectos da classe utilizada como parâmetro do tipo do comparador. O método exigido pela interface Comparator<T> é:

    int compare(T um, T outro);

    O uso é análogo ao da interface Comparable<T>, mas não compromete uma classe com nenhuma função de comparação especial. Considerando o exemplo do gato, a definição seguinte permitiria, por exemplo, ordenar gatos por nome ( String implementa Comparable<String>, definindo ordem lexicográfica).

    import java.util.Comparator;
    public class CatNameComparator implements Comparator<Cat> {
      public int compare(Cat cat1, Cat cat2) {
        return cat1.getName().compareTo(cat2.getName());
      }
    }

    Recordar que a compatibilidade com equals e a simetria da comparação são como para o caso de compareTo (acima).

    Problema

    1. Considere a tabela da Aula Prática 05. Redefina a classe como sendo comparável. Diz-se que uma tabela é menor/igual/maior que outra quando se verificar a relação menor/igual/maior entre as somas dos elementos de cada uma.
    2. Considere ainda o caso da alínea anterior. Defina agora dois comparadores (devem ser implementados como classes internas da tabela) que estabelecem as relações de comparação relativamente (i) aos máximos das tabelas e (ii) ao número de elementos (independentemente dos valores).
    3. Considere agora, em lugar de tabelas de inteiros, que as tabelas contêm gatos (classe definida acima). Altere o código da alínea 2(i) para que funcione com as tabelas de gatos.

    [ resolução: procurar resolver antes de consultar ]

    Exercício 2: Iteração

    Defina um iterador para a tabela da aula prática 05. O iterador deve ser implementado como uma classe interna e deve implementar a seguinte interface:

    public interface Iterator {

    boolean hasNext(); // true if there are more elements in the collection

    int next(); // get the current element and advance to the next

    }

    A tabela deve implementar a seguinte interface:

    interface Iterable { Iterator getIterator(); }