Lo que se viene con JDK 7 & NetBeans 7

Se dice que el número 7 es el número de la perfección, y para el mundo Java este número no está lejos de serlo.
Está cerca el JDK 7, con muchas mejoras en la sintaxis, y casi a la par también sale el NetBeans 7 con su respectiva compatibilidad.

En este post mostraré algunas características de estos software.

(Mientras termino la continuación del RESTful para objetos, voy mostrando esto)

Descargando e instalando JDK 7

Primero, debemos descargar el JDK, y este lo podemos obtener de aquí

http://dlc.sun.com.edgesuite.net/jdk7/binaries/

... bajo el título Windows Offline Installation, Multi-language JDK file
jdk-7-ea-bin-b118-windows-i586-11_nov_2010.exe

Nota: Esta es la versión disponible a la fecha de este post. Si no existe, buscar dentro de http://download.java.net/jdk7/.

La instalación del JDK no es cosa del otro mundo, ya que el instalador siempre nos dice qué opción debemos elegir... y hasta creo que es mucho más rápida.

Luego comprobamos que la instalación fue correcta, escribiendo en la línea de comandos java -version

Ojo, yo aún tengo instalado el JDK 6, y si deseo utilizarlo, cambio la ruta de la variable JAVA_HOME.

Aquí quiero hacer una notación importante. La variable de entorno JAVA_HOME debe apuntar a la carpeta o directorio que tiene el subdirectorio "bin" del Java. Por ejemplo, en este momento tengo mi variable establecida así:

a pesar que ya tengo instalado la versión JDK 7.. incluso el compilador puedo utilizar la versión 6,

para utilizar la nueva versión, debo cambiar la variable de entorno al directorio de la versión 7.

Para cambiar el valor de la variable de entorno en Windows, entrar a las propiedades de la PC (una manera más rápida es presionando las teclas Win+Pausa) y buscando la opción "Variables de Entorno". Para XP, Vista, 7 cada ventana son diferentes, así que no diré cómo son las ventanas.

Descargando e instalando NetBeans 7.0

A la fecha de este post, el NetBeans 7.0 está en la etapa M2, así que descargaremos esta versión desde aquí:

http://bits.netbeans.org/netbeans/7.0/m2/

Personalmente, cada vez que quiero probar una versión del NetBeans, elijo la opción ".zip", ya que solo descargado y descomprimo el contenido y listo! ya tengo el NetBeans instalado (Eclipse, no te creas en ser el único)

Pero para asegurarnos de que el NetBeans utilizará el JDK7, debemos modificar el archivo de configuración del IDE. Este se encuentro en el subdirectior "etc" de NetBeans. El nombre del archivo es "netbeans.conf", y agregamos esta línea

netbeans_jdkhome="C:\Archivos de programa\Java\jdk1.7.0"

.. y luego le damos doble clic al netbeans.exe para ejecutar el IDE.

Luego de leer la licencia, memorizarla y aceptarla, ya podemos disfrutar del IDE NetBeans 7 + JDK 7

Ahora, crearemos un nuevo proyecto de Aplicación Java, y veremos que por omisión la clase prinicipal que contiene el método public static void main() ya no es Main ya que ocasionaba muchas confusiones para los principiantes, sino es el mismo nombre del proyecto. Ojo, puede ser cualquier nombre, pero aquí el NetBeans sugiere ese nombre.

Luego, entramos a las propiedades del proyecto, y cambiamos la versión del código fuente a utilizar en nuestro proyecto.

Características nuevas de JDK 7 en NetBeans 7.0

Aquí vienen las características más esperadas que todo el mundo se quejaba de que Java no tena y que vienen a nuestra salvación.

switch con cadenas

Esta es - creo yo - la que muchos esperábamos: usar cadenas en switch. Por definición, los switch solo permiten una variable de tipo escalar (nativo), como el char, int, byte, etc... es decir, los String no "juegan". Entonces, solo con los Strings usábamos "if" encadenados, como aquí:

Pero aquí NetBeans nos muestra una sugerencia: cuando pasamos el ratón por el foquito del margen izquierdo nos dice

.. y al seleccionar la opción.. adivinen qué sucede...

Operador "diamante": anulando Genericos redundantes

En la versión Java 1.5 aparecieron los Genéricos, una notación importante para asegurar los tipos de las colecciones. Es decir, antes en un List podía tener String, objetos persona, Integer, arreglos.. etc... y para obtener un elemento debía hacerse "casting". Pero en la versión 5, con los genéricos, se podía declarar un tipo para una colección y asegurar que el objeto devuelto siempre era del mismo tipo declarado y evitaba hacer "cast".

List<Persona> personas=new ArrayList<Persona>();

Pero había un problema: el tipo de la colección que se estaba instanciando debería ser del mismo tipo de la declaración. Es decir, no se podía hacer esto:

List<Persona> personas=new ArrayList<Empleado>();

por más que Empleado sea subclase de Persona. Se puede utilizar caracteres comodines, pero eso es otra historia. El asunto es que para una declaración simple como la mencionada antes, debería usarse siempre el mismo tipo en la instanciación. Entonces, si ya fue declarado con un tipo, ¿Ya no debería mencionarlo en la instanciación? Pues, aquí NetBeans nos sale a la ayuda.

Antes:

Después:

Multicatch

¿Tienes una código que contiene muchos catch, y según la recomendación de Jav se debería usar un catch específico por cada excepción para manejarla de manera específica.... y en tu código en todos los catch se hace lo mismo.. y quieres evitar de usar la clase Exception? No te preocupes. Aquí aparecen los multicatch. Supongamos este código:

        File f=new File("d://temp.xml");
        try {
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document d = builder.parse(f);
        } catch (SAXException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        } catch (ParserConfigurationException ex) {
            ex.printStackTrace();
        }

El IDE nos sugerirá algo en el primer "catch".

Antes:

Después:

Estos fueron algunos.. más información de NB 7.0 lo podeís ver aquí:

http://wiki.netbeans.org/NewAndNoteworthyNB70

Hasta el siguiente apunte!!