Este documento presenta las características avanzadas de Java como colecciones genéricas, autoboxing, anotaciones, Reflection API, Java Compiler API y Scripting API. Explica cómo estas características permiten escribir código más seguro, legible y dinámico en Java. También incluye ejemplos de código para ilustrar el uso de estas características.

1. El lado cool de
Java
Leo Soto M.
@leosoto
Java Day INACAP Osorno, Junio 2010

2. ¡Vamos a ir rápido!
1. Collections
2. Generics
3. Misceláneos: autoboxing, varargs
4. Reflection API
5. Annotations
6. Java Compiler API
7. Scripting API

3. 1. Collections

4. Array? Vector? Hashtable?

5. Nope.

7. Implementaciones
List visitas = new ArrayList();
Set alumnos = new HashSet();
Map notasPorAlumno = new HashMap();
Queue pendientes = new LinkedList();

8. Algoritmos
Collections.sort(visitas);
Collections.binarySearch(visitas, v);
Collections.shuffle(alumnos);
Collections.max(notasPorAlumno.get(a));
Collections.reverse(pendientes);

9. 2. Generics

10. ¿Recuerdan?
List visitas = new ArrayList();
Set alumnos = new HashSet();
Map notasPorAlumno = new HashMap();
Queue pendientes = new LinkedList();

11. ¡Con Generics!
List<Visita> visitas =
new ArrayList<Visita>();
Set<Alumno> alumnos =
new HashSet<Alumno>();
Map<Alumno, List<Integer>> notas =
new HashMap<Alumno, List<Integer>();
Queue<Runnable> pendientes =
new LinkedList<Runnable>();

12. ¿Y qué diablos ganamos?

13. Type Safety
alumnos.add(“esto arroja error”);
String foo = alumnos.get(0); // Esto tb

14. Legibilidad
Alumno primero = (Alumno)alumnos.get(0);

15. Legibilidad
Alumno primero = alumnos.get(0);

16. 3. Misceláneos: autoboxing, varargs

17. Autoboxing
Integer boxed = new Integer(1);
int unboxed = boxed.intValue();

18. Autoboxing
Integer boxed = 1;
int unboxed = boxed;

19. Autoboxing
Integer boxed = null;
int unboxed = boxed; // Oops

20. Autoboxing
List<Integer> notas;
notas.add(4);
notas.add(7);
int suma = notas.get(0) + notas.get(1);

21. Varargs
public void saludar(String[] nombres) {
for(String nombre: nombres) {
System.out.printf(“Hola %s”, nombre)
}
}

22. Varargs
saludar(new String[] {“Pedro”, “Juan”});

23. Varargs
saludar(“Pedro”, “Juan”);

24. Varargs
public void saludar(String[] nombres) {
for(String nombre: nombres) {
System.out.printf(“Hola %s”, nombre)
}
}

25. Varargs
public void saludar(String... nombres) {
for(String nombre: nombres) {
System.out.printf(“Hola %s”, nombre)
}
}

26. 4. Reflection API

27. ¿Metaprogramación?

28. Uhm, no exactamente

29. ¡Java dinámico!

30. Algo así

31. Demo
https://github.com/leosoto/demos_javaday/tree/master/reflection/

32. Sin reflection Java no sería lo que es

33. A veces para bien y otras veces para mal

34. Hint: Si usa XML, probablemente es para mal ;)

35. 5. Annotations

36. Metadatos para el código

37. Annotations
@Deprecated
public void metodoAntiguo() {
// blah blah
}

38. Pero también se pueden definir nuevas

39. Annotations
@Beta
public class UntestedPlugin {
}

40. Annotations
public @interface Beta {};

41. Annotations
Class pluginClass = loadPlugin();
if (pluginClass.isAnnotationPresent(
Beta.class
)) {
// Alertar al usuario que esta usando
// un plugin beta
}

42. Y las anotaciones también pueden tener atributos

43. Annotations
public @interface Plugin {
String author() default “unknown”;
boolean beta() default false;
};

44. Annotations
@Plugin(author=“Leo”, beta=true)
public class UntestedPlugin {
}

45. 6. Java Compiler API

46. Demo
https://github.com/leosoto/demos_javaday/tree/master/compiler/

47. Ugh

48. 7. Scripting API

49. Demo
https://github.com/leosoto/demos_javaday/tree/master/scripting/

50. ¿Con gusto a poco?
8. Ejercicio para el auditor: ClassLoaders

51. ¡Muchas gracias!
@leosoto
http://blog.leosoto.com

52. ¿Preguntas?
@leosoto
http://blog.leosoto.com