Java 5 – Novos recursos Jobson Ronan

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.

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

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]

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.

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

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 strings static 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 c static void expurgate(Collection c) { for (Iterator i = c.iterator(); i.hasNext(); ) if (i.next().length() == 4) i.remove(); }

Generics – Tipos Genéricos Quando se escreve, 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

Generics – Tipos Genéricos Partes de códigos existentes na definição de List e Iterator do pacote java.util public interface List { void add(E x); Iterator iterator(); } public interface Iterator { E next(); boolean hasNext(); }

Bounded Wilcards Considere as seguintes declarações Podemos definir o seguinte metodo public abstract class Shape { public abstract void draw(Canvas c); } public class Circle extends Shape { private int x, y, radius; public void draw(Canvas c) {... } } public class Rectangle extends Shape { private int x, y, width, height; public void draw(Canvas c) {... } } public void drawAll(List shapes) { for (Shape s: shapes) { s.draw(this); }

Bounded Wilcards Porém o método não poderia ser chamado sobre um List Porém queremos que o método aceite listas de qualquer tipo de Shape public void drawAll(List shapes) {... }

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 c) { for (Iterator i = c.iterator(); i.hasNext(); ) i.next().cancel(); }

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 c) { for (TimerTask t : c) t.cancel(); }

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

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

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 // Returns the sum of the elements of a int sum(int[] a) { int result = 0; for (int i : a) result += i; return result; }

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

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

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;

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 m = new TreeMap (); 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}

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.

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;... }

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

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 }

Typesafe Enums – Tipos enumerados Um exemplo maior public enum Planet { MERCURY (3.303e+23, e6), VENUS (4.869e+24, e6), EARTH (5.976e+24, e6),... 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 = E-11; double surfaceGravity() { return G * mass / (radius * radius); } double surfaceWeight(double otherMass) { return otherMass * surfaceGravity(); }

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.

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

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");

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

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

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 ”

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.*;

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

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.

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

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 Test { }

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

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

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!

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

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 class GenericPriorityList >  Use LinkedList e ListIterator

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.

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

Referências JDK 5 Documentation Generics Tutorial, Joshua Bloch, Effetive Java: Programming Language Guide, 2001

Java 5 – Novos recursos Jobson Ronan