NetBeans El Super IDE para los programadores Java

Los JIDE o entornos integrado de desarrollo para Java han evolucionado de forma sorprendente, desde un simple editor como el Block de notas, donde hay que ser muy cuidadosos de cada detalle, pasando por un IDE un poco más avanzado como GEL que colorea el código para resaltar o clasificar las palabras clases del lenguaje, hasta llegar a los súper Smart IDE, o Entornos integrados de desarrollo inteligentes, los cuales tienen capacidades de generar y auto-completado código fuente deforma automática y en algunos casos sugieren la corrección de errores con un toque de inteligencia, que los hace fascinantes, como ejemplo de estos Smart IDEs podemos encontrar:

En la familia del software Libres:

• Netbeans IDE 6.7.1
• Eclipce 3.6
  
• IntelliJ IDEA 9
• EasyEclipce

Los No Libres o Privativos:

• JDeveloper 11g
• JBuilder 2010
• VisualStudio 2008(J#)

Continuando con la saga de artículos sobre Recordando el pasado y gradeciendo el presente, aquí les traigo el primero de los artículos que dedicare al que considero el mejor IDE Libre para Java.

Breve introducción al IDE NeBeans 6.7.1

NetBeans es un proyecto que nació bajo el regazo de la empresa inventora de Java, Sun MicroSystem, hace una década aproximadamente en el año 1998, Sun decidió liberar parte del código fuente de uno de sus mas impórtatenos proyectos, llamado en aquel entonces Sun ONE, es un producto construido con el fin de proveer un buen IDE escrito 100% en Java para los nacientes programadores de este gran lenguaje, la estrategia de cerrar el código y ofrecerlo como un producto comercial no fue muy aceptada por creciente comunidad de desarrolladores del joven Lenguaje de programación, entonces, como segunda estrategia y en sus inicio de vinculación con el software libre, Sun entrego la gran mayoría del código fuente y otros recursos del proyecto Sun ONE a la comunidad de desarrolladores Java, estos habidos de tener su propio IDE, comenzaron la dura pero gratificante tarea de convertirlo en una de las herramientas mas avanzadas para desarrollar software utilizado el lenguaje de programación Java, como muestra de ellos, utilizaron este mismo lenguaje para construir en un 100% al hoy famoso IDE para Java NetBeans.

Programando con NetBeans

Al momento que decidi escribir este articulo el IDE se encontraba en su versión 6.7.1 estable, con una nueva versión 7.0 en fase de prueba o beta.

Para iniciar debemos descargar el IDE desde su sitio web http://www.netbeans.org/downloads/index.html, en la que se pueden seleccionar varios instaladores, desde instaladores simples que incluyen solo lo más básico del IDE, hasta instaladores que incluyen todos los elementos que ofrece el IDE, además, se pueden escoger instalaciones para diferentes plataformas (Sistemas Operativos) como GNU/Linux, Window, Unix, entre otras, por ultimo también se ofrecen descargas del IDE en muchos idiomas, incluyendo por supuesto el español, cosa que no ocurre con otros de los IDEs mas importantes como JDeveloter y Eclipce.

El proceso de instalación en Windows no es nada diferente a las instalaciones tradicionales guidadas por una asistente, donde solo hay que aceptar los términos de uso (leer por favor), pulsar uno o varios siguientes etc…

La instalación en GNU/Linux es igualmente simple, para ello pueden visitar este Articulo de instalación de NB en GNU/Linux Debian que ha escrito muy colaborativamente y amablemente mi compañera Maritza Galarza.

Netbeans en marcha

Inicio / programas / Netbeans 6.7

Ventana principal del IDE NetBeans

He numerado cada parte de la ventana principal del IDE, con el fin de explicar muy brevemente cual es su función básica.

La zona número 1 es la barra de herramientas del menú Archivo, esta barra muestra las en botones con iconos las funciones más usadas en este menú, en su orden se muestra el botón para crear un nuevo archivo, crear un nuevo proyecto, abrir un nuevo proyecto y guardar todo,

La zona número 2 es la barra de herramientas del menú Edición, esta barra muestra en su orden la operación de deshacer y la de rehacer los cambios que realizamos en el proyecto que estemos trabajando actualmente, estas dos seguro que son las tareas más usadas en este menús.

La zona número 3 es la barra de herramientas de los menús Depurar y Ejecutar, donde se encuentran todas las opciones para realizar operaciones de compilación, ejecución y empaquetado de los recursos (archivos) que conforman nuestro proyecto, esta barra de herramientas muestra en su orden los botones de construir el repositorio .jar del proyecto, borrar y reconstruir el repositorio, ejecutar el proyecto, compilar (depurar) y ejecutar el proyecto y el programador de compilaciones.

La zona número 4 es la barra de herramienta para buscar recursos o texto dentro de nuestro proyecto.

La zona número 5 se encuentran un conjunto de paneles laterales colapsables o retraible (se esconden y se muestran según nosotros lo deseemos), en su orden se pueden ver:

El panel de Prestaciones

Este panel contiene un árbol (Tree) con nodos para trabajar con diferentes servicios de red, entre los que se encuentran en su orden servidores SMDB (Sistema Manejadores de Bases de Datos) como MySQL y Derby, un conjunto de Servicio Web (WebServices), Servidores Web, Contenedores de JSP y Servlet, Servidores Aplicaciones como Apache Tomcat y GlassFish.

El panel de Archivos

Esta panel nos permite crear, ver, eliminar, copiar y mover cualquier recurso (archivos y carpetas) que están dentro de la carpeta principal de nuestro proyecto, es importante conocer o por lo menos saber bien cuál es el objetive del recurso que queremos borrar o mover del proyecto, puesto que algunos de ellos contienen código fuente o código compilado esencial para la ejecución de nuestro proyecto, por otro lado existen algunas carpetas que se vuelven a reconstruir integralmente si decidimos borrarlas, estas carpetas son build, la cual contiene los fichero compilados desde el código fuente de nuestro proyecto, netbeans reconstruye esta carpeta automáticamente cada vez que compilamos el proyecto, la otra carpeta es dist, la cual contiene los repositorios (ficheros de código compilado empaquetados en un fichero .jar) finales de nuestro proyecto, al igual que ocurre con la carpeta build, netbeans reconstruye la carpeta dist cada vez que deseamos construir en proyecto final (los repositorios), el resto de carpetas y archivos les recomiendo dejarlas como se encuentran, puesto que algunas como nbproyect y test son utilizadas por el IDE para almacenar ficheros con información sobre la estructura del proyecto, información sobre las librerías adicionales, e información para realizar pruebas, si algunas de estas carpetas o al menos uno de sus archivos cambia de nombre, o en el peor de los casos, se encuentra ausente, en proyecto no podrá ser abierto, compilado, ejecutado y empaquetado por Netbeans.

El panel de proyectos

Este panel es quizás el panel más importante durante la construcción de un proyecto en Netbeans, esto lo digo porque dentro de se pueden ver, crear, copiar, mover, eliminar, compilar y ejecutar los archivos de código fuente y otros recursos que conforman nuestro proyecto, como por ejemplo los paquetes (carpetas para organizar y jerarquizar los recursos del proyecto), los iconos, los archivos de multimedia, archivos de configuración y almacenamiento, librerías (repositorios.jar), páginas web, plantillas para reportes, etc..

El panel de Navegación

Este panel es una utilidad con la que podemos ver en forma de árbol todos los elementos que conforman a una archivo de código fuente que haga parte de nuestro proyecto, en la grafica se puede apreciar los elementos (atributos = variables globales y operaciones = funciones) de la clase (algoritmo con nombre especifico, que almacena variables globales y funciones) IconoSistempres, cada elemento es un nodo (item) del árbol del panel de navegación, se puede apreciar también que el nodo raíz (el primero, el de mayor jerarquía) es el nombre de la clase, además cada elemento de la clase es presentado con un icono que muestra su categoría y ámbito dentro de la clase.

Clase Publica

Función o Método Constructor de la clase

Función o Método Publico

Función o Método Privado

Función o Método Principal (Inicia la ejecución del programa)

Atributos o Propiedades o simplemente Variables Globales Privadas

Panel de Propiedades

Este panel permite ver y configurar de una forma muy fácil y sencilla las propiedades del objeto o clase que hayamos seleccionado desde el panel de proyectos, o desde el panel de navegación, o desde el panel de edición de código, o desde el panel de diseño de GUI (Interfaces Graficas de Usuario), en la grafica se puede ver que las propiedades mostradas son las de la clase IconoSistempes.

Panel de Paleta de Componentes GUI

Este panel trabaja junto al Panel de Diseño GUI y al Panel de Propiedades, se puede considerar que juntos son una bendición, ya que agilizan de forma sorprendente el tiempo de construcción de aplicaciones con GUI, además de permitir un trabajo simple e intuitivo, solo tenemos que seleccionar uno o varios componentes GUI (contenedores o controles) ubicados en el Panel de Paleta GUI, arrastrarlos hasta el Panel de Diseño, dándole la posición y tamaño deseados, ir al Panel de Propiedades y configurar los valores deseado para las propiedades de los componentes seleccionado, por último, podemos ir al panel de diseño y pulsar clic sobre el botón Diseño o Vista Previa y podremos ver como quedara nuestra GUI mucho antes de haber terminado de construir la aplicación.

A este concepto se le conoce como WYSIWYG (What You See Is What You Get), lo que ves es lo que obtienes, ideado y materializado legendaria y superpopular marca de tecnología informática Apple (la que tiene en su logo una manzana mordida y productora de los súper PCs Mac), pero que fue verdaderamente explotado por otro gigante de la informática, cuyo nombre Microsoft es más famoso que bebida gaseosa mundialmente conocida.

Si así es, así está escrito en la historia de la informática, MS (más conocido como Microsoft) ha sacado partido mejorando e innovando a partir de ideas encubadas por otros, algunos lo llaman plagio, otros monopolio y por fin otros lo llamamos estrategia de competencia, lo cierto es que a pesar de todas las demandas que la firma tecnológica ha afrontado en su historia, MS ha salido libre de culpas, argumentando que plagio es copiar o apoderarse sin debida autorización de los planos, el código y de otras cosas propias de la idea, pero lo que ellos algunas veces hacen es reingeniería (o ingeniería a la inversa) sobre algunos avances tecnológicos de interés, el resto de tecnologías son producto de la investigación e innovación de firma, bueno este es otro tema.

Decía que Microsoft fue el primero en hacer posible una herramienta para construir software que utilizara todo el potencial del concepteo WYSIWYG, esto ocurrió hace unas décadas atrás cuando aprecio por primera vez en el mundo le lenguaje de programación Visual Basic para Aplicaciones o VBA, traía consigo una suite de herramientas llamada Visual Studio o VS, cagada de innovación y novedades nunca antes vista, las cuales revolucionarían la forma de construir IDEs para el desarrollo de software, entre ellas se encontraba el concepto de WYSIWYG para la generación automática de código fuente, basada en Drag and Drop (Arrastrar y soltar) y configuración de propiedades, con el tiempo esto se convirtió en un patrón y casi todos los IDEs destacados en el mundo del desarrollo de software incluyen estos principios, por supuesto que Netbeans no podía ser la excepción.

En la zona numero 6 se encuentran uno de dos paneles, el Panel de Diseño GUI o El Panel de Edición de Código, estos dos paneles se muestran según el tipo de clase en la que estemos trabajando.

El Panel de Diseño solo está habilitado cuando estamos trabajado con GUIs, como por ejemplo una ventana (Window, JWindow, Frame, JFrame, Dialog o JDialog) o un panel (Panel, JPanel, JTabbedPane, JSplidPane, JScrollPane, JToolBar, JDesktopPane o JIntenalFrame) o Componentes (JBotton, JRadioBotton, JCheckBox, JToggleBotton, JList, JComboBox, JLabel, JTextField, JPasswordField, JTextArea, JTextPane, JEditoPane, JSlider, JTable, JSpinner, JProgressBar, JSeparator, JMenuItem, JMenu, JMenuBar o JTree ).

El Panel de Edición de Código Fuente esta activado siempre, sin importar que tipo de elemento java estemos trabajado.

El panel de Diseño GUI.

Este panel solo se puede acceder si la clase seleccionada en la que estamos trabajado es o contiene al menos un componente GUI, ya sea del tipo Control (elementos GUI para introducir datos de texto o dar órdenes de selección o mostrar datos) o del tipo Contenedor (elementos GUI donde se pueden colocar o ubicar los controles GUI u otros contenedores GUI, para ser mostrados), algunos ejemplo de controles podemos encontrar los botones, los radios de selección, las casillas de verificación, las listas de ítems de selección, las tablas (filas y columnas), los campos para introducir texto o contraseñas, entro otros, como ejemplo de contenedores podemos encontrar las ventanas, los paneles, los menús, las pestañas, entre otros, todos estos componentes se pueden ver, arrastrar y probar desde el panel de Paleta de Controles GUI, en este panel se encuentran organizados por categorías, con el fin de implicarnos la búsqueda de los mismos

El panel de Edición de Código Fuente

Este panel es muy importante porque nos permite ver, escribir y modificar el código de nuestras clases, todo absolutamente todo lo que podemos hacer en el Panel de Diseño de GUI, también se puede realizar desde el Panel de Edición de Código Fuente, de hecho, cada vez que colocamos un componente en el Panel de Diseño, o realizamos un movimiento del mismo cambiamos sus propiedades, Netbeans simplemente genera el código fuente Java correspondiente a dichas acciones, basándose en los principios de WYSIWYG, de igual forma sucede si desde el Panel Editor de Código escribimos código Java para colocar, quitar o mover un componente o cambiamos sus propiedades, al pasar al Panel de Diseño, todos estos cambios se vean reflejados en la GUI que estemos desarrollado.

• El panel de Edición de Código Fuente también posee otras funcionalidades importantes e igualmente útiles, sobre todo cuando estamos escribiendo código fuente para una clase u otro elemento del proyecto, entre estas utilidades se encuentran:
• El autocompletado de código, para elementos del e lenguaje como, sintaxis, bloques condicionales, bloques para bifurcaciones, bloques para ciclos iterativos, bloques para manejo de errores, funciones constructores, funciones obtenerdoras y modificadoras de valores de variables globales, funciones para eventos, etc.
• Dando clic derecho sobre el Editor de Código escogemos la opción Insertar Código, y nos parecen varias opciones para insertar código en el editor.

• Consulta y presentación de Clases con todos sus elementos públicos, ubicadas en las librerías que hayamos colocado en el proyecto y por su puesto en las librerías del JSDK.

• Consulta de los elementos (variable y funciones) de una clase.

• Además de mostrar los elementos de una clase, también muestra su documentación siesta está disponible.

• Coloreado y resaltado de palabras claves del lenguaje Java y otros lenguajes soportados por el IDE.

• Retraer y desplegar bloques de código, como comentarios, condicionales, ciclos, funciones, clases, etc.

• Auto compilado en tiempo de edición, resaltando en varios colores las líneas de código que donde se encuentran los errores.

• Copiar, pegar, cortar, buscar y reemplazar texto.

• Restauraciones del código con vista previa, dando la oportunidad de ver los cambios antes de ser ejecutados, posibilitando cancelarlos si es necesario.
• Restauración, optimización y sugerencias inteligentes de mejoras para el código escrito.

Crear un nuevo proyecto tipo Aplicaciones Java

Para poder realizar cualquier trabajo en NetBeans se debe crear un proyecto para organizar y gestionar todos los recursos que harán parte de dicho trabajo.

Los pasos para crear un proyecto en NetBeans:

1. Iniciar NetBeans
2. Clic en el menú Archivo
3. Clic en el ítem (opción) Nuevo Proyecto
4. Seleccionar escoger la categoría y el tipo de proyecto (para nuestro caso Proyecto Aplicación de escritorio Java de la categoría Java).
5. Pulsar en el botón siguiente.
6. Introducir el nombre del proyecto, el cual debe cumplir con la reglas de sintaxis para dar nombres a paquetes, clases, interfaces, enumeraciones, variables y funciones o métodos, se recomienda que el nombre del proyecto no tenga $ _ y está en minúscula.
7. Seleccionar la carpeta donde se guardara el proyecto, NetBeans guarda los proyectos en una carpeta por defecto llamada NetBeansProyects, que se encuentra en la carpeta documentos, del usuario que inicio sesión en el Sistema Operativo.
8. Opcionalmente pueden cambiar el nombre de la clase principal de la aplicación, en este caso yo la dejo con el nombre que NetBeans le da por defecto, por mas adelante en este articulo, les explico como cambiarla después de creado el proyecto.
9. Si desean conectarse a bases de datos en esta aplicación, pueden seleccionar la opción Aplicación De Base de Datos, de lo contrario pueden dejar la opción por defecto, Aplicación básica, esta opción también se puede realizar después de creado el proyecto.
10. Si tenemos librerías de clases compiladas para utilizar en nuestro proyecto, podemos agregarlas seleccionado la opción usar una carpeta dedicada para almacenar las librerías (es recomendable no cambiar el nombre de la carpeta lib que por defecto es la utilizada por NetBeans para guardar las librerias), también se puede hacer después de creado el proyecto.
11. Por último deben seleccionar la opción Configurar como Proyecto Principal, con el fin de que si tiene otros proyecto abiertos en el panel de proyectos, este nuevo proyecto sea al que se le apliquen los cambios al momento de compilar, construir y ejecutar la aplicación.

También pueden utilizar la barra de herramientas Archivo y pulsar el botón Creación de un nuevo proyecto

En esta ventana se puede seleccionar varios tipos de proyecto, desde aplicación Java bacía, donde uno va construyendo poco a poco cada elemento del software, aplicación de escritorio, la donde Nebeans genera todo lo necesario para iniciar a construir una aplicación sofisticada de escritorio, proyecto de biblioteca (librería .jar el homologo de librería .dll), proyecto partiendo del código de otros proyecto generado con Netbeans o sus homólogos JCreator, Gel y Eclipse, por ultimo podemos crear proyectos de formularios con un framework de código libre desarrollado en Java llamado open-swing.

En nuestro caso solo nos concentraremos en realizar una simple aplicación de escritorio, pero si alguien lo desea puede crear otros tipos de proyectos, como se puede ver en el panel de categorías aparecen otras opciones, por ejemplo Aplicaciones Web, Aplicaciones para Móviles (Teléfonos y PDA) , aplicaciones empresariales (Enterprise Edition), proyectos para Modelado de software Orientado a Objetos con UML, incluso se pueden crear proyectos para construir aplicaciones en otros lenguajes como C++, PHP, Ruby y Grovvy, todos soportados por Netbeans en su versión completa, que también es libre.

Después de escoger el tipo de proyecto (Aplicación de Escritorio Java), pulsamos en el botón siguiente para configurar los datos del proyecto.

Configuración del proyecto

En esta ventana que es el la número 2 y la última del asistente (wizard) para la creación de proyectos de escritorio, se puede especificar datos importantes de los proyectos como lo son:

El nombre del proyecto

Este nombre cumple con las reglas de sintaxis de nombres de Paquetes, Clases, Enumeraciones, Interfaces, Variables y Funciones del lenguaje Java, es decir, no puede contener espacio, puede tener números o letras, o una combinación de los dos, pero no puede iniciar con numero, el único carácter especial (que no es letra, ni es número) que puede tener es el carácter de guion bajo (rayita de piso _), aunque puede contener mayúsculas, se recomiendas por nemotecnia (conducta estándar para escribir código fuente de un software) que el nombre del proyecto sea todo en minúsculas.

La ruta de almacenamiento del proyecto

Netbeans almacena los proyectos por defecto en una carpeta creada por el mismo llamada NetBeansProjects, que por defecto se ubica en la carpeta documentos (en Windows o GNU/Linux), se puede indicar otra ruta si así se desea, solo hay que pulsar el botón examinar y navegar por el sistema de archivos utilizado por el PC, hasta encontrar la ubicación deseada.

El nombre de la Clase Principal de la aplicación

Toda aplicación de escritorio creada con Java, necesita de una clase donde se encuentre la función (método) main (Principal), esta función es utilizada por la JVM (java Virtual Machine) de Java para poder iniciar con la ejecución de la aplicación, Netbeas por defecto le da un nombre a esta clase, el nombre es formado por el nombre del proyecto iniciando en mayúscula, unido a la palabra App, la cual es una abreviación de Application en Ingles, nosotros podemos cambiar el nombre por defecto de la clase principal, por el nombre que nosotros queramos, si así lo deseamos, la única restricción que existe, es que dicho nombre debe respetar las reglas de sintaxis para los nombres de clases del lenguaje Java, las cuales son similares a las explicadas para el caso de los nombres de proyectos, además el IDE guarda esta clase en un paquete (carpeta) que lleva el mismo nombre del proyecto, a este paquete se le conoce como Paquete Raíz (paquete principal o paquete de la aplicación).

Configurar como proyecto principal

Si seleccionamos esta opción (checamos la cajita de verificación que señale en rojo), Netbeans marcara este proyecto como el proyecto por defecto en el Panel de Proyectos, esto permite que todas las operaciones realizadas dentro del IDE, se realicen sobre este proyecto, siempre y cuando este está abierto, esta característica es muy útil cuando tenemos más de un proyecto abierto dentro del Panel de Proyecto.

El último paso es pulsar el botón siguiente y Netbean tardara unos segundos generando todos los recursos para poder iniciar la construcción de nuestro proyecto tipo aplicación de escritorio.

Proyecto de Aplicación de Escritorio de Netbean

Estructura predefinida del proyecto

Como podemos ver, Netbeans genera automáticamente un conjunto de recursos (archivos) necesarios para iniciar con la construcción de nuestro proyecto, entre los que se encuentran archivos de imágenes, librerías de clases java .jar, archivos de código fuente .java, carpetas (paquetes) y ficheros de configuración en lenguaje XML y de propiedades.

He marcado con colores las diferentes zonas de recursos que el IDE género de forma automática, la zona roja contiene un paquete con tres archivos de código fuente, un fichero llamado EjemploAboutBox.java que contiene código fuente para utilizar una ventana de ayuda Acerca de…, otro archivo llamado EjemploView.java, que contiene el todo el código fuente necesario para utilizar una ventana principal en nuestro proyecto, por último se genera un archivo de código fuente con el código necesario para iniciar la aplicación, es decir, contiene el método main (función de arranque ) utilizado por la JVM para iniciar la aplicación sobre el Sistema operativo.

Realicemos un breve análisis de las clases que genera Netbeans, para ver su contenido podemos ir al panel de proyectos y seleccionar el archivo dando doble clic sobre clic, veamos el contenido del archivo EjemploView.java

Elementos de la ventana principal de un proyecto de aplicación de escritorio

Esta clase implementa un formulario GUI, por este motivo hereda de la Clase FrameView (Ventana con Marco visible) ubicada en el paquete org.jdesktop.application, que a su vez hereda de la clase JFreme (ventana con Marco) ubicada en el paquete javax.swing, que a su vez que a su vez hereda de la clase JWindow (Ventana de Java) del mismo paquete, que a su vez hereda de la clase Window (Ventana, normalmente prestada a Java por el Sistema Operativo) del paquete java.awt, que a su vez hereda de la clase Conteiner (Contenedor) del mismo paquete, esta última clase hereda de la clase Component (Componente) del mismo paquete, como se puede apreciar, las clases Window, JWindow, JFrame, FrameView y EjemploView, todas heredan directa o indirectamente de la clase Container, convirtiéndolas en Componentes GUI del tipo Contenedor, es por esto que la clase EjemploView de nuestro proyecto puede contener otros componentes (controles y contenedores), tal y lo muestra la grafica anterior, netbeans genera la ventana EjemploView con los siguientes componentes controles:

1. Un objeto componente de tipo JPanel (un Panel para colocar componentes) de paquete javax.swing, esta clase es un contenedor (hereda directa o indirectamente de Container del paquete java.awt) que no es una ventana (no hereda de Windows), lo cual indica que no se puede hacer visible individualmente, para poder mostrarlo debe estar dentro de un contenedor de tipo ventana por ejemplo un JFrame, los paneles se utilizan básicamente para colocar otros componentes, los cuales normalmente son controles u otros paneles, este panel 1 representa la barra de estado de la ventana principal de nuestro proyecto y está ubicado en la parte sur o inferior dentro de la ventana FrameView.
2. Un objeto componente de tipo JProgressBar (Barra de Progreso Java) del paquete javax.swing, esta clase que hereda de JComponent tiene toda la funcionalidad necesaria para trabajar con barras de progreso (barras que se van llenado o disminuyendo en tiempo de ejecución), esta barra se encuentra ubicada en la parte derecha dentro del panel barra de tareas.
3. Un objeto componente de tipo JMenuBar (Barra de Menu Java) del paquete javax.swing, esta clase que hereda de JComponent tiene toda la funcionalidad necesaria para trabajar con barras de menú (barras ubicadas en la parte superior de una ventana, donde se encuentra los menús de opciones del programa), las barras de menú pueden aunque no son contenedores propiamente dichos, están formados por otros objetos del tipo JMenu, los cuales son mostrados dentro de esta clase y anclados a esta barra en la parte superior de la ventana.
4. Dos objetos componentes de tipo JMenu (Menu Java) del paquete javax.swing, esta clase que hereda de JComponent mas directamente de JMenuItem, tiene toda la funcionalidad necesaria para trabajar con Menus, las cuales representan lista de opciones o ítems JMenuItem desplegables, que solo se encuentran dentro de una barra de menú JMenubar, o dentro de otro Menú como un submenú del mismo, o dentro de un menú contextual JPopupMenu también conocido como menú del clic derecho.
5. Se puede apreciar que la barra de menús posee dos objetos tipo JMenu, uno muestra la etiqueta File y el otro la etiqueta Help, el texto de estas etiquetas lo puede cambiar por nuestro propia leyenda, si así lo deseamos, solo tenemos que seleccionar el componente de tipo JMenu que deseamos cambiar, luego pulsamos la tecla barra esparcidora (la que da los espacios en blanco), el menú cambiara su estado y pasara a estado editable, donde podremos escribir lo que desamas que aparezca, otra opción para cambiar el texto de los componentes, consiste en seleccionar dicho componente, luego ir al panel de propiedades, buscar la propiedad TEXT , dar clic sobre el texto no deseado y reemplazarlo por el nuestro, el texto se puede cambiar de la misma forma para todos los componentes que muestren alguna leyenda.
6. Un objeto componente de tipo JMenuItem (Item u Opción de Menú) del paquete javax.swing, esta clase que hereda de JComponent tiene toda la funcionalidad necesaria para trabajar con items de menú, siendo estos todas aquellas opciones que se encuentran dentro de un menú, y que solo pueden ser visibles cuando desplegamos el dicho menú (en este caso el menú File), estas opciones generalmente tienen asociado un evento, que al dar clic con el mouse, o pulsando una convención de teclas, generan una acción específica dentro del sistema, al igual que ocurre con los menús, estos componentes poseen una leyenda intuitiva, la cual puede ser modificada a nuestro antojo.
7. Es otro objeto componente de tipo JPanel (Panel), el cual se encuentra ubicado dentro del objeto ventana (EjemploView) en la parte central, este panel representa el panel de fondo de la ventana principal de nuestro proyecto.
8. Es un objeto componente tipo EjemploView, la cual hereda de FrameView del paquete org.jdesktop.application, que a su vez hereda de JFrame (ventana Java con marco) del paquete javaz.swing, esta ventana representa la ventana principal de nuestro proyecto, compuesta por un conjunto de otros componentes GUI incluidos dentro de ella, esta ventana fue generada de forma automática por Netbeans.

El panel de Inspección

Para poder ver la jerarquía de todos los componentes GUI que se encuentran dentro de un contenedor, ya se ventana o panel, podemos dar clic en el panel lateral llamado Panel Inspector, este panel solo está disponible cuando nos encontramos en el Panel de Diseño GUI, para ellos es necesario que la el archivo seleccionado sea creado como un formulario JWindow, JFrame, FrameView, JDialog, o JPanel.

Panel de Inspección de componentes.

En la grafica anterior podemos ver el panel de inspección correspondiente a la clase EjemploView, dentro de este panel se aprecia en forma detallada la posición de cada componente dentro de la ventana, vemos que algunos se encuentran dentro de otros, formando una jerarquía anidada, además se aprecia también los nombres de la variable y sus respectivos tipo (clases) Java y un icono que muestra en miniatura la forma de cada componente, estas variables son utilizadas en el código fuente para hacer referencia a cada componente especifico, estos nombre son colocados de forma predeterminada por el IDE, dándonos la posibilidad de cambiarlos a nuestro antojo, para ello solo es necesario dar clic derecho sobre el nombre de la variable del componente deseado, aparece un menú contextual, del cual debemos seleccionar la opción Cambiar Nombre de Variable.

Luego nos aparece una nueva ventana, en la cual debemos ingresar el nuevo nombre que deseamos darle a la variable del componente seleccionado.

Al pulsar en el botón aceptar, podemos ver que Netbeans ha cambiado el nombre de la variable seleccionada, por el nombre que le indicamos, esta operación de cambio de nombre se realiza dentro del todo el proyecto, es decir, Netbeans busca dentro de todos los archivos de código fuente que hemos escrito dentro de nuestro proyecto, el antiguo nombre de la variable que hemos seleccionado y procede a reemplazarlo de forma segura, sin riesgos de cambiar una variable que pueda llamarse igual a la variable original.

Por último procedemos a cambiar las propiedades de alguno de los componentes que pertenecen a la ventana EjemploView, para ellos solo tenemos que seleccionar el componente deseado desde el Panel de Diseño, en este caso, seleccionan el panel de la barra de estados, luego se dirigen a al Panel de Propiedades y escogen la propiedad que deseada, por ejemplo, pueden escoger la propiedad Backgroud (Color de fondo), de esta forma podrán ver el cambio inmediato sobre el Panel de Diseño.

Como pueden observar al seleccionar el componente (en el ejemplo el panel barraDeEstados), se ha seleccionado de forma automática dicho control en el Panel de Inspección, además, en la parte superior del Panel de Propiedades se puede observar el nombre del componente seleccionado, estas son dos señales que nos indican que se ha seleccionado el componente deseado, un error que suele ocurrió cuando seleccionamos un componente desde el Panel de Diseño, cambiamos sus propiedades y el resultado se aplica a otro control, esto puede ocurrió cuando el componente al que deseamos cambiar sus propiedades, se encuentran ubicados detrás o dentro de un componente transparente, como por ejemplo el panel JGlassPane.

Para seleccionar el color de fondo pulsan clic sobre la propiedad Backgroud, de inmediato les aparece un componente para seleccionar el color, el cual presenta una amplia gama de opciones para acoger solo una, este componente se llama selector de color, cuya clase Java tiene el nombre de JColorChooser del paquete java.swing, dentro de esta ventana se muestra el nombre de la variable del componente al que se ele esta aplicado el color(barraDeEstados), junto al nombre de la propiedad que cambia el color (background) separados por punto (barraDeEstados.backgrond), también se muestra la intensidad de colores RGB (Red Green Blue) que forman al color seleccionado, por ultimo proceden a pulsar clic sobre el botón aceptar, entonces Netbeans como respuesta aplica de forma instantánea ese color sobre el fondo del panel seleccionado, algo que se puede ver desde el Panel de Diseño.

Para cambiar una o varias las propiedades de cualquier otro componente, se realiza el mismo procedimiento:

1. Ubicarse en el Panel de Diseño
2. Seleccionar el componente deseado (desde al Panel de Diseño o desde el Panel de Inspección)
3. Ir al Panel de Propiedades, verificar que sean las propiedades del control seleccionado.
4. Seleccionar la propiedad que deseamos cambiar
5. Indicar los valores de dicha propiedad
6. Si requiere, pulsar clic en el botón aceptar para finalizar.

Ahora analicemos la clase EjemploAboutBox.java.

Los pasos son los mismos que realizamos con la clase EjemploView.

1. Ir al Panel de Proyectos
2. Seleccionar el paquete de fuentes
3. Seleccionar el paquete donde se encuentra la clase EjemploAbautBox.java, el cual es el paquete ejemplo,
4. Seleccionar el archivo de la clase, dándole doble clic, este archivo muy rara vez tiene un nombre diferente al nombre de la clase, esto se debe a una convención de codificación del lenguaje Java, la cual recomienda que por cada clase que se inscriba en un proyecto, debe un respectivo archivo de código fuente .java cuyo nombre es el mismo nombre de la clase que contiene.
5. Luego ubicarse en el Panel de diseño, o de código fuente según sea el caso.

En la grafica podemos ver que la clase es un contenedor, en este caso hereda de otro contenedor llamado JDialog del paquete javax.swing, al cual he etiquetado con el nuero 1.

Un JDialog representa una ventana que a su vez hereda de JFrame ubicada en el mismo paquete javax.swing, a pesar de que ambas clases implementan una ventana, existen sutiles diferencias entre un JDialog y un JFrame, la más relevante es que un JDialog se comporta como ventana Modal o no Modal según se requiera, es decir, al mostrar (hacer visible = setVisible(true) un JDialog y este se coloca delante de un JFrame, siempre estará por sobre dicho JFrame, en este momento el JDialogo puede deshabilitar la posibilidad de utilizar a la ventana (el JFrame u otro JDialog) que está detrás, en este caso se dice que es una ventana Modal, lo que quiere decir que el JDialog que se está mostrando en ese momento debe ser utilizado primero y una vez cerrado se puede utilizar cualquier otra venta que este abierta en la aplicación Java, el caso contrario ocurre cuando el JDialog se muestra sobre otra ventana (JFrame u otro JDialog ) habilitando la posibilidad de utilizar las ventanas que están detrás de él, pero el JDialog siempre se muestra sobre ellas, en este caso se dice que es una ventana no Modal.

Siguiendo con el análisis de la clase EjemploAboutBox.java, vemos que esta al se r un contenedor Netbeans la ha construido colocándole un conjunto componentes adicionales, entre los que se encuentran 9 etiquetas, los cuales son objetos de la clase JLabel del paquete javax.swing, estos componentes se utilizan para mostrar pequeñas pariciones de texto que etiquetan a otros componentes, también son utilizadas para organizar de forma simple información breve que se mostrar, tal como sucede en este caso, en la imagen anterior he colocado el nuero 3 a todos los componentes de tipo JLabel.

Existen otro componente importante en esta ventana EjemploAbautBox, se trata del componente que he etiquetado con el numero 2, este componente representa a un botón de pulsado, el cual pertenece a la case JButton ubicada igualmente en el paquete javax.swing del JSDK (Java Standart Software Developer Kid) o caja de herramientas estándar para el desarrollo de software con Java, los botones de pulsado, o simplemente botones, son uno de los componentes GUI más utilizados para el desarrollo de aplicaciones con Interfaces Graficas de Usuario, se puede decir que forman parte básica de los componentes GUI de cualquier aplicación actual.

Cambiar el nombre de una clase

Puede ocurrir que en alguna ocasión decidamos cambiarle el nombre a una de las clases que hacen parte del código fuente de uno de nuestros proyectos, el motivo puede ser por error al digitar su nombre, por simple capricho, o porque NetBeans le dio un nombre por defecto que no deseamos tener, este último caso es justo el que se nos presenta en esta ocasión, noten que los nombres que Netbeans ha dado a las clases de nuestro proyecto, son nombres en ingles y que siguen un patrón lógico, este patrón incluye el nombre del proyecto al inicio, acompañado del objetivo de la clase en ingles.

Ustedes pueden cambiar de forma segura el nombre de cualquier clase que haga parte del proyecto, siempre y cuando el código fuente de dichas clases haga parte del proyecto, para ello debemos seguir los siguientes pasos:

1. Ir al Panel de Proyectos
2. Seleccionar el nombre del archivo que pertenece a la clase que deseamos cambiar de nombre.
3. Pulsar clic derecho sobre el archivo
4. Seleccionar del menú emergente la opción reestructurar
5. Seleccionar del submenú la opción cambiar nombre…
6. En la ventana que se muestra introducir el nuevo nombre de la clase
7. Pulsar el botón vista previa, si desean ver los cambios que se van a realizar en el código fuente antes de ser aplicados definitivamente, si deciden cancelar la operación , pueden pulsar en el botón cancelar.
8. Pulsar en el botón Reestructurar para aplicar los cambios de forma definitiva, incluso en todos los lugares del código fuente donde sea utilizado el antiguo nombre de la clase.

Ver los pasos resumidos en las siguientes dos imagenes

Pulsar Vista Previa si desean chequear la operación antes de ejecutarse, o simplemente pulsar Reestructurar para ejecutar la operación de forma inmediata.

Como pueden apreciar Netbeans aplica los cambios sobre los archivos a los que se le realizo la operacio, pero también aplica los cambios en el código fuente del proyecto

También habrán notado que he cambiado el nombre de la clase Ejemplo por Principal, de la clase EjemploView por VentanaPrincipal y la clase EjemploAboutBox por VentanaAcercaDe, de la misma forma he cambiado todos los componentes GUI que hacen parte de cada ventana, ahora sus variables tienen nombres más familiares e intuitivos por que están en español.

El código de la clase Principal.java

Esta clase hereda (extends) de la clase SingleFrameApplication del paquete org.jdesktop.application.SingleFrameApplication, por este motivo es que hay que importar dicho paquete y dicha clase, en el lenguaje Java hay varias formas de hacer esto, la más común es utilizar la palabra import junto a la ruta completa de paquetes donde se encuentra ubicada la clase que se desea utilizar (importar), un ejemplo claro se ve en las línea 7 y 8 del código fuente de la clase Principal (ver la imagen anterior).

En estas dos líneas se importan dos clases utilizadas dentro del código fuente de la clase Principal, la primera es la clase Application, la cual está ubicada en el paquete (carpeta) application, el cual a su vez está ubicada dentro del paquete jdescktop, el cual a su vez está ubicado dentro del paquete org, el cual a su vez está ubicado en el archivo swing-worker-1.1.jar y por ultimo este debe estar agregado a las bibliotecas de librerías del proyecto.

Algunas clases se importan sin necesitad de agregar librerías adicionales al proyecto, estas clases hacen parte del código fuente del proyecto como por ejemplo Principal.java, VentanaPrinclipal.java y VentanaAcercaDe.java, además de estas, existen otras clases que vienen incluidas en los paquetes del JSDK de Java.

Esta clase conecta a nuestra aplicación con el Framework Swing Application, el cual es un conjunto de clases desarrolladas con el fin de agilizar las tareas mas comunes en el desarrollo de aplicaciones de escritorio, está diseñando utilizando la librería de Java SWING para componentes GUI, la cual carece de ciertos detalles importantes como persistencia automática del estado de los componentes, es decir, si cerramos la aplicación y dejamos desactivado o activado cierto botón o componente GUI, al volver a abrir la aplicación dichos componentes GUI no tendrán el estado con el que fueran guardados al momento de cerrar la aplicación , esta característica tan importante en una aplicación de escritorio tenía que ser manejada por el programador Java, gracias al desarrollo de este excelente marco de trabajo (FrameWork) ahora es mucho más fácil realizar estas tarea, entre otras no menos importantes como por ejemplo saber si la aplicación ya esta ejecutada para así evitar ejecutar otra instancia de la misma en memoria, etc..

Los métodos void startup( ) y void configureWindows( Windows root ) de la clase Principal son heredados de la clase SimpleFrameAplication que hace parte del Framework Swing Application, estos métodos se ejecutan de forma automática al llamar a método void launch (SimpleFrameApplication app, String[] args), el cual a su vez es llamado dentro del método static void main( String[] args).

Se puede ver que el método void startup( ) llama en si interior al constructor de la clase VentanaPrincipal, pasándole su objeto como parámetro al método show igualmente heredado de SimpleFrameApplication, el cual se encarga de mostrar a la ventana justo en el centro de la pantalla.

Compilar el Proyecto, ejecución de la Aplicación.

El proceso de compilación consiste en solicitar al depurador del lenguaje Java (javac.exe = java compilator) que inicie con la verificación de cada una de las líneas de código fuente de cada recurso de nuestro proyecto, en esta verificación se revisa que se cumpla estrictamente con la sintaxis del lenguaje Java, también se revisan que las rutas de los archivos que contienen cada una de las clases que se utilizan en el proyecto se encuentren dentro de la variable den entorno CLASSPATH, las clases que hacen parte del JSDK no ya se encuentran en esta ruta desde el mismo momento de la instalación del JSDK, pero es muy común en los proyecto utilizar clases escritas y compiladas por otras personas, o por nosotros mismos, ya sea en el proyecto actual o en otros proyectos pasados, estas clases generalmente se encuentran almacenadas en archivos repositorios (una especie de archivos contendor de otros archivos, como por ejemplo con extensión, .tar, .zip, .gz, .dll, .cap, .rpm, .bin, .deb, .exe, .jar o .jad, etc. ) , la ruta de estos archivos también se coloca tal y como está dentro de la variable de entorno CLASSPATH, el compilador Java extrae de forma automática las clases que aquí se encuentran, si el compilador encuentra al menos una violación de las reglas de sintaxis del lenguaje Java, o no encuentra el origen de alguna clase utilizada en el proyecto, entonces, seremos notificados con detalles del todos los errores encontrados, si por el contrario el compilador determina que todo se encuentra en perfectas condiciones, procese a generar el binario Bytecode, el cual es analizado por el Interprete Java (java.exe) que hace parte de la JVM (Maquina virtual Java), este análisis interpreta cada instrucción en código binario bytecode de nuestras clases compiladas y las transforma a código binario compatible con la arquitectura (CPU = microprocesador) y plataforma (Sistema Operativo) del computador donde se ejecuta la JVM y por ende nuestro programa, como resultado de todo este proceso obtenemos un programa de computo, que puede ser ejecutado en sobre cualquier computador que posea instalada la JVM, este es el secreto que hiso grande y famoso al lenguaje de programación Java, que por cierto, este mismo principio fue utilizado para la creación de nuevas ideas, como por ejemplo el .NET FremeWork de Microsoft, que a mi punto de vista, mejoro muchos de los inconvenientes que tenia al JVM original y ofreció mayores posibilidades para nosotros los programadores de aplicaciones para computo, por ejemplo adaptar el ancestral y siempre útil concepto de estructura (Struct en C, o Typedef en VB) a al ya algo viejo paradigma orientado a objetos, de igual forma hizo con las enumeraciones y dos conceptos relativamente nuevos llamados delegados (Delegates) y genéricos (Generics), pero quizás lo más importante para nosotros, es la posibilidad de poseer un conjunto muy pero muy amplio de clases, organizadas dentro del .Net framework en librerías y nombres de espacios (NameSpace), las cuales se pueden utiliza con un conjunto igualmente amplio de lenguajes de programación, entre los que se encuentran legendarios y por siempre grandes lenguajes como:

• · C++, Cobol (ahora #Cobol).
• · Fortran (ahora OO).
• · Delphi (antiguo Pascal OO).
• · VB (ahora OO).
• · Smalltalk (el papa de los lenguajes OO, ahora sharpSmalltalk o #Smalltalk).
• · PowerBuilder (popular pero muy extraño).
• · Dos miembros de la familia GNU como lo son Perl (ahora PerlNet) y Python (ahora ironPhyton).
• · Por supuesto no podían faltar los novatos pero avasalladores:
• · Java (ahora J#).
• · C# (hace poco anunciado como el gran sucesor de VB).
• · Ruby (Lenguaje japonés que ha tenido gran aceptación en todo el mundo ahora ruby.Net)
• · JScript (una versión especial de JavaScript para el servidor).

Disculpen la excesiva introducción que he hecho sobre .Net Framework en este artículo dedicado a Java y su fabuloso IDE Netbeans, loc que pasa es que me emociono cuando hablo sobre .Net Framework, ahora si a lo que íbamos.

Pasos para compilar desde NetBeans.

Hay varias formas de compilar un proyecto en Netbeans.

Forma No. 1

1. Clic en menú Depurar
2. Clic en el ítem Debug Proyect

Forma No. 2

1. Pulsar la combinación de teclas Ctrl + F5

Forma No. 3

1. Ir al Panel de Proyectos
2. Clic derecho sobre el nodo Raiz ( el primer nodo del árbol, que nombre del proyecto)
3. Clic en el item Depurar

Forma No. 4

1. Pulsar clic sobre el botón Debug Proyect

Si el compilador Java encuentra en un error dentro del código fuente, mostrar un mensaje notificando sobre dicho error.

Ventana que notifica la detección de un error por el compilador.

Notificaciones de NetBeans cuando el compilador detecta un error en el código fuente.

Como podemos ver, NetBeans nos muestra de varias maneras que el compilador Java detecto al menos un error en el código fuente, entre las notificaciones que nos presentan se encuentran:

• · Las clases donde se encuentras los errores
• · Los mensajes de error que envía el compilador.
• · Las líneas de error donde se encuentran los errores
• · La ruta de los ficheros de clase Java donde se encuentran los ficheros que tienen errores.

La carpeta build de NetBeans

Si el proceso de compilación termina de forma satisfactoria, NetBeans genera un nuevo directorio llamado build, en este directorio almacena todo el fichero compilados con extensión .class correspondiente a los ficheros de código fuente con extensión .java que se encontraban en la carpeta src, además de los ficheros compilados, NetBeans copia en esta carpeta todos los archivos que corresponden a los recursos utilizados por el proyecto, como por ejemplo iconos e imágenes, archivos de multimedia, plantillas de reportes, etc..

Esta carpeta la pueden eliminar cada vez que deseen, que se vuelve a reconstruir de forma automática cada vez que NetBeans realice el proceso de compilación de forma satisfactoria.

Siempre que se realice sin problemas la compilación de un proyecto, NetBeans intenta ejecutarlo, si el proyecto un aplicación de escritorio, NetBeans busca la clase que registrada con el método main y la ejecuta, si el proyecto es una aplicación web, el IDE inicia el servidor de aplicaciones que se haya elegido para contener los Servlet y paginas JSP del proyecto, luego busca el fichero que se haya seleccionado como archivo inicial (un Servlet o comúnmente una página llamada index.jsp o index.html) del sitio web, la ejecuta y transfiera su salida (normalmente combinación de código HTML, JavaScript, CSS, XHTML y ficheros multimedia) al Cliente Web (normalmente un Navegador Web o Browser) que tenga predeterminado el Sistema Operativo, si por el contrario el proyecto es una aplicación móvil J2ME (una versión reducida de Java, especialmente diseñada para escribir aplicaciones para dispositivos móviles como teléfonos y algunas PDA), el NetBeans la ejecuta sobre la plataforma móvil que posea instalada por defecto, utilizando un Emulador (software que simula el comportamiento de un dispositivo móvil) que nos permite ver la aplicación casi de la misma manera como se verá ejecutada sobre un dispositivo móvil real.

Ejemplo del la ventana principal que genera NetBeans al crear un proyecto tipo aplicación de escritorio

Ejemplo de la ventana Acerca de, generada automáticamente por NetBeans al crear un proyecto tipo aplicación de escritorio

Parada o terminación de una aplicación en ejecución

Para detener la ejecución de una aplicación puesta en desde el IDE, podemos realizar una de las siguientes operaciones sobre NetBeans:

· Ir al menú Depurar del NetBeans y seleccionar el ítem (opción) finalizar sesión del depurado.

1. · Pulsar la combinación de teclas SHIF + F5
2. · Ir a la barra de herramientas y pulsar clic sobre el botón Finalizar Sesión del Depurador
3. · Ir al Panel de Salida y pulsar en el botón Finalizar Sesión del Depurador

Construir el repositorio de distribución de la aplicación

Una vez terminado el proyecto, sea cual sea su tipo, siempre queremos tener todos los recursos compilados en un solo archivo (como sucede con los ficheros .exe, o .dll), de esta forma será mucho más fácil su distribución, instalación y ejecución desde medios de almacenamiento digitales o desde la misma red.

Para poder crear uno o varios repositorios del proyecto desde NetBeans, solo tenemos que realizar uno de los siguientes pasos:

1. · Ir al menú Ejecutar de NetBeans y seleccionar el la opción Limpiar y Generar el Proyect
2. · Pulsar la combinación de teclas SHIF + F11
3. · Ir a la barra de herramientas de ejecutar y compilar y pulsar clic sobre el botón Limpiar y Generar Proyect
4. · Ir al Panel de proyectos y seleccionar el nodo (item) raíz (el primero, el que tiene el nombre del proyecto) y al pulsar clic derecho sobre dicho nodo, seleccionar del menú contextual que aparece la opción Limpiar y Generar Proyect

Cualquiera que sea la forma que utilicen para generar los repositorios del proyecto, Netbeans como respuesta empaqueta todos los recursos compilados y archivos necesarios para la correcta ejecución de la aplicación, para ello crea de forma automática una carpeta llamada dist, en la cual coloca todo lo necesario, por lo general crea un fichero con extensión .jar si el proyecto es una aplicación de escritorio o librería de clases, o un archivo con extensión .war si se trata de una aplicación de sitio web, en cualquier caso empaqueta todo el contenido de la carpeta build en este fichero, además si el proyecto es una aplicación de escritorio y utiliza alguna biblioteca de clases externa al código fuente del proyecto, el IDE crea dentro de la carpeta dist una nueva carpeta que por defecto se llama lib, donde coloca todas las librerías utilizadas por el proyecto.

Carpeta de distribución de repositorios del proyecto

Hasta este punto se puede notar a simple vista la robustez que posee este magnífico IDE, para este ejemplo hemos creado la estructura básica de una aplicación de escritorio, pero lo más importante sin escribir una sola línea de código, aun que fue concebido inicialmente para agilizar en gran medida el trabajo de construcción de aplicaciones mediante el lenguaje de programación Java, también es utilizado frecuentemente como herramienta de construcción para proyectos basados en otros lenguajes como C++, Ruby y PHP, donde su robustez y simplicidad esta casi a la altura de las bondades que ofrece con el lenguaje Java.

Ya me despido, espero que les haya gustado esta breve introducción sobre NetBeans, en el siguiente articulo explicare como hacer una aplicación  con conexión a Bases de Datos sin salir del IDE NetBeans, ademas, explicare el uso de los controles GUI básicos de Swing.

Que descanse y que Dios todo poderoso los llene de bendiciones.

494 Visitas hoy