Paquetes

Ordenando nuestro proyecto Java. Uso de los paquetes en Java (packages)

 Los paquetes en Java (packages) son la forma en la que Java nos permite agrupar de alguna manera lógica los componentes de nuestra aplicación que estén relacionados entre sí.

 Los paquetes permiten poner en su interior casi cualquier cosa como: clases, interfaces, archivos de texto, entre otros. De este modo, los paquetes en Java ayudan a darle una buena organización a la aplicación ya que permiten modularizar o categorizar las diferentes estructuras que componen nuestro software.

Los paquetes en Java, adicionalmente al orden que nos permite darle a la aplicación, también nos brindan un nivel adicional de seguridad para nuestras clases, métodos o interfaces, pues como veremos más adelante podremos especificar si una clase o interfaz en particular es accesible por todos los componentes del software (sin importar el paquete) o si en realidad es solo accesible por las clases que estén en el mismo paquete que ésta. Veremos con más detalle este tema del acceso más adelante.
Ahora veamos cómo crear paquetes en Java

¿Cómo crear paquetes en Java?

 

Ya sabemos para qué sirven los paquetes en Java y sus características principales. Vamos ahora a aprender cómo usarlos y qué cambios generan estos en la estructura de nuestro proyecto.


Para declarar un paquete en Java se hace uso de la palabra reservada "package" seguido de la "ruta" del paquete, como se muestra a continuación.

package ruta.del.paquete;

 Hay varias cosas
 que clarificar aquí. Como verás, la sintaxis es bastante simple y 
comprensible pero hay algunos detalles a tener en cuenta, veamos.

 

Tips para crear paquetes en Java

 
El paquete en Java se declara antes que cualquier otra cosa:
La declaración del paquete debe estar al principio del archivo 
Java, es decir, es la primera línea que se debe ver en nuestro código o 
archivo .java. Primero se declara el paquete, y luego podremos poner los
 imports y luego las clases, interfaces, métodos, etc.




Cada punto en la ruta del paquete es una nueva carpeta:
Cuando se escribe la ruta del paquete en Java, se pueden 
especificar una ruta compleja usando el punto ".", por ejemplo en el 
código anterior, nuestra clase, interfaz o archivo estará ubicado en una
 carpeta llamada "paquete" la cual a su vez está en la carpeta "del" y 
esta también se encuentra dentro de una carpeta llamada "ruta". De este 
modo si queremos por ejemplo que una clase quede al interior de una 
carpeta llamada "mi_paquete" y ésta al interior de una carpeta llamada 
"otro_paquete" pondríamos:

 
package otro_paquete.mi_paquete;
/*Se usa el punto para separar cada carpeta
  equivale a la ruta otro_paquete/mi_paquete dentro del proyecto*/
public class mi_clase
{

Si no se declara un paquete (paquete por defecto):
Si decidimos no declarar un paquete para nuestra clase, ésta 
quedará en un paquete que se conoce como paquete por defecto (default 
package), en este paquete estarán todas las clases que no tengan un 
paquete declarado. Aunque esto no genera errores de compilación ni nada 
parecido, siempre es recomendable declarar un paquete a cada componente 
de nuestro programa Java para poder darle diferentes niveles de 
seguridad o acceso a dichos componentes y mantener todo ordenado.






Al momento de declarar el paquete en Java:
Es común usar la primera letra en mayúscula cuando se declara una 
clase, pues bien, cuando se declaran paquetes es común que todas la 
letras estén en minúscula y en caso de ser varias palabras separarlas 
por un guion bajo "_" por ejemplo "mi_paquete" es adecuado mientras que 
"MiPaquete" aunque no es incorrecto, no es una buena práctica.

  
En estos 
momentos ya  tenemos claro qué es y para qué sirve un paquete en Java, 
también sabemos cómo se declaran los paquetes en Java y probablemente 
tendremos una noción de los cambios que estos generan al interior de la 
estructura de nuestro proyecto. 
 


 
 
 

Variables

Variables y Tipos

Una variable en Java es un identificador que representa una palabra de memoria que contiene información. El tipo de información almacenado en una variable sólo puede ser del tipo con que se declaró esa variable.
Una variable se declara usando la misma sintaxis de C. Por ejemplo la siguiente tabla indica una declaración, el nombre de la variable introducida y el tipo de información que almacena la variable

 Java posee dos grandes categorías de tipos para las variables:

 int almacena un valor entero como 1, 2, 0, -1, etc.
Las variables de tipos primitivos almacenan directamente un valor que siempre pertenece al rango de ese tipo. Por ejemplo una variable
Esto significa que al asignar una variable entera a otra variable entera, se copia el valor de la primera en el espacio que ocupa la segunda variable.
Las variables de tipo referencia a objetos en cambio almacenan direcciones y no valores directamente. Una referencia a un objeto es la dirección de un área en memoria destinada a representar ese objeto. El área de memoria se solicita con el operador new.
Al asignar una variable de tipo referencia a objeto a otra variable se asigna la dirección y no el objeto referenciado por esa dirección. Esto significa que ambas variables quedan refenciando el mismo objeto.
La diferencia entre ambas asignaciones se observa en la siguiente figura:

Esto tiene implicancias mayores ya que si se modifica el objeto referenciado por r, entonces también se modifica el objeto referenciado por s, puesto que son el mismo objeto.
En Java una variable no puede almacenar directamente un objeto, como ocurre en C y C++.
Por lo tanto cuando se dice en Java que una variable es un string, lo que se quiere decir en realidad es que la variable es una referencia a un string.

 
Se dice que un tipo A es de mayor rango que un tipo B si A es un superconjunto de B. Esto quiere decir que las variales de tipo B siempre se pueden asignar a variables de tipo A (eventualmente con pérdida de significancia).
Por ejemplo int es de mayor rango que short, que a su vez es de mayor rango que byte. Float y double son de mayor rango que int. Double es de mayor rango que float.
Esto se puede resumir en:
double > float > long > int > short > byte  

 Expresiones En Java cada expresión tiene un tipo que se determina durante la compilación, es decir es independiente del valor durante la ejecución. Una expresión puede ser:

• Una constante: 1, 1.0, true, etc.
  El tipo de esta expresión es el tipo de la constante. En el ejemplo los tipos son int, double y boolean respectivamente.
• Una variable: i, s, a
  El tipo de esta expresión es el tipo con que se declaró aquella variable. En el ejemplo los tipos son entero, referencia a string y referencia a arreglo.
• El resultado de una operación: i+1, a[1], etc.
  El tipo se determina en función de los tipos de las expresiones que se indican como argumentos de la operación.

Java tiene prácticamente los mismos operadores de C y C++. Cada operador acepta una, dos o tres expresiones de diversos tipos. A veces un operador no está definido para argumentos de ciertos tipos. Por ejemplo la resta entre strings no esta definida. Pero la suma de strings esta definida como la concatenación.

• Al operar con byte y short, estos se convierten implícitamente a int.
• Cuando los tipos de los operandos no coinciden, el operando de menor rango se convierte implícitamente al tipo de mayor rango. El resultado de la operación es del tipo de mayor rango.

Ejemplos:

El resultado de estas operaciones es siempre del mismo tipo del operando.
Si el operando es byte o short entonces se convierte a int, se realiza la operación y el resultado es un int.
El resultado de estas operaciones es siempre del mismo tipo del operando.

  Ejemplos:

  int a=1, b=2;
 int c= +a;
 int d= -(c+1);
 b= a++; // b= 1, a=2
 a= --b; // a=b= 0
 (a+1)++; // error a+1 no es una variable
 float f= a; f++; // error f no es entero



Los operandos y el resultado de estos operadores son siempre booleanos.
Los operadores && y || evalúan la expresión del lado derecho sólo si es necesario.
Ejemplos:

 int a=1, b=2;
 boolean v= ! a<=b && a==5 || b!=4;
 boolean w= ((! a<=b) && a==5) || b!=4;
 boolean w2= a<=b && a; // error a no es boolean


  Conversiones: cast

• Java realiza conversiones implícitas de menor a mayor rango.
• Eventualmente hay pérdida de significacia al convertir enteros a punto flotante.
• Todas las conversiones de mayor a menor rango deben ser explícitas por medio del operador de cast:

  (tipo)expresión

Ejemplos: 

  int i= 1;
 short s= 2;
 int j= i+s;
 s= a; // error short < int
 s= (short)a; // Ok
 i= 1.0; // error int < double
 i= (int)1.0; // Ok
 f= 1.0; // error float < double
 f= (float)1.0; // Ok
 f= 1.0f; // Ok boolean v=(boolean)a; // error no existe conversión

Librerias y Comandos

Uso de librerías en Java. Importar librerías estándar de Java y librerías propias. Importar paquetes

 En Java y en varios lenguajes de programación más, existe el concepto de librerías. Una librería en Java se puede entender como un conjunto de clases, que poseen una serie de métodos y atributos. Lo realmente interesante de estas librerías para Java es que facilitan muchas operaciones. De una forma más completa, las librerías en Java nos permiten reutilizar código, es decir que podemos hacer uso de los métodos, clases y atributos que componen la librería evitando así tener que implementar nosotros mismos esas funcionalidades.

 Imaginemos cómo hacer un código para conseguir que nuestra aplicación imprima algo por pantalla o conseguir que nuestra aplicación pueda hacer uso de arreglos dinámicos con cualquier tipo de dato. Por medio de librerías, para imprimir texto en pantalla en Java basta con usar System.out.print() y se puede hacer uso de ArrayList, para tener arreglos dinámicos y demás, en Java, esto es así de fácil y todo es gracias a las librerías, la clase System que pertenece a la librería java.lang (ésta es la librería estándar de Java y no es necesario importarla). Ocurre de la misma forma con el ArralyList, no podríamos hacer uso de éste si no existiera la librería java.util. Cabe mencionar que estas librerías no solo poseen estas clases sino que poseen una gran cantidad de clases Java adicionales que nos permiten llevar a cabo operaciones muy complejas con gran facilidad.
Lo más interesante de las librerías en Java, es que nosotros también podemos crearlas y hacer uso de ellas al interior de nuestros proyectos. Básicamente un paquete en Java puede ser una librería, sin embargo una librería Java completa puede estar conformada por muchos paquetes más. Al importar un paquete podemos hacer uso de las clases, métodos y atributos que lo conforman, así que eso de las librerías no es solo trabajo de otros sino que podemos crear nuestras propias librerías y usarlas, incluso podemos hacer uso de un proyecto completo nuestro al interior de otro (así de genial es esto).
Pues bien, hasta ahora todo suena muy impresionante y se entiende que es bastante útil y que nos facilita enormemente la vida, pero ¿cómo importar una librería en Java? ¿cómo se usa una librería de Java? ¿qué es importar una librería? o mejor aún ¿qué es import en Java? pues bien, vamos a resolver todas estas dudas a continuación.

Import en Java (importar librerías en Java)

Hacer uso de librerías tanto propias como externas, o librerías propias de Java, es bastante fácil. Básicamente lo único que debemos saber es que para importar librerías en Java se usa la palabra clave import seguido de la "ruta" del paquete o clase que deseamos agregar al proyecto. Cabe resaltar que el import permite agregar a nuestro proyecto una o varias clases (paquete) según lo necesitemos. Para comprender y usar correctamente el import de Java, retomaremos los ejemplos dados en la sección de paquetes.

Ejemplo de import en Java

Vamos a suponer que al interior de nuestro proyecto hemos creado cuatro clases diferentes en paquetes diferentes, cada clase se llamará "Clase_1", "Clase_2", "Clase_3" y "Clase_4" respectivamente.
En la imagen de abajo se puede apreciar la estructura de los paquetes de cada una de las cuatro clases de Java. Veamos con detalle esto para quedar claros.

La clase número uno fue declarada en un el paquete "mis_clases.clases_publicas.clase_1" por lo tanto quedará al interior de una carpeta llamada "clase_1" la cual estará al interior de otra carpeta llamada "clases_publicas" y esta a su vez estará dentro de la carpeta llamada "mis_clases". La clase número dos se le declaró el paquete "mis_clases.clase_2" por lo tanto ha quedado al interior de una carpeta llamada "clase_2" la cual a su vez está al interior de la carpeta "mis_clases". A la clase número tres se le impuso el paquete "mis_clases", esto indica que esta estará al interior de la carpeta "mis_clases". Por último, la clase número cuatro no tiene declarado ningún paquete por lo tanto el paquete asignado será el paquete por defecto, en otras palabras, esta clase se mantendrá siempre en la carpeta raíz del proyecto (en netbeans y eclipse la carpeta raíz se llama src).
Muy bien, ya sabemos la estructura de nuestros paquetes y necesitamos importarlos al interior de alguna otra clase para hacer uso de ellas, para esto, Java nos proporciona el comando import (tal como mencioné anteriormente). Antes de comenzar a mostrar como importar las clases de estos paquetes, voy a dar algunas normas y definiciones útiles al momento de importar librerías, clases o paquetes en Java.

Antes de importar en Java...

Al igual que sucede con la declaración de los paquetes, realizar el import en Java también tiene una localización especifica al interior del archivo java. La importación de librerías y demás siempre debe ir después de la declaración del paquete, si la clase no posee alguna declaración de paquete (pertenece al paquete por defecto), entonces los import deberán estar en las primeras líneas del archivo.

Ejemplo 1: Sintaxis para import en Java

 

package paquete.mipaquete;

import paquete2.otropaquete.*;

class Ejemplo1{}
 En el código anterior básicamente estamos diciendo que la clase contenida en el 
archivo Java, estará en el paquete "paquete/mipaquete", es decir, esa 
será la ruta de acceso a esa clase en el proyecto. En la siguiente línea
 hemos realizado el import de un paquete. Por medio del "*" hemos 
indicado a Java que queremos importar todas las clases pertenecientes a 
dicho paquete, puede ser una o más.




Ejemplo 2: Sintaxis para import en Java

 

package paquete.mipaquete; import paquete3.otropaquete2.MiClase; class Ejemplo2{}

 En el código anterior hemos usado el mismo paquete para la clase pero hay una pequeña diferencia al momento del import, en esta ocasión hemos importado una clase directamente (MiClase), es decir, como no usamos el "*" no hemos importado todas las clases pertenecientes al paquete "paquete3.otropaquete2" sino que solo hemos importado a "MiClase" 

Ejemplo 3: Sintaxis para import en Java

mport paquete.mipaquete.*;

class Ejemplo3{}

En esta ocasión se puede apreciar que no hemos declarado paquete alguno para nuestra clase y que únicamente hemos realizado el import, sin embargo este import como tal es algo particular para nosotros, pues hemos importado TODAS las clases pertenecientes al paquete "paquete.mipaquete" que es el paquete al cual pertenecen las clases del ejemplo 1 y 2, esto quiere decir que al interior de la clase Ejemplo3, podemos usar las clases Ejemplo1 y Ejemplo2.
 Muy bien!! Hasta el momento ya sabemos muchas cosas acerca del import en Java, sabemos cómo importar todas las clases pertenecientes a un paquete, también como importar una única clase de un paquete cualquiera y vimos también que los paquetes que nosotros mismos creamos al interior del proyecto, pueden ser usados en otras clases de manera instantánea. Pero aún hay algo que no hemos visto y lo cual es de gran importancia, ¿cómo importar las clases y librerías propias de Java?, pues bien vamos a verlo.

Importando clases de Java

Importar clases propias de Java es prácticamente igual que importar clases de nuestros propios paquetes, sin embargo, ¿cuáles son esas clases?, ¿cómo conocerlas?, ¿cuál es el paquete al que pertenecen?, pues bien, de una vez te comento que Java está conformado por una enorme cantidad de clases y paquetes y desde mi punto de vista creo que es bastante complejo conocerlas todas, aunque si es importante conocer las más comunes y útiles, básicamente lo que debes hacer es ingresar a la API de Java y allí encontrarás todas las clases que componen el lenguaje, el paquete al que pertenecen, los métodos que poseen, los atributos y una breve explicación de cada uno de estos. Si ingresas a la documentación de Java verás que por ejemplo existe una clase llamada ArrayList, ésta pertenece al paquete java.util, esto quiere decir que para importarla debemos usar esa dirección, veamos:

Ejemplo 4: Importando clases de Java

 

mport java.util.ArrayList;

class Ejemplo4{}

 Aquí hemos 
importado la clase ArrayList y podremos hacer uso de sus componentes, 
siempre y cuando sean públicos (más adelante hablaremos de esto). Hay 
otra forma de hacerlo, pero posee ciertos inconvenientes:

 

Ejemplo 5: Importando clases de Java

 
import java.util.*;

class Ejemplo5{}

  Aqui hemos 
importado TODAS las clases pertenecientes al paquete "java.util" lo cual
 incluye la clase ArrayList y por lo tanto es funcional y válido, sin 
embargo esto es bastante ineficiente, pues estamos importando todas las 
clases que son aproximadamente 50 y que seguramente no usaremos. Veamos 
entonces cómo importar algunas clases propias de Java.

 

Ejemplo 6: Importando clases de Java

 
import java.util.ArrayList;
import java.io.* //importando clases para entrada y salida (IN OUT)
import java.math.* //clases utiles para operaciones y valores matematicos

class Ejemplo6{}
 
 

Como podrás ver, existen muchas librerías muy útiles y es bastante sencillo hacer uso de ellas cuando sea necesario y así ahorrarnos mucho tiempo, trabajo y esfuerzo.
Muy bien, hasta ahora hemos aprendido todo lo necesario acerca del import en Java, sabemos cómo importar nuestra propias clases, importar todas las clases de un paquete, también vimos que Java posee una API y que está conformada por una enorme cantidad de Clases, interfaces, excepciones, etc. y que en cualquier momento podemos hacer uso de cualquiera de estas.
Hemos llegado al final de este contenido, espero que hayas comprendido a la perfección cada uno de los detalles aquí explicados y que ahora domines correctamente el concepto de librerías en Java y del import en Java. Recuerda que si tienes algún problema, duda o comentario, puedes dejarlo sin ningún temor en la sección de comentarios.Puedes continuar con la sección de sistema de tipos en Java.

Entorno Grafico de NetBeans

Entorno Grafico de NetBeans

Entorno de desarrollo NetBeans

Existen varios entornos que han encontrado aceptación por profesionales y aficionados. Los más conocidos son probablemente Eclipse, NetBeans y IntelliJ IDEA. Los dos primeros resultan más interesantes por ser de código abierto, y para este artículo se ha escogido NetBeans por presentar una ventaja adicional: al ser desarrollado por la compañía Sun, la misma que creó Java, puede descargarse e instalarse en un mismo paquete con el kit de desarrollo JDK, lo cuál simplificará su instalación a los alumnos.

1. Puesta a punto

Al igual que con los otros entornos estudiados, la instalación de NetBeans no presenta ninguna complicación, incluso si se escoge descargarlo por separado desde la web del programa. Sin embargo, al abrir NetBeans nos encontramos una pantalla algo más confusa que en los anteriores entornos:

 Al igual que en BlueJ, para empezar debemos crear un nuevo proyecto mediante el menú File > New project, indicando en este caso de qué tipo va a ser. Ya desde el principio, advertirás muchas opciones y posibilidades en el entorno, seguramente más de las que en muchos casos nos interesaría:

 En una ventana posterior daremos nombre al proyecto y escogeremos una ubicación en el disco para almacenarlo. También nos dará la opción para crear automáticamente una clase principal, la que hasta ahora hemos llamado Test, y que aquí por defecto se llamará Main. Una vez hecho esto, la ventana de trabajo nos resultará sin duda compleja, pero también familiar:

 NetBeans nos ofrece un esqueleto de clase Main, que podemos utilizar para hacer nuestra primera prueba. Por defecto, NetBeans compila automáticamente los archivos en el momento en que los grabas (icono del diskette), de forma que únicamente necesitamos utilizar el botón que representa una flecha verde, como el play de un mando a distancia. Verás el resultado de la ejecución en la ventana inferior:

 Como ves, no ha sido nada difícil empezar a trabajar con NetBeans; en la siguiente sección esbozaremos las capacidades de esta potente aplicación.

2. Sacándole partido

Examinemos en detalle la carpeta de proyecto. Verás que se han creado múltiples subcarpetas en tu directorio de trabajo:

 De ellas sólo nos van a interesar dos: en src se encuentran los archivos fuente de nuestro programa, mientras que en build es donde guarda NetBeans los archivos compilados (.class). Para añadir una nueva clase al proyecto sólo tienes que utilizar el botón New Class; si lo que quieres es agregar al proyecto clases ya existentes, la forma más rápida consiste en copiarlas directamente a la carpeta src.

Si examinamos en detalle la ventana de trabajo, apreciaremos lo siguiente:

• A diferencia de los entornos anteriormente estudiados, en NetBeans puedes ver las clases en la parte izquierda agrupadas por el paquete al que pertenecen
• La clase que contiene el método principal main está destacada con una flecha verde en su icono
• La parte inferior izquierda es como un diagrama de clase: incluye toda la información sobre atributos y métodos de la clase que estemos editando
• NetBeans también puede mostrar números de línea, mediante el menú View > Show line numbers.

Como se ha dicho antes, en NetBeans no existe la necesidad explícita de compilar, puesto que cuenta con una función de autocompilado. Piensa en un editor de textos avanzado: según vas escribiendo, el programa comprueba tu ortografía y, si has cometido una falta, la destaca en rojo sobre la marcha. NetBeans funciona exactamente igual; es más, la forma en que resalta los errores sigue la misma estética que los correctores ortográficos. Si queremos saber el motivo del problema, bastará con situar el cursor sobre una de las marcas de error:

En jGrasp o BlueJ, el primer error de compilación provocará la detención del proceso: aquí puedes seguir trabajando aunque se acumulen varios errores, corrigiéndolos después en el orden que quieras. Fíjate en la parte izquierda de la ventana: NetBeans distinguirá con iconos aquellas clases que presentan errores de compilación. Y puesto que la clase pertenece al paquete figuras, también marca el paquete completo como erróneo. De igual forma, el proyecto trigonometría queda marcado en rojo por la existencia de al menos un error en sus archivos.

Sin duda, y pese a la complejidad, resulta muy cómodo programar en NetBeans. Se trata de un completo entorno que nos permitirá realizar no sólo programas sencillos sino auténticos proyectos profesionales de programación. Como todos los IDEs dirigidos a programadores profesionales, ofrece herramientas avanzadas que nosotros, en un curso de iniciación a Java, raramente vamos a utilizar. Pero para que te hagas una idea de lo que estamos hablando, repasaremos algunas de sus posibilidades:

• Permite la integración de la herramienta Ant de Apache, que permite automatizar mediante guiones o scripts la compilación de proyectos complejos y realizarla después dándole a un solo botón. Las posibilidades de Ant son enormes, permitiendo especificar, por ejemplo, que los archivos fuente se almacenan en unas determinadas carpetas mientras los compilados se deben copiar a otras. También se pueden programar scripts de limpieza que eliminen todos los archivos compilados o no utilizados.

• Soporta control de versiones con la herramienta gratuita CVS. Esta funcionalidad es extremadamente útil al programar en equipo, y básicamente consiste en tener un único almacén de archivos compartido por todos los colaboradores de un proyecto de programación. El sistema registra todos los cambios realizados de forma que cada programador puede ver resaltado en colores qué cambios ha hecho su compañero en cada archivo. Cuando el equipo se da cuenta de que ha cometido un error, puede dar marcha atrás y recuperar rápidamente una versión anterior, deshaciendo los cambios realizados. Más aún: dos programadores pueden modificar un mismo archivo a la vez. Cuando el segundo intente devolver el archivo modificado al almacén, el programa le facilitará la revisión para mezclar sus cambios con los de su compañero, siempre que no resulten incompatibles.

• Ofrece la posibilidad de refactorizar código. Utilizamos esta palabra para designar cambios menores en el código que, sin modificar la funcionalidad de nuestro programa, lo simplifican o facilitan su legibilidad. El ejemplo más básico de refactorización es cambiar el nombre de una variable: el entorno se ocupará de realizar el cambio en todos los puntos del programa en que aparezca, incluso en otros archivos del proyecto. NetBeans también permite ordenar automáticamente el código, introduciendo tabulaciones y espaciados para que el programa se lea con facilidad.

• Incorpora el autocompletado de código. Imagina que estás escribiendo el nombre de una variable o de un objeto, pero no recuerdas qué nombre le diste exactamente: pues bien, simplemente escribe las primeras letras, pulsa la tecla Control y la barra espaciadora, y el programa te indicará cuáles son los nombres disponibles. Algo parecido sucede con los atributos y métodos de una clase. Si escribimos el nombre de un objeto seguido de un punto, sabemos que a continuación debe ir o bien un atributo o bien un método de los que ofrezca la clase a la que pertenece el objeto en cuestión. Si no recordamos su nombre repetiremos la combinación de teclado y el entorno nos ofrecerá las distintas posibilidades:

Las dos primeras funcionalidades están muy orientadas al uso profesional y tendría poco sentido utilizarlas en un curso de iniciación, pero es posible que algún profesor quiera ilustrar las posibilidades de trabajo en equipo incorporando un servidor de control de versiones. El autocompletado, sin embargo, puede ser utilizado en clase con frecuencia; otra cuestión sería el considerarlo o no adecuado para la labor docente. La función de NetBeans es permitir programar deprisa, y funciones como el formateado automático del texto y el autocompletado de código ahorran al programador tiempo y errores. Algunos profesores considerarán que, cuando empezamos, no deberíamos recibir tantas ayudas y sino enfrentarnos precisamente a esos errores. Otros valorarán estas herramientas para que los alumnos se sientan más guiados en su tarea de programar.

NetBeans no permite la creación interactiva de objetos (una iniciativa interesante a nivel didáctico, pero no tanto en un IDE profesional). Pero podemos completar nuestro paseo por el entorno comprobando cómo funciona la depuración. La forma de realizarla es igual que en los otros entornos, aunque NetBeans proporciona posibilidades de inspección y monitorización mucho más avanzadas. Lo que a nosotros nos interesa, sin embargo, se realiza de forma similar: haz click en la columna gris a la izquierda de las líneas donde quieras añadir puntos de ruptura, y pulsa el icono de depurar programa:

En verde se destaca el punto de ruptura en el que estamos detenidos, y en rojo otros puntos de ruptura que hayamos marcado. En la ventana inferior podremos examinar los valores de todos los objetos en este punto, y a través del menú Debug encontraremos las opciones ya conocidas para controlar la ejecución (step, step into...) aparte de otras posibilidades que sobrepasan nuestros intereses.

Los menús y mensajes de NetBeans están escritos, al igual que su documentación, en inglés. Sin embargo, existe un grupo de trabajo dedicado a traducir el IDE al español, de forma que algunas versiones se encuentran traducidas a nuestro idioma. En cuanto a la documentación, iniciativas personales o universitarias de España o Iberoamérica permiten encontrar en la red ciertos recursos para comprender mejor esta popular y potente plataforma.

3. Valoración

Al igual que con el resto de entornos, terminemos con una breve exposición de sus aspectos más destacados:

Puntos fuertes de NetBeans

• Sin duda, el más completo, estable y fiable de los tres
• Si un alumno necesita programar en su vida profesional y ha aprendido con NetBeans, podrá enfrentarse con confianza a cualquier entorno presente en la empresa, ya que todos son muy parecidos entre sí
• La gestión de paquetes y sus avanzadas detecciones de errores (incluso antes de compilar) resultan más cómodas e intuitivas que en los otros entornos

Puntos débiles de NetBeans

• Su consumo de recursos es significativamente mayor que el de las otras alternativas
• Enfrentarse a un entorno algo complejo como NetBeans puede desanimar o confundir al alumno, especialmente si no tiene nociones de programación
• Sus múltiples ayudas al programador pueden no ser adecuadas para iniciarse en el lenguaje Java