Aula 3

InterfacesListas e listas ligadasIteradores

Na aula anterior

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

2009/2010 Programação Orientada por Objectos 2

Interfaces

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) outra2009/2010 Programação Orientada por Objectos 3

Interfaces: definição

public interface Comparable<T> { int compareTo(T object);}

public interface Queue<E> { E element(); void add(E e); void remove();}

2009/2010 Programação Orientada por Objectos 4

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. T é um parâmetro. O correspondente argumento tem de ser um tipo.

Interfaces: implementaçãopublic class Rational implements Comparable<Rational> { private int numerator; private int denominator; … public int compareTo(final Rational another) { int leftNumerator = getNumerator() * another.getDenominator(); int rightNumerator = another.getNumerator() * getDenominator();

if (leftNumerator > rightNumerator) return 1; if (leftNumerator < rightNumerator) return -1; return 0; } …}

2009/2010 Programação Orientada por Objectos 5

public class Rational implements Comparable<Rational> { private int numerator; private int denominator; … public int compareTo(final Rational another){ return getNumerator() * another.getDenominator() - another.getNumerator() * getDenominator(); } …}

Implementação

Interfaces: implementação

2009/2010 Programação Orientada por Objectos 6

«interface»Comparable<T →

Rational>

Rational

Relação de realização

Comparable<T → Rational>

Rational

Interfaces: polimorfismo

public class MyList implements Queue<Customer> {

…

}

public class MyListTester {

…

public static void main(final String[] arguments) { Queue<Customer> customerQueue = new MyList();

… }

…

}2009/2010 Programação Orientada por Objectos 7

Queue<E → Customer>

MyList

Interfaces: nomes

Adjectivo denotando possibilidade de realizar determinadas operações (e.g., Comparable)

Nome denotando conceito cujo comportamento será implementado (e.g., Queue)

2009/2010 Programação Orientada por Objectos 8

Caso semelhante ao das classes abstractas, mas1. 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.

Genericidade

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?

2009/2010 Programação Orientada por Objectos 9

Lista genérica?

public class ArrayList { private Object[] elements;

…}

2009/2010 Programação Orientada por Objectos 10

- elements

*ObjectArrayList

Room

Lista genérica: implementação

public class ArrayList<E> { private E[] elements;

…}

2009/2010 Programação Orientada por Objectos 11

ArrayList<E → Room>

Room*

- elements

ArrayListE

«bind» <E → Room>

- elements : E [*]

Notação UML para classes genéricas (também conhecidas por modelos ou templates).

Classe genérica. E é um parâmetro. O correspondente argumento tem de ser um tipo.

Lista genérica: utilização

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()); }

}

2009/2010 Programação Orientada por Objectos 12

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?

Lista ligada genérica: implementação

public class LinkedList<E> {

Node<E> firstNode = null; Node<E> currentNode = null; …

private static class Node<E> {

private Node<E> nextNode; private E element;

private Node(final Node<E> nextNode, final E element) { this.nextNode = nextNode; this.element = element; }

} …}2009/2010 Programação Orientada por Objectos 13

Classe embutida (nested) privada. A classe LinkedList<E> tem acesso aos membros privados de Node<E>.

Lista ligada genérica: notação

2009/2010 Programação Orientada por Objectos 14

LinkedListE

NodeE

- nextNode: Node- element: E

LinkedListE

- firstNode: Node<E>- currentNode: Node<E>

NodeE

- nextNode: Node- element: E

Notações para o embutimento.

LinkedList::NodeE

- nextNode: Node- element: E

LinkedListE

- firstNode: Node<E>- currentNode: Node<E>

Lista ligada genérica: utilização

public class Floor {

private LinkedList<Room> rooms = new LinkedList<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()); }

}

2009/2010 Programação Orientada por Objectos 15

Inserir novo elemento no início ou no meio da lista não implica “empurrar” elementos existentes!

Lista ligada genérica: Exemplo

2009/2010 Programação Orientada por Objectos 16

rooms : LinkedList<E →

Room>

: Node<E → Room>

firstNode currentNodenextNode

element element

nextNode = null

: Room

: Node<E → Room>

: Room

Lista ligada genérica: inserir no início

public class LinkedList<E> {

Node<E> firstNode = null; …

private static class Node<E> { …

private Node(final Node<E> nextNode, final E element) { this.nextNode = nextNode; this.element = element; } }

public void addFirst(final E newElement) { firstNode = new Node<E>(firstNode, newElement); } …}

2009/2010 Programação Orientada por Objectos 17

Lista ligada genérica: inserir no início

2009/2010 Programação Orientada por Objectos 18

rooms : LinkedList<E →

Room>

: Node<E → Room>

firstNode currentNodenextNode

element element

nextNode = null

: Room

: Node<E → Room>

: RoomnewElement : Room

: Node<E → Room>

nextNode

element

firstNode

Lista ligada genérica: remover do início

public class LinkedList<E> {

…

public void removeFirst() { if (isEmpty()) throw new NoSuchElementException(…);

if (currentNode == firstNode) currentNode = currentNode.nextNode;

Node<E> nextFirstNode = firstNode.nextNode; firstNode.element = null; firstNode.nextNode = null; firstNode = nextFirstNode; }

…

}2009/2010 Programação Orientada por Objectos 19

Lista ligada genérica: remover do início

2009/2010 Programação Orientada por Objectos 20

rooms : LinkedList<E →

Room>

: Node<E → Room>

firstNode currentNodenextNode

element element

nextNode = null

: Room

: Node<E → Room>

: Room

element = null

nextFirstNode : «ref» Node<E → Room>

firstNode

Lista ligada genérica: inserir no fim

public class LinkedList<E> {

…

public void addLast(final E element) { if (firstNode == null) firstNode = new Node<E>(null, element); else lastNode().nextNode = new Node<E>(null, element); }

private Node<E> lastNode() { Node<E> node = firstNode;

while (node.nextNode != null) node = node.nextNode;

return node; }

…}

2009/2010 Programação Orientada por Objectos 21

Lista ligada genérica: inserir no fim

public class LinkedList<E> {

…

public void addLast(final E element) { if (firstNode == null) firstNode = new Node<E>(null, element); else { Node<E> lastNode = firstNode;

while (lastNode.nextNode != null) lastNode = lastNode.nextNode;

lastNode.nextNode = new Node<E>(null, element); } }

…}

2009/2010 Programação Orientada por Objectos 22

Lista ligada genérica: inserir no fim

2009/2010 Programação Orientada por Objectos 23

rooms : LinkedList<E →

Room>

: Node<E → Room>

firstNode currentNodenextNode

element element

nextNode = null

: Room

: Node<E → Room>

: Room

lastNode : «ref» Node<E → Room>

nextNode = null

: Node<E → Room>

nextNode

newElement : Roomelement

Lista ligada genérica: passar ao seguinte

public class LinkedList<E> {

…

public E next() { if (!hasNext()) throw new NoSuchElementException(“…");

if (currentNode == null) currentNode = firstNode; else currentNode = currentNode.nextNode;

return currentNode.element; }

…}

2009/2010 Programação Orientada por Objectos 24

Lista ligada genérica: passar ao seguinte

2009/2010 Programação Orientada por Objectos 25

rooms : LinkedList<E →

Room>

: Node<E → Room>

firstNode currentNodenextNode

element element

nextNode = null

: Room

: Node<E → Room>

: Room

nextNode = null

: Node<E → Room>

nextNode

newElement : Roomelement

currentNode

Lista ligada genérica: notação

2009/2010 Programação Orientada por Objectos 26

LinkedList

E

Node

E

- element: EnextNode

firstNode

currentNode 0..1

0..1

0..10..1

Esta solução não permite percorrer a lista mais do que uma vez em paralelo!

0..1

0..1

1

*

Lista ligada genérica: iteradores

public class Floor {

private LinkedList<Room> rooms = new LinkedList<Room>();

public Floor(final int numberOfRooms) { for (int roomNumber = 1; roomNumber != numberOfRooms + 1; roomNumber++) rooms.add(new Room(roomNumber)); }

public void show() { while (rooms.hasNext()) out.println(rooms.next()); }

}

2009/2010 Programação Orientada por Objectos 27

Lista ligada genérica: iteradores

public class Floor {

private LinkedList<Room> rooms = new LinkedList<Room>();

public Floor(final int numberOfRooms) { for (int roomNumber = 1; roomNumber != numberOfRooms + 1; roomNumber++) rooms.add(new Room(roomNumber)); }

public void show() { LinkedList<Room>.Iterator i = rooms.iterator(); while(i.hasNext()) out.println(i.next()); }

}

2009/2010 Programação Orientada por Objectos 28

Iterator é umaclasse 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.

Lista ligada genérica: notação

2009/2010 Programação Orientada por Objectos 29

LinkedList

E

Node

E

- element: EnextNode

firstNode currentNode

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

Iteradores

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

2009/2010 Programação Orientada por Objectos 30

Mais tarde voltaremos a este assunto.

Programação Orientada por Objectos

A reter…

Interfaces Definem comportamentos (adjectivam) Classes implementam-nas

Listas Listas ligadas Operações sobre listas ligadas Introdução aos iteradores

2009/2010Página

31

Programação Orientada por Objectos

A ler para a próxima aula…

Classes relativas a colecções na API do Java

Capítulos 1 a 10 e 16 do livro:

Y. Daniel Liang, Introduction to Java Programming, 7.ª edição, Prentice-Hall, 2008.ISBN: 978-0-13-605966-0

2009/2010Página

32

Programação Orientada por Objectos

Aula 3: Sumário

Interfaces Listas e listas ligadas Iteradores

2009/2010Página

33