Java 5 – Novos recursos

1. Java 5 – Novos recursos Jobson Ronan {jrjs@cin.ufpe.br}

2. Objetivos • Java 5 Tiger adicionou uma série de recursos novos, como nenhum outro release do Java havia adicionado • O objetivo desta aula é apresentar as novas características e recursos da linguagem Java • Principalmente em que estes novos recursos podem nos ajudar a escrever código mais simples, legível menos susceptíveis a erros.

3. Objetivos • Esses novos recursos são • Generics • Enhanced For Loop • Autoboxing/Unboxing • Typesafe Enums • Varargs • Static Imports • Annotations (Metadata)

4. Generics – Tipos Genéricos • Este recurso ao sistema de tipos esperado a muito tempo permite um tipo ou um metodo operar sobre objetos de vários tipos provendo type-safety em tempo de compilação. Isto adiciona type-safety em tempo de compilação ao Framework de Collections eliminando a “sujeria” casting. [JSR 14]

5. Generics – Tipos Genéricos • Quando se obtém um objeto de um Collection, deve-se aplicar um cast do tipo do objeto guardado na Collection. • Além de inconveniente, isto é inseguro • O compilador não checa se se o cast é do mesmo tipo da coleção. • O cast pode falhar em tempo de execução.

6. Generics – Tipos Genéricos • Generics adicionam um meio de avisar ao compilador o tipo da coleção • Dessa forma ela pode ser checada. • O compilador sabendo o tipo da coleção, pode checar se a coleção esta sendo usada consistentemente e inserir os casts corretos

7. Generics – Tipos Genéricos • Exemplo simples existente no tutorial de Collecions (antigo) • Exemplo modificado usando generics // Removes 4-letter words from c. Elements must be stringsstatic void expurgate(Collection c) { for (Iterator i = c.iterator(); i.hasNext(); ) if (((String) i.next()).length() == 4) i.remove();} // Removes the 4-letter words from cstatic void expurgate(Collection<String> c) { for (Iterator<String> i = c.iterator(); i.hasNext(); ) if (i.next().length() == 4) i.remove(); }

8. Generics – Tipos Genéricos • Quando se escreve <Type>, leia isso com “de Type” • A declaração anterior pode ser lida como “Coleção de Strings”. • O código usando generics é limpo e seguro. • Elimina-se um cast inseguro e um numero de parâmetros extras. • Mais importante, move-se parte da especificação de um método do seu comentário para sua assinatura

9. Generics – Tipos Genéricos • Partes de códigos existentes na definição de List e Iterator do pacote java.util public interfaceList<E> {voidadd(E x); Iterator<E> iterator(); }public interfaceIterator<E> {E next(); booleanhasNext(); }

10. Bounded Wilcards • Considere as seguintes declarações • Podemos definir o seguinte metodo public abstract classShape {public abstract voiddraw(Canvas c); }public classCircle extendsShape {private intx, y, radius; public voiddraw(Canvas c) { ... } }public classRectangle extendsShape {private intx, y, width, height; public voiddraw(Canvas c) { ... } } public voiddrawAll(List<Shape> shapes) {for(Shape s: shapes) { s.draw(this); } }

11. Bounded Wilcards • Porém o método não poderia ser chamado sobre um List<Circle> • Porém queremos que o método aceite listas de qualquer tipo de Shape public voiddrawAll(List<? extends Shape> shapes) { ... }

12. Enhanced for Loop – “for each” • Esta nova construção da linguagem elimina a necesidade do Iterators (“sujos” e causadores de erros) ao iterar sobre coleções e arrays. [JSR 201] • Considere o seguinte metodo que recebe uma coleção de “TimerTask” e as cancela • A variavel do iterator aparece 3 veses em cada loop • Isto significa 2 chances de fazer “besteira” void cancelAll(Collection<TimerTask> c) { for (Iterator<TimerTask> i = c.iterator(); i.hasNext(); ) i.next().cancel(); }

13. Enhanced for Loop – “for each” • A contrução do “for each” elimina a confusão e as oportunidades de erros. • Observe o exemplo de como usar o “for each”: • Quando se escreve “dois pontos” (:) leia-se como “em” ou “de” • No loop acima: “para cada TimerTask t em c”. • Se combina de forma limpa com generics void cancelAll(Collection<TimerTask> c) { for (TimerTask t : c) t.cancel(); }

14. Enhanced for Loop – “for each” • Um erro comum ao usar Iterators • Alguém consegue ver o bug? Muitos desenvolvedores experientes cometem este erro uma vez ou outra • O problema é que o metodo next é chamado muitas vezes na coleção de “fora” (suits) List suits = ...; List ranks = ...; List sortedDeck = new ArrayList(); // BROKEN - throws NoSuchElementException! for (Iterator i = suits.iterator(); i.hasNext(); ) for (Iterator j = ranks.iterator(); j.hasNext(); ) sortedDeck.add(new Card(i.next(), j.next()));

15. Enhanced for Loop – “for each” • Para consertar o erro é preciso declarar uma variavel no escopo do loop de “fora” • O que isso tem a ver com o “for each”? // Fixed, though a bit ugly for (Iterator i = suits.iterator(); i.hasNext(); ) { Suit suit = (Suit) i.next(); for (Iterator j = ranks.iterator(); j.hasNext(); ) sortedDeck.add(new Card(suit, j.next())); } for (Suit suit : suits) for (Rank rank : ranks) sortedDeck.add(new Card(suit, rank));

16. Enhanced for Loop – “for each” • Ainda pode ser usado com arrays • Pode-se adicionar suporte do “for each” a qualquer custon collection • Basta implementar a interface java.lang.Iterable<T> // Returns the sum of the elements of a int sum(int[] a) { int result = 0; for (int i : a) result += i; return result; }

17. Enhanced for Loop – “for each” • Use “for each” sempre que puder • Melhora a simplicidade e a qualidade do código • Observe que “for each”s são usados apenas em iterações onde não se deseja remover ou substituir os elementos da coleção

18. Autoboxing/Unboxing • Este recurso elimina a “sujeira” causada pela conversão manual de tipos primitivos (como int) em wrapper classes (como Integer) [JSR 201]

19. Autoboxing/Unboxing • Como era feito a conversão de tipos primitivos em objetos wrapper • Com Autoboxing/Unboxing int x = 2; Integer y = new Integer(3); int z = x + y.intValue(); int x = 2; Integer y = 3; int z = x + y; Integer w = z;

20. Autoboxing/Unboxing • Exemplo utilizando autoboxing/unboxing mais generics e “for each” import java.util.*; // Prints a frequency table of the words on the command line public class Frequency { public static void main(String[] args) { Map<String, Integer> m = new TreeMap<String, Integer>(); for (String word : args) { Integer freq = m.get(word); m.put(word, (freq == null ? 1 : freq + 1)); } System.out.println(m); } } > java Frequency if it is to be it is up to me to do the watusi > {be=1, do=1, if=1, is=2, it=2, me=1, the=1, to=3, up=1, watusi=1}

21. Typesafe Enums – Tipos enumerados • Uma facilidade de tipos enumerados bem orientada a objetos com métodos e atributos arbitrários. • Possui todos os benefícios do Typesafe Enum pattern (“Effective Java”, item 21) sem a grande quantidade de código necessária.

22. Typesafe Enums – Tipos enumerados • Antiga forma de representar tipos enumerados • Problemas • Não é typesafe • Não possui namespace • Brittleness – Problema da recompilação • Valores impressos não são informativos public class PlayingCard { public static final int SUIT_CLUBS = 0; public static final int SUIT_DIAMONDS = 1; public static final int SUIT_HEARTS = 2; public static final int SUIT_SPADES = 3; ... }

23. Typesafe Enums – Tipos enumerados • Typesafe Enum pattern (Effective Java) // The typesafe enum pattern public class Suit { private final String name; private Suit(String name) { this.name = name; } public String toString() { return name; } public static final Suit CLUBS = new Suit("clubs"); public static final Suit DIAMONDS = new Suit("diamonds"); public static final Suit HEARTS = new Suit("hearts"); public static final Suit SPADES = new Suit("spades"); }

24. Typesafe Enums – Tipos enumerados • Java 5 enum • E Java 5 enums ainda • Possuem implementação de alta qualidade a todos os métodos de Object • Podem possuir métodos e atributos quaisquer • Podem implementar qualquer interface • Implementam Serializable e Comparable • Podem ser usados em um case public enum Suit { CLUBS, DIAMONDS, HEARTS, SPADES }

25. Typesafe Enums – Tipos enumerados • Um exemplomaior public enum Planet { MERCURY (3.303e+23, 2.4397e6), VENUS (4.869e+24, 6.0518e6), EARTH (5.976e+24, 6.37814e6), ... PLUTO (1.27e+22, 1.137e6); private final double mass; // in kilograms private final double radius; // in meters Planet(double mass, double radius) { this.mass = mass; this.radius = radius; } private double mass() { return mass; } private double radius() { return radius; } // universal gravitational constant (m3 kg-1 s-2) public static final double G = 6.67300E-11; double surfaceGravity() { return G * mass / (radius * radius); } double surfaceWeight(double otherMass) { return otherMass * surfaceGravity(); } }

26. Varargs – Multiplos argumentos • Esta nova característica da linguagem Java elimina a necessidade de empacotar listas em um array ao chamar métodos que recebem múltiplos argumentos.

27. Varargs – Multiplos argumentos • Em um passado não muito distante, um método que aceitava um número arbitrário de valores obrigava a criação uma array com os valores dentro antes de proceder com a chamada de método Object[] arguments = { new Integer(7), new Date(), "a disturbance in the Force" }; String result = MessageFormat.format( "At {1,time} on {1,date}, there was {2} on planet " + "{0,number,integer}.", arguments);

28. Varargs – Multiplos argumentos • Ainda é verdade que múltiplos argumentos precisam ser passados como um array. • Porém, varargs automatizam e escondem o processo. • Além disso, é totalmente compatível com a API antiga String result = MessageFormat.format( "At {1,time} on {1,date}, there was {2} on planet " + "{0,number,integer}.", 7, new Date(), "a disturbance in the Force");

29. Varargs – Multiplos argumentos • Exemplo de declaração • Os três pontos indicam que o ultimo argumento pode ser passado como um array ou como uma sequencia de argumentos • Varargs podem ser usados apenas na posição final da lista de argumentos • Na implementação do método o argumento multiplo é acessado como um array public static String format(String pattern, Object... arguments);

30. Varargs – Multiplos argumentos • Java agora tem printf • Classe PrintStream public PrintStream printf(String format, Object... args)

31. Static Imports • Este mecanismo permite importar não só definições de classes, como definições de métodos estáticos e constantes. • Este mecanismo foi criado visando combater ao “Constant Interface Antipattern”

32. Static Imports • Para acessar membros estáticos, era necessário qualificar as referências com as classes de onde elas vinham • Agora pode-se fazer • Ou até mesmo double r = Math.cos(Math.PI * theta); import static java.lang.Math.PI; import static java.lang.Math.*;

33. Static Imports • E finalmente • A adição deste mecanismo a linguagem Java é, foi e continua sendo bastante questionada • Pode comprometer a legibilidade do código • Use apenas se você ficar tentado a usar o“Constant Interface Antipattern” double r = cos(PI * theta);

34. Annotations (Metadata) • Este mecanismo permite “decorar” classes, métodos e atributos • Permite adicionar metadados direto no código fonte • Em muitas circunstancias pode ajudar a eliminar a necessidade de escrever código possibilitando uma ferramenta gerar este baseado nos metadados presentes no código fonte • Também elimina a necessidade de manter “side-files”. Arquivos que precisam ser atualizados conforme mudanças no código-fonte.

35. Annotations (Metadata) • Como assim? • Annotations podem ser acessadas via Reflexão. • Então, uma ferramenta pode analisar um código facilmente e fazer o que quiser com ele. • Annotations não alteram a semântica do programa, mas podem afetar como o programa é tratado por ferramentas e bibliotecas. • Programadores típicos nunca precisarão definir um tipo Annotation. Porém não é difícil faze-lo

36. Annotations (Metadata) • Criando um mini-framework de para testes automatizados (from JDK5 Documentation): import java.lang.annotation.*; /** * Indicates that the annotated method is a test method. * This annotation should be used only on parameterless static methods. */ @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface Test { }

37. Annotations (Metadata) • Um programa simples usando as annotation definidas public class Foo { @Testpublic static void m1() { } public static void m2() { } @Testpublic static void m3() { throw new RuntimeException("Boom"); } public static void m4() { } @Testpublic static void m5() { } public static void m6() { } @Testpublic static void m7() { throw new RuntimeException("Crash"); } public static void m8() { } }

38. Annotations (Metadata) • A ferramenta de testes import java.lang.reflect.*; public class RunTests { public static void main(String[] args) throws Exception { int passed = 0, failed = 0; for (Method m : Class.forName(args[0]).getMethods()) { if (m.isAnnotationPresent(Test.class)) { try { m.invoke(null); passed++; } catch (Throwable ex) { System.out.printf("Test %s failed: %s %n", m, ex.getCause()); failed++; } } } System.out.printf("Passed: %d, Failed %d%n", passed, failed); } }

39. Conclusões • Tantos foram os recursos adicionados na nova especificação que a linguagem passou de Java 2 para Java 5! • Muitos destes recursos estavam a muito tempo sendo pedidos pela comunidade. • Temos que agradecer um pouco a MS • Recursos como generics e annotations mostram a maturidade de linguagem e dos desenvolvedores!

40. Exercícios • Implemente a classe GenericStack usando uma lista ligada e generics contendo os métodos • push(element) • pop() • peek() • size() • Implemente uma classe (ou metodo main) que teste sua GenericStack

41. Exercícios • Implemente a classe GenericPriorityList • Ordena a lista a cada inserção de um element • Metodos • add() • getFrist() • removeFrist() • Use Bounded Wildcards para que a lista aceite qualquer tipo de Comparable<T> class GenericPriorityList<T extends Comparable<T>> • Use LinkedList e ListIterator

42. Exercícios • Implemente um enum Mes, com métodos para indicar a quantidade de dias do mês( getTotalDays()) • Implemente um método que recebe um múltiplos objetos do Tipo Mes e retorna o total de dias da soma dos meses.

43. Exercícios • Adicione suporte a “for each” para suas listas • GenericStack e GenericPriorityList • Experimente os exemplos de annotations mostrados na aula

44. Referências • JDK 5 Documentation • Generics Tutorial, http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf • Joshua Bloch, Effetive Java: Programming Language Guide, 2001

45. Java 5 – Novos recursos Jobson Ronan {jrjs@cin.ufpe.br}