14. Interfaces; Listas e cadeias ligadas; Iteradores – Fundamentos de Programação

Interfaces
Listas e listas ligadas
Iteradores

 Polimorfismo de subtipos
 Classes e operações polimórficas
 Herança
 Ligação estática e ligação dinâmica
 Classes abstractas e classes concretas
 Operações abstractas
 Análise, desenho e implementação
 Dicionário do domínio
 Conceitos
 Conceitos concretos e conceitos abstractos
2013/2014 Fundamentos de Programação 2

 Definem um comportamento que as classes podem
implementar
 Contêm apenas constantes e declarações de
operações (e tipos embutidos)
 Classes podem implementar interfaces
 Uma classe pode implementar várias interfaces,
embora possa derivar apenas de uma outra classe
 Uma interface pode estender (derivar de) outra

public interface Comparable<Type> {
int compareTo(Type object);
}
public interface Queue<Item> {
Item element();
void add(Item item);
void remove();
}
Operações apenas declaradas.
Não se define qualquer método.
Não é necessário usar o
qualificador abstract.
Operações públicas
por omissão.
Nota: A interface Queue é um
pouco diferente na biblioteca do
Java!
Interface genérica. Type é um
parâmetro. O correspondente
argumento tem de ser um tipo.

public final class Rational implements Comparable<Rational> {
private final int numerator;
private final int denominator;
…
@Override
public int compareTo(final Rational another) {
final int leftNumerator =
getNumerator() * another.getDenominator();
final int rightNumerator =
another.getNumerator() * getDenominator();
if (leftNumerator > rightNumerator)
return 1;
if (leftNumerator < rightNumerator)
return -1;
return 0;
}
…
}

public final class Rational implements Comparable<Rational> {
private final int numerator;
private final int denominator;
…
public int compareTo(final Rational another){
…
}
…
}
Implementação
«interface»
Comparable<Type → Rational>
Rational
Relação de
realização
Comparable<Type → Rational>
Rational

public class CustomerQueue implements Queue<Customer> {
…
}
public class MyQueueTester {
…
public static void main(final String[] arguments) {
Queue<Customer> customerQueue =
new CustomerQueue();
…
}
…
}
Queue<Item → Customer>
CustomerQueue

 Adjectivo denotando possibilidade de realizar
determinadas operações (e.g., Comparable)
 Nome denotando conceito cujo
comportamento será implementado (e.g.,
Queue)
Caso semelhante ao das classes abstractas, mas
1. não há qualquer herança de implementação (i.e.,
de atributos não constantes e métodos) e
2. uma classe que implemente a interface pode
simultaneamente implementar outras interfaces.

 Precisa-se de classes semelhantes
 Com operações semelhantes
 Com atributos semelhantes
 Variando apenas em alguns tipos (e.g., o tipo dos
elementos a guardar em diferentes listas)
 É necessário definir essas classes
separadamente?

public class ArrayList {
private Object[] items;
…
}
- items
*
ObjectArrayList
Room

public class ArrayList<Item> {
private Item[] items;
…
}
ArrayList<Item → Room> Room
*
- items
ArrayList
Item
«bind» <Item → Room>
- items : Item [*]
Notação UML para classes
genéricas (também conhecidas
por modelos ou templates).
Classe genérica. Item é um
parâmetro. O correspondente
argumento tem de ser um tipo.

public class Floor {
private ArrayList<Room> rooms =
new ArrayList<Room>();
public Floor(final int numberOfRooms) {
for (int roomNumber = 1;
roomNumber != numberOfRooms + 1;
roomNumber++)
rooms.addFirst(new Room(roomNumber));
}
public void show() {
while (rooms.hasNext())
out.println(rooms.next());
}
}
Inserir novo elemento no início ou a meio
da lista implica «empurrar» elementos
existentes para «fazer espaço».
Para fazer isto o
que é preciso?

public class LinkedList<Item> {
private Node<Item> firstNode = null;
private Node<Item> currentNode = null;
…
private static class Node<Item> {
private Node<Item> nextNode;
private Item item;
private Node(final Node<Item> nextNode,
final Item item) {
this.nextNode = nextNode;
this.item = item;
}
}
…
}
Classe embutida (nested)
privada. A classe
LinkedList<Item> tem
acesso aos membros
privados de Node<Item>.

LinkedList
Item
Node
Item
- nextNode: Node
- item: Item
LinkedList
Item
- firstNode: Node<Item>
- currentNode: Node<Item>
Node
Item
- nextNode: Node
- item: Item
Notações para o
embutimento.
LinkedList::Node
Item
- nextNode: Node
- item: Item
LinkedList
Item
- firstNode: Node<Item>
- currentNode: Node<Item>

private LinkedList<Room> rooms =
new LinkedList<Room>();
roomNumber++)
rooms.addFirst(new Room(roomNumber));
}
}
}
Inserir novo elemento no início ou no meio
da lista não implica «empurrar» elementos
existentes!

rooms : LinkedList<Item → Room>
: Node<Item → Room>
firstNode currentNode
nextNode
item item
nextNode = null
: Room
: Room

private Node<Item> firstNode = null;
…
private static class Node<Item> {
…
private Node(final Node<Item> nextNode,
final Item item) {
this.nextNode = nextNode;
this.item = item;
}
}
public void addFirst(final Item newItem) {
firstNode = new Node<Item>(firstNode, newItem);
}
…
}

nextNode
item item
nextNode = null
: Room
: RoomnewItem : Room
nextNode
item
firstNode

…
public void removeFirst() {
if (isEmpty())
throw new NoSuchElementException(…);
if (currentNode == firstNode)
currentNode = currentNode.nextNode;
Node<Item> nextFirstNode = firstNode.nextNode;
firstNode.item = null;
firstNode.nextNode = null;
firstNode = nextFirstNode;
}
…
}

nextNode
item item
nextNode = null
: Room
: Room
item = null
nextFirstNode : «ref» Node<Item → Room>
firstNode

…
public void addLast(final Item newItem) {
if (firstNode == null)
firstNode = new Node<Item>(null, newItem);
else
lastNode().nextNode = new Node<Item>(null, newItem);
}
private Node<Item> lastNode() {
Node<Item> node = firstNode;
while (node.nextNode != null)
node = node.nextNode;
return node;
}
…
}

…
public void addLast(final Item newItem) {
if (firstNode == null)
firstNode = new Node<Item>(null, newItem);
else {
Node<Item> lastNode = firstNode;
while (lastNode.nextNode != null)
lastNode = lastNode.nextNode;
lastNode.nextNode = new Node<Item>(null, newItem);
}
}
…
}

nextNode
item item
nextNode = null
: Room
: Room
lastNode : «ref» Node<Item → Room>
nextNode = null
nextNode
newItem : Room
item

…
public Item next() {
if (!hasNext())
throw new NoSuchElementException("…");
if (currentNode == null)
currentNode = firstNode;
else
currentNode = currentNode.nextNode;
return currentNode.item;
}
…
}

nextNode
item item
: Room
: Room
nextNode = null
nextNode
item
currentNode
: Room

LinkedList
Item
Node
Ite
m
- item: Item
nextNode
firstNode
currentNode 0..1
0..1
0..1
0..1
Esta solução não
permite percorrer a
lista mais do que uma
vez em paralelo!
0..1
0..1
1
*

roomNumber++)
rooms.add(new Room(roomNumber));
}
}
}

roomNumber++)
}
LinkedList<Room>.Iterator i = rooms.iterator();
while(i.hasNext())
out.println(i.next());
}
}

roomNumber++)
}
Iterator<Room> i = rooms.iterator();
while(i.hasNext())
out.println(i.next());
}
}

Iterator é uma
classe interna (inner).
As suas instâncias têm
uma ligação implícita
à instância da classe
envolvente que as
criou. A ver com
pormenor mais tarde.
LinkedList
Item
Node
Item
- item: Item
nextNode
0..10..1
0..1
Esta solução permite
percorrer a lista mais
do que uma vez em
paralelo!
Iterator
LinkedList.this
*
0..1
0..1
*
*
1

 Permitem iterar ao longo de uma sequência de
elementos, actuando sobre essa sequência
 A uma sequência podem associar-se vários
iteradores
 Classes que forneçam iteradores podem ser
usadas em ciclos for-each…
 … mas têm de implementar a interface Iterable

roomNumber++)
}
for (Room room : rooms)
out.println(room);
}
}
Mais tarde voltaremos a este assunto.

 Interfaces
 Definem comportamentos (adjectivam)
 Classes implementam-nas
 Listas
 Listas ligadas
 Operações sobre listas ligadas
 Introdução aos iteradores
2013/2014 Fundamentos de Programação
Página
33

 Interfaces
 Listas e listas ligadas
 Iteradores
2013/2014 Fundamentos de Programação
Página
34

14. Interfaces; Listas e cadeias ligadas; Iteradores – Fundamentos de Programação

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a 14. Interfaces; Listas e cadeias ligadas; Iteradores – Fundamentos de Programação

Mais de Manuel Menezes de Sequeira

Último

14. Interfaces; Listas e cadeias ligadas; Iteradores – Fundamentos de Programação

Notas do Editor