PRDS - Programa de Residência em Desenvolvimento de Software

Transcrição

1 PRDS - Programa de Residência em Desenvolvimento de Software Laboratório de Engenharia de Software (LES) da PUC-Rio Carlos Lucena [email protected] Rodrigo Paes [email protected] Gustavo Carvalho [email protected] Cidiane Lobato [email protected]

2 Conteúdo Módulo 1: Java I 4 horas Sintaxe IDE Eclipse Módulo 2: Orientação a Objetos com Java I 8 horas Herança Polimorfismo Associação Delegação Collections [1] Módulo 3: Java II 12 horas Manipulação de arquivos Persistência JDBC Sockets Módulo 4: UML 4 horas Casos de Uso Seqüência Colaboração Classes Módulo 5: Qualidade de Software I 4 horas Teste Assertiva de execução Módulo 6: Orientação a objetos com Java II 8 horas Padrões de projeto Frameworks 2

3 Conteúdo Módulo 7: Java III 12 horas Mapeamento OO --> ER Persistência Hibernate Módulo 8: Desenvolvimento WEB I 16 horas Servlets, JSP, Desenvolvimento de taglibs Arquitetura 3 camadas MVC básico Módulo 9: Desenvolvimento WEB II 20 horas MVC Struts Internacionalização Módulo 10: Desenvolvimento WEB III 28 horas MVC Spring Testes na camada WEB Appfuse 3

4 Conceitos de Orientação a Objetos

5 Objetos Objeto de Software: uma entidade identificada com estado e comportamento específicos. O estado é mantido através de variáveis; o comportamento é implementado por métodos. Objeto Genérico Objeto Bicicleta 5

6 Objetos No modelo de um objeto, as variáveis são mantidas no centro, ou núcleo, do objeto. Os métodos rodeiam e escondem o núcleo do objetos dos outros objetos em uma programa. O empacotamento das variáveis de um objeto por seus métodos é denominado encapsulamento. Esta concepção de um núcleo de variáveis protegido pelos métodos de um objeto é considerada por muitos como a representação ideal de um objeto de software. 6

7 Mensagens Objetos interagem e se comunicam através de mensagens. Quando um objeto A deseja que um objeto B execute um de seus métodos, A envia uma mensagem a B. Informações passadas através de uma mensagem são os parâmetros do método a ser executado. 7

8 Classes Classe: é um modelo que define as variáveis e os métodos comuns a todos os objetos de um certo tipo. Classe Objetos 8

9 Classes Uma variável de classe contém informação compartilhada por todas as instâncias de uma classe. 9

10 Herança Herança: relacionamento entre classes através do qual as variáveis e os métodos de uma superclasse são herdados por suas subclasses. 10

11 Herança Subclasse: uma classe que deriva de outra classe. Superclasse: ancestral direto de uma classe ou quaisquer ascendentes de uma classe. Uma subclasse herda todas as variáveis e métodos de sua superclasse. Contudo, a subclasse pode não ter acesso aos elementos herdados. Herança Múltipla: cada classe possui mais de uma superclasse direta. 11

12 Herança Subclasses podem adicionar variáveise métodosàqueles herdados da superclasse. Subclasses também podem sobrescrever métodos herdados, fornecendo implementação especializada para estes métodos. A árvore de herança ou hierarquia de classes pode ser tão profunda quanto necessário. Em geral, quanto mais abaixo na hierarquia, mais especializado é o comportamento de uma classe. 12

13 Interface Interface: é um contrato na forma de uma coleção de métodos e declarações de constantes. Quando uma classe implementa uma interface, se compromete a fornecer uma implementação para todos os métodos declarados na interface. Uma classe pode implementar múltiplas interfaces. 13

14 Classe X Interface Para compreender a diferença entre classe e interface, é necessário antes entender o conceito de tipo de objeto: define o conjunto de solicitações às quais ele pode atender; define o que o objeto é capaz de fazer; representa a interface do objeto; é uma promessa de serviços. Então o tipo de um objeto é o mesmo que sua classe? A classe de um objeto define o estado interno de um objeto e a implementação de suas operações. A classe define como o objeto é implementado. Representa a implementação do objeto. É o cumprimento de uma promessa de serviços. 14

15 Classe X Interface Sem compreender tipo e classe, não há como entender herança de tipo e herança de implementação... Herança de classe (ou de implementação): Define a implementação de um objeto em função da implementação de outro. Mecanismo para compartilhamento de código. Herança de tipo (ou de interface): Define quando um objeto pode ser utilizado no lugar do outro......cumprindo a mesma promessa que o outro prometeu. 15

16 Classe X Interface Herança de Classe Implementação da mesma forma que o outro implementa!!! Herança de Tipo Implementação do que o outro promete!!! Herança de Classe X Herança de Tipo A herança de implementação também implica herança de tipo!!! 16

17 Mas então... Quando usar herança? O objeto é um tipo especial de... Transação Dispositivo Reserva Compra Mouse Teclado e não um papel assumido por! Pessoa Tripulante Passageiro Agente 17

18 Mas então... Quando usar herança? O objeto nunca tem que mudar para outra classe! Dispositivo Um Tripulante de um vôo pode ser Passageiro de outro. Mouse Teclado Pessoa Um Mouse nunca vai se tornar um Teclado Tripulante Passageiro Agente 18

19 Mas então... Quando usar herança? As subclasses não sobrescrevem métodos da superclasse (apenas adicionam!). Superclasse desenhar() testar() Sobrescreve tudo!? Pra que herdar??? Superclasse desenhar() testar() SubclasseA SubclasseB SubclasseA SubclasseB imprimir() executar() Novas funcionalidades... Compartilha código! desenhar() testar() desenhar() testar() 19

20 Outros conceitos Polimorfismo Polimorfismo: termo usado para significar que uma chamada de método pode ser executada de várias formas (ou polimorficamente), sendo que quem decide a forma é o objeto que recebe a chamada. Por exemplo: Se um objeto "a" chama um método grita() de um objeto "b", então o objeto "b" decide a forma de implementar o método. A chamada b.grita() vai ser um grito humano se "b" for um humano e será um grito de macaco, se o objeto "b" for um macaco. O que importa, portanto, é o tipo do objeto "b". 20

21 Outros conceitos Relacionamentos Para que objetos se comuniquem eles precisam se relacionar. São possíveis os seguintes tipos de relacionamento: Herança; Associação; Agregação; Composição; Dependência. Uma seqüência de comunicação entre objetos para a realização de um serviço é denominada delegação. 21

22 Relacionamentos entre Classes Herança: relacionamento entre itens gerais (superclasse) e itens mais específicos (subclasses). Por exemplo: em uma universidade, Comando e Matrícula. Associação: relacionamento que indica que os objetos de uma classe estão vinculados a objetos de outra classe. Por exemplo: no DAR de uma universidade, existem associações entre Turma e Aluno, Professor e Disciplina, etc. Agregação: tipo de associação utilizada para indicar um relacionamento todo-parte ; um objeto parte pode fazer parte de vários objetos todo. Por exemplo, Pedido e Item, Universidade e Curso, etc. 22

23 Relacionamentos entre Classes Composição: é uma variante semanticamente mais forte da agregação em que objetos parte só pertencem a um único todo e têm o tempo de vida coincidente com o dele. Por exemplo, Notebook e Teclado, Window e Frame, etc. Dependência: relacionamento de utilização entre dois itens, no qual a alteração de um (o item independente) pode afetar o outro (o item dependente). Por exemplo, Cliente e Fornecedor, etc. 23

24 Conceitos de Orientação a Objetos em Java

25 Classes em Java Classe: é um modelo que define as variáveis e os métodos comuns a todos os objetos de um certo tipo. 25

26 Classes em Java A classe anterior contém o código que implementa o ciclo de vida dos objetos instanciados a partir da classe: construtores para inicialização de novos objetos; variáveis que mantém o estado da classe e de seus objetos; métodos que implementam o comportamento da classe e de seus objetos. Além dos elementos acima (construtores, variáveis e métodos), é possível especificar outras informações: nome de uma possível superclasse; implementação de interfaces; se a classe pode ser herdada, etc. 26

27 Classes em Java Elemento public abstract final class NameOfClass extends Super implements Interfaces { ClassBody } Função (Opcional) Classe é publicamente acessível (Opcional) Classe não pode ser instanciada (Opcional) Classe não pode ter subclasses (Obrigatório) Nome da classe (Opcional) Superclasse da classe (Opcional) Interfaces implementadas pela classe (Obrigatório) Fornece a funcionalidade da classe 27

28 Classes em Java public: declara que a classe pode ser usada por qualquer outra classe. Sem public, uma classe pode ser usada somente por classes no mesmo pacote. abstract: especifica uma classe abstrata a partir da qual não é possível criar uma instância (ex. abstract class Number: class Integer e class Float). final: a classe não pode possuir subclasses (ex. String). extends Super: identifica Super como superclasse; implements Interfaces: enumera as interfaces implementadas pela classe. 28

29 Interfaces de Java Interface: é uma coleção nomeada de definições de métodos, sem as respectivas implementações. Diferenças entre Interfaces e Classes Abstratas: uma interface não pode implementar métodos, ao passo que uma classe abstrata pode; uma classe pode implementar muitas interfaces mas não pode ter mais que uma superclasse; uma interface não é parte da hierarquia de classes; classes não-relacionadas podem implementar a mesma interface. 29

30 Herança em Java 30

31 Herança em Java A classe Object é o topo da hierarquia de classes, sendo cada classe sua descendente. Portanto, uma variável Object pode armazenar uma referência para qualquer objeto (uma classe ou vetor). A classe Object provê comportamentos compartilhados por todos os objetos sendo executados na JVM. Por exemplo, todas as classes herdam o método tostring da classe Object, que retorna uma representação em string para um objeto. 31

32 Polimorfismo em Java Presente em todas as chamadas de métodos: um objeto "a" possui uma referência para o objeto "b", e realiza a chamada b.m(), que pode ser executa de várias formas, dependendo do tipo de b. Seguem exemplos: class A { void façaalgo() { //O objeto "a" cria o objeto "b" Gritador b; if(...) { b = new Humano(); } else { b = new Macaco(); } b.grita(); // chamada polimórfica } } 32

33 Polimorfismo em Java class A { void façaalgo() { // O objeto "a" recebe o objeto "b" de um objeto "c. // "c" é um objeto qualquer para o qual se tem referência. Gritador b = c.medêumgritador(); b.grita(); // chamada polimórfica } } class A { //O objeto "a" recebe o objeto "b" numa chamada de método. void façaalgo(gritador b) { b.grita(); // chamada polimórfica } } Não existe polimorfismo em métodos de classe! 33

34 Polimorfismo em Java O polimorfismo existe em chamadas a métodos definidos em interfaces e superclasses. Exemplo com interfaces: interface Gritador { void grita(); } class Humano implements Gritador { public void grita() {System.out.println("AAHHAAHHAAHHA"); // Me Tarzan!} } class Macaco implements Gritador { public void grita() {System.out.println("IIHIIHHIIHHII"); // Me Cheetah! } } 34

35 Polimorfismo em Java A herança de implementação também permite fazer polimorfismo, porque permite criar classes que implementam o mesmo tipo. class UmGritador { public grita() { System.out.println("Buuuuu"); } } class Humano extends UmGritador { public void grita() { System.out.println("AAHHAAHHAAHHAA"); } } Ao herdar, a subclasse Humano faz o override (substituição, sobrecarga de) alguns métodos. A classe Humano decidiu gritar de forma diferente! 35

36 Polimorfismo em Java Para fazer polimorfismo, é melhor usar herança de tipo ou herança de implementação? É preferível usar herança de tipo para fazer polimorfismo e usar herança de implementação apenas para fatorar código comum entre várias classes. Em outras palavras: defina comportamentos ("ser um gritador") com tipos abstratos (interfaces) e use-os no polimorfismo; defina implementações ( como gritar ) com classes e use superclasses para fatorar implementações comuns. 36

37 Relacionamentos entre Classes em Java Herança: em Java, é implementada através dos operadores implements (herança de tipo) e extends (herança de implementação). Ex: Gritador, Humano e Macaco. Associação: em Java, é implementada através da declaração de atributos. Quanto o atributo é uma coleção, tem-se uma agregação ou composição de objetos. Ex.: no DAR de uma universidade, a associação entre Professor e Disciplina, etc. class Disciplina{ Professor professor;... } Associação Simples class Professor{ Collection disciplinas;... } Agregação 37

38 Relacionamentos entre Classes em Java Dependência: em Java, existe tal relacionamento entre duas classes quando: uma classe utiliza outra somente como parâmetro de entrada na assinatura de ao menos uma de suas operações; uma classe utiliza outra somente como variável local de ao menos um de seus métodos. Por exemplo, no DAR de uma universidade, entre as classes Universidade e Departamento: class Universidade{ Collection departamentos;... } Agregação class Universidade{... getdisciplinas(departamento d)... } Dependência 38

39 Aplicação ClickMeApp ClickMeApp: possui um componente GUI chamado ClickMe; um círculo aparece quando clicamos com o mouse dentro da área do componente ClickMe. São compiladas as classes ClickMeApp, ClickMe e Spot. Outras classes fornecidas por Java são utilizadas. 39

40 Aplicação ClickMeApp: Classe Spot public class Spot { //instance variables private int size; public int x, y; //constructor public Spot() { x = -1; y = -1; size = 1; } //methods for access to the size instance variable public void setsize(int newsize) { if (newsize >= 0) { size = newsize; } } public int getsize() { return size; } } 40

41 Aplicação ClickMeApp: Classe ClickMe (I) import javax.swing.borderfactory; import javax.swing.jcomponent; import java.awt.*; import java.awt.event.*; public class ClickMe extends JComponent implements MouseListener { private Spot spot = null; private static final int RADIUS = 7; private Color spotcolor = new Color(107, 116, 2); //olive //... 41

42 Aplicação ClickMeApp: Classe ClickMe (II) //... /** Creates and initializes the ClickMe component. */ public ClickMe() { addmouselistener(this); //Hint at good sizes for this component. setpreferredsize(new Dimension(RADIUS * 30, RADIUS * 15)); setminimumsize(new Dimension(RADIUS * 4, RADIUS * 4)); //Request a black line around this component. setborder(borderfactory.createlineborder(color.black)); } //... 42

43 Aplicação ClickMeApp: Classe ClickMe (III) /** * Paints the ClickMe component. This method is * invoked by the Swing component-painting system. */ public void paintcomponent(graphics g) { /** * Copy the graphics context so we can change it. * Cast it to Graphics2D so we can use antialiasing. */ Graphics2D g2d = (Graphics2D)g.create(); //... 43

44 Aplicação ClickMeApp: Classe ClickMe (IV) //Turn on antialiasing so that painting is smooth. g2d.setrenderinghint( RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); //Paint the background. g2d.setcolor(color.white); g2d.fillrect(0, 0, getwidth() - 1, getheight() - 1); //Paint the spot. if (spot!= null) { int radius = spot.getsize(); g2d.setcolor(spotcolor); g2d.filloval(spot.x - radius, spot.y - radius, radius * 2, radius * 2); } } //... 44

45 Aplicação ClickMeApp: Classe ClickMe (V) } //Methods required by the MouseListener interface. public void mousepressed(mouseevent event) { if (spot == null) { spot = new Spot(); spot.setsize(radius); } spot.x = event.getx(); spot.y = event.gety(); repaint(); } public void mouseclicked(mouseevent event) {} public void mousereleased(mouseevent event) {} public void mouseentered(mouseevent event) {} public void mouseexited(mouseevent event) {} 45

46 Aplicação ClickMeApp: Classe ClickMeApp (I) import javax.swing.swingutilities; import javax.swing.jlabel; import javax.swing.jframe; import java.awt.borderlayout; public class ClickMeApp implements Runnable { /* This constructor creates an instance of ClickMeApp, which creates and shows a window containing a ClickMe component. */ public ClickMeApp() { /* Tells the event-dispatching thread (used to display and handle events of a Swing GUI) to call the run method of "this" (the ClickMeApp object this constructor created). The argument to invokelater must implement the Runnable interface, which guarantees that it defines the run method. */ SwingUtilities.invokeLater(this); } //... 46

47 Aplicação ClickMeApp: Classe ClickMeApp (II) /** * Creates and shows the GUI. This method should be * invoked on the event-dispatching thread. */ public void run() { createandshowgui(); } /** * Brings up a window that contains a ClickMe component. * For thread safety, this method should be invoked from * the event-dispatching thread. */ private static void createandshowgui() { //... 47

48 Aplicação ClickMeApp: Classe ClickMeApp (III) //Make sure we have nice window decorations. JFrame.setDefaultLookAndFeelDecorated(true); //Create and set up the window. JFrame frame = new JFrame("ClickMeApp"); frame.setdefaultcloseoperation(jframe.exit_on_close); //Set up the layout manager. frame.setlayout(new BorderLayout()); //Add the ClickMe component. ClickMe component = new ClickMe(); frame.add(component, BorderLayout.CENTER); //... 48

49 Aplicação ClickMeApp: Classe ClickMeApp (IV) } //Add an explanatory label. frame.add(new JLabel("Click within the rectangle."), BorderLayout.SOUTH); //Display the window. frame.pack(); frame.setvisible(true); } //This method is automatically executed. public static void main(string[] args) { //Create an instance of ClickMeApp. new ClickMeApp(); } 49

50 API Orientada a Objetos de Java Hierarquia de Collections

51 Introdução Coleção: é um objeto que agrupa múltiplos elementos em uma única unidade para armazenar, recuperar e manipular dados agregados. Representa itens de dados que formam um grupo natural, como uma caixa de s ou uma lista telefônica. Implementações de coleção em versões Java pré-1.2 incluíam Vector, Hashtable e Array, mas não existia ainda um framework de coleções. 51

52 Introdução Framework de coleções: é uma arquitetura unificada para representar e manipular coleções, contendo: interfaces: tipos abstratos de dados que representam coleções. Permitem que coleções sejam manipuladas independentemente de sua representação; implementações: implementações concretas das interfaces de coleção. São estruturas de dados reusáveis; algoritmos: métodos que realizam computações úteis, tais como busca e ordenação sobre objetos que implementam as interfaces de coleção. São ditos polimórficos : o mesmo método pode ser usado em diferentes implementações da interface de coleção apropriada. São funções reusáveis. 52

53 Interfaces Formam uma hierarquia de diferentes tipos de coleções que permitem a manipulação de dados independentemente de sua representação. Set é um tipo especial de Collection, SortedSet é um tipo de Set, etc. Note que a hierarquia consiste de duas árvores diferentes: um Map não é um Collection verdadeiro. 53

54 Interfaces Todas as interfaces de coleção são genéricas. public interface Collection<E>... <E> significa que a interface é genérica. Quando uma instância de Collection é declarada, deve-se especificar o tipo de objeto contido na coleção: List<String> list = new ArrayList<String>; Isto permite verificar em tempo de compilação se o tipo de objeto a ser armazenado na coleção está correto. 54

55 Interfaces Collection: a raiz da hierarquia de coleções. É usada quando uma generalidade máxima é necessária. Java não provê implementações diretas desta interface. Set: coleção que não pode conter elementos duplicados. Modela a abstração matemática de conjuntos. Exemplo: processos executando em uma máquina. List: chamada de seqüência, é uma coleção ordenada. Pode conter elementos duplicados. O usuário de List pode controlar a posição em que um elemento é inserido e acessa elementos através de um índice. Corresponde à noção de vetores. 55

56 Interfaces Queue: coleção de elementos com prioridades associadas. Provê operações de inserção, extração e inspeção. Tipicamente ordena elementos no esquema FIFO. Entre as exceções, estão as filas de prioridade. Map: objeto que mapeia chaves e valores. Não pode conter chaves duplicadas. Corresponde ao uso de Hashtables. SortedSet: Set com elementos em ordem ascendente. SortedMap: Map com chaves em ordem ascendente. 56

57 Interface Collection: Operações public interface Collection<E> extends Iterable<E> { //Basic operations int size(); boolean isempty(); boolean contains(object element); boolean add(e element); //optional boolean remove(object element); //optional Iterator iterator(); //Bulk operations boolean containsall(collection<?> c); boolean addall(collection<? extends E> c); //optional boolean removeall(collection<?> c); //optional boolean retainall(collection<?> c); //optional void clear(); //optional //Array operations Object[] toarray(); <T> T[] toarray(t[] a); } 57

58 Interface Collection: Iterador Iterador: objeto que permite percorrer uma coleção e remover elementos seletivamente. public interface Iterator<E> { boolean hasnext(); E next(); void remove(); //optional } hasnext() retorna true se a iteração possui mais elementos e next() retorna o próximo elemento na iteração. remove() remove o último elemento retornado pelo next(): pode ser chamado somente uma vez por next() e levanta uma exceção caso esta regra seja violada. 58

59 Interface Collection: Iterador O seguinte método mostra como usar um Iterator para filtrar uma coleção, isto é, remover elementos específicos. static void filter(collection c) { for (Iterator i = c.iterator(); i.hasnext(); ) if (!cond(i.next())) i.remove(); } O código acima é polimórfico: funciona para qualquer Collection (sem levar em conta a implementação)! 59

60 Interface Set: Implementações Set implementa a abstração matemática de conjuntos: contém somente métodos herdados de Collection e adiciona a restrição de que duplicações não são possíveis. Java dispõe de três implementações de Set: HashSet: elementos em uma tabela hash, melhor performance e nenhuma garantia quanto à ordem de iteração. TreeSet: elementos em uma árvore vermelho-preto, substancialmente mais lento que HashSet e ordena elementos baseados em seus valores. LinkedHashSet: elementos em uma tabela hash associada a uma lista encadeada, apenas um pouco mais lento que HashSet e ordena elementos por ordem de inserção. 60

61 Interface Set: Operações public interface Set<E> extends Collection<E> { //Basic operations int size(); boolean isempty(); boolean contains(object element); boolean add(e element); //optional boolean remove(object element); //optional Iterator iterator(); //Bulk operations boolean containsall(collection<?> c); boolean addall(collection<? extends E> c); //optional boolean removeall(collection<?> c); //optional boolean retainall(collection<?> c); //optional void clear(); //optional //Array operations Object[] toarray(); <T> T[] toarray(t[] a); } 61

62 Interface Set: Operacões Adaptação de métodos Collection para Set ( s é um Set): s.size(): retorna a cardinalidade de s ; s.isempty(): retorna um booleano indicando se s é {}; s.add(e): adiciona elemento especificado a s se este não está presente e retorna booleano indicando se houve adição; s.remove (Object): remove elemento especificado de s e retorna booleano indicando se houve remoção; s.iterator(): retorna um Iterator de s; s1.containsall(s2): retorna true se s2 é subconjunto de s1; s1.addall(s2): transforma s1 na união de s1 e s2; s1.retainall(s2): transforma s1 na interseção de s1 e s2; s1.removeall(s2): transforma s1 na diferença entre s1 e s2; s.toarray(): o mesmo que para Collection. 62

63 Interface Set: Exemplo O programa seguinte toma palavras em args[] e imprime: uma mensagem que indica se há duplicação de palavras, o múmero de palavras distintas e uma lista das plavras duplicadas eliminadas. import java.util.*; public class FindDups { public static void main(string args[]) { Set<String> s = new HashSet<String>(); for (String a : args) if (!s.add(a)) System.out.println("Duplicate: " + a); System.out.println(s.size()+" distinct words: "+s); } } 63

64 Interface Set: Exemplo Note que o código sempre se refere ao Collection por Set (interface) em vez de HashSet (implementação). Esta prática é fortemente recomendada, porque torna possível flexibilizar a mudança de tipo de implementação apenas pela mudança do construtor. Ao contrário, se variáveis referentes a uma coleção ou a parâmetros usados são declarados a partir de tipos de implementação, todas elas deverão também ser modificadas. Isto vale para o uso de interfaces e implementações em geral! 64

65 Interface Set: Exemplo Saída do programa; ex. java FindDups i came i saw i left : Duplicate: i Duplicate: i 4 distinct words: [i, left, saw, came] Observe que HashSet não dá garantias quanto à ordem dos elementos no Set. Para obter as palavras em ordem alfabética, basta modificar HashSet para TreeSet. Por ex., nova saída para java FindDups i came i saw i left : Duplicate word: i Duplicate word: i 4 distinct words: [came, i, left, saw] 65

66 Interface Set: Exemplo Voltando ao programa FindDups... import java.util.*; public class FindDups2 { public static void main(string args[]) { Set<String> uniques = new HashSet<String>(); Set<String> dups = new HashSet<String>(); for (String a : args) if (!uniques.add(a)) dups.add(a); uniques.removeall(dups); System.out.println("Unique words: " + uniques); System.out.println("Duplicate words: " + dups); } } Nova saída para java FindDups2 i came i saw i left : Unique words: [left, saw, came] Duplicate words: [i] 66

67 Interface List: Implementações List é um Collection ordenado que pode conter duplicações. Em adição às operações herdadas de Collection, List inclui as seguintes operações: acesso posicional: manipulação de elementos baseada na posição numérica destes na lista; busca: procura por um objeto especificado na lista e retorna sua posição numérica; iteração: extende a semântica de Iterator a fim de tirar vantagem da natureza seqüencial da lista; de intervalo: operações em intervalos arbitrários da lista. Java dispõe de duas implementações para List: ArrayList e LinkedList (ArrayList possui a melhor performance). 67

68 Interface List: Operações public interface List<E> extends Collection<E> { //Positional access E get(int index); E set(int index, E element); //optional boolean add(e element); //optional void add(int index, E element); //optional E remove(int index); //optional abstract boolean addall(int index, Collection<? extends E> c); //optional //Search int indexof(object o); int lastindexof(object o); //Iteration ListIterator<E> listiterator(); ListIterator<E> listiterator(int index); //Range-view List<E> sublist(int from, int to); } 68

69 Interface List: Operações Operações herdadas de Collection têm a mesma semântica. Apenas remove() sempre remove a primeira ocorrência na lista do elemento especificado. As operações add e addall sempre adicionam os novos elementos no final da lista. Operações posicionais: get, set, add e remove têm a mesma semântica de operações em vetores. set e remove retornam valor antigo sobrescrito ou removido; addall insere elementos começando na posição especificada. Operações de busca: indexof e lastindexof têm a mesma semântica de operações em vetores. 69

70 Interface List: Operações Operações de iteração: List provê um iterator sofisticado que permite percorrer a lista em ambas direções, modificar a lista durante a iteração e obter posição do iterador. public interface ListIterator<E> extends Iterator<E> { boolean hasnext(); E next(); boolean hasprevious(); E previous(); int nextindex(); int previousindex(); void remove(); //optional void set(e o); //optional void add(e o); //optional } 70

71 Interface List: Operações Operações de intervalo: sublist(int fromindex, int toindex) retorna uma visão de List que corresponde ao intervalo que vai de fromindex, inclusive, para a toindex, exclusive. 71

72 Exercícios

73 Exercícios Implementar um programa utilizando coleções. Dar preferência ao uso das coleções List e Map. Torne possível a reusabilidade, desenvolvendo o programa de forma que a mudança de implementação de uma coleção possa ser realizada rapidamente. 73

74 Referências [1] Tutorial da Sun Microsystems. 74