MANUAL DE NETBEANS
Configuración del proyecto Para crear un proyecto IDE:
1.
Inicie NetBeans IDE.
2.
En el IDE, seleccione Archivo> Nuevo Proyecto (Ctrl + Mayúsculas + N), como se muestra en la siguiente figura.
3.
En el asistente Nuevo proyecto, expanda la categoría Java y seleccione Aplicación Java como se muestra en la siguiente figura. A continuación, haga clic en Siguiente.
4.
En la página Nombre y ubicación del asistente, haga lo siguiente (como se muestra en la figura siguiente):
En el campo Nombre de proyecto, escriba HelloWorldApp .
Deje la carpeta de uso dedicado para Bibliotecas casilla Almacenar sin seleccionar.
En el campo Clase Create Main, tipo helloworldapp.HelloWorldApp .
Haga clic en Finalizar El proyecto se crea y se abre en el IDE. Usted debe ver los siguientes componentes:
La ventana de Proyectos, que contiene una vista en árbol de los componentes del proyecto, incluidos los archivos, las bibliotecas de código que el código depende, y así sucesivamente.
La ventana del editor de código con un archivo llamado HelloWorldApp abierta.
La ventana del navegador, que puede utilizar para navegar rápidamente entre los elementos dentro de la clase seleccionada.
4.
En la página Nombre y ubicación del asistente, haga lo siguiente (como se muestra en la figura siguiente):
En el campo Nombre de proyecto, escriba HelloWorldApp .
Deje la carpeta de uso dedicado para Bibliotecas casilla Almacenar sin seleccionar.
En el campo Clase Create Main, tipo helloworldapp.HelloWorldApp .
Haga clic en Finalizar El proyecto se crea y se abre en el IDE. Usted debe ver los siguientes componentes:
La ventana de Proyectos, que contiene una vista en árbol de los componentes del proyecto, incluidos los archivos, las bibliotecas de código que el código depende, y así sucesivamente.
La ventana del editor de código con un archivo llamado HelloWorldApp abierta.
La ventana del navegador, que puede utilizar para navegar rápidamente entre los elementos dentro de la clase seleccionada.
Agregar código para el archivo de de origen Generado Debido a que usted ha dejado la casilla de verificación Crear clase principal seleccionado en el Asistente para nuevo proyecto, el IDE ha creado una clase esqueleto principal para usted. Usted puede agregar el "Hola Mundo!" mensaje para el código del esqueleto mediante la sustitución de la línea: / / Código TODO aplicación lógica aquí con la línea: System.out.println System.out.pr intln ("Hola Mundo!"); Guarde el cambio, seleccione Archivo> Guardar. El archivo debe ser similar al siguiente ejemplo de código. /* * Para cambiar esta plantilla, seleccione Herramientas Herramientas | Plantillas * Y abra la plantilla en el editor. */ paquete helloworl helloworldapp; dapp; / ** * * @ Author
Compilación y ejecución del programa Debido a compilar el IDE en función Guardar, usted no tiene que compilar manualmente su proyecto con el fin de ejecutar en el IDE. Cuando se guarda un archivo de código fuente Java, el IDE automáticamente se compila. La compilación en función de Ahorro se puede desactivar en la ventana Propiedades del proyecto. Haga clic derecho en el proyecto, seleccione Propiedades. En la ventana Propiedades, seleccione la ficha Compilar. La compilación en casilla de verificación Guardar está justo en la parte superior. Tenga en cuenta que en la ventana de Propiedades del proyecto se pueden configurar varios parámetros para su proyecto: las bibliotecas del proyecto, el embalaje, la construcción, funcionamiento, etc
Para ejecutar el programa programa::
Seleccione Ejecutar> Ejecutar proyecto (F6). La siguiente figura muestra lo que ahora debería ver.
¡Felicitaciones! ¡Felicitacione s! El programa funciona!
Si hay errores de compilación, se marcan con glifos rojos en los márgenes izquierdo y derecho del editor de código. Los glifos en el margen izquierdo indican los errores de las líneas correspondientes. Los glifos en el margen derecho muestra todas las áreas del archivo que tienen errores, incluyendo los errores en las líneas que no son visibles. Puede ratón sobre una marca de error para obtener una descripción del error. Puede hacer clic en un glifo en la margen derecha para saltar a la línea con el error.
Creación e implementación de la aplicación Una vez que usted ha escrito y prueba de f uncionamiento de la aplicación, puede utilizar el comando Clean and Build para generar la aplicación para su despliegue. Cuando se utiliza el comando Clean and Build, el IDE ejecuta un script que realiza las siguientes tareas:
Elimina los archivos previamente compilados y otros productos de generación.
Vuelve a compilar la aplicación y genera un archivo JAR que contiene los archivos compilados.
Para generar la aplicación:
Elija Ejecutar> Limpiar y Build Project (Shift-F11) Usted puede ver las salidas construir abriendo la ventana de archivos y la ampliación de la HelloWorldApp nodo. El bytecode archivo compiladoHelloWorldApp.class está dentro del build /
classes / helloworldapp subnodo. Un archivo JAR que contiene el despliegue HelloWorldApp.classestá dentro del dist nodo.
//////BREAK
Proyecto de instalación La aplicación crea contendrá dos proyectos:
Una clase Java proyecto de biblioteca en el que se va a crear una clase de utilidad.
Un proyecto de aplicación Java con una clase principal que implementa un método de clase de utilidad que el proyecto de la biblioteca. Después de crear los proyectos, agregará el proyecto de biblioteca a la ruta de clase del proyecto de aplicación. A continuación podrá codificar la aplicación. El proyecto de biblioteca contendrá una clase de utilidad con un acróstico método. El acróstico método toma una m atriz de las palabras como un parámetro y luego genera un acróstico sobre la base de esas palabras. El proyecto MyApp contendrá una clase principal que llama a la acróstico método y pasa las palabras que se introducen como argumentos cuando se ejecuta la aplicación.
Nota: Estrictamente hablando, los dos proyectos no son necesarios para una aplicación tan simple. Este tutorial usa dos proyectos de demostración de las características que usted puede ser que necesite para una aplicación más compleja.
Creación de una clase Java Proyecto para bibliotecas 1.
Seleccione Archivo> Nuevo Proyecto (Ctrl + Mayúsculas + N). En Categorías, seleccione Java. En Proyectos, seleccione Biblioteca de Java Class. Haga clic en Siguiente.
2.
En Nombre de proyecto, escriba MyLib . Cambie la ubicación del proyecto en cualquier directorio de tu ordenador. A partir de ahora, este tutorial se refiere a este directorio como NetBeansProjects .
Nota: La ruta especificada anteriormente deberá aparecer la siguiente manera en el campo Carpeta de proyecto del asistente: / NetBeansProjects/ MyLib /
3.
(Opcional) Seleccione la carpeta de uso dedicado para el almacenamiento de Bibliotecas casilla y especifique la ubicación de la carpeta de bibliotecas. Ver Compartiendo Bibliotecas del proyecto para obtener más información sobre esta opción.
4.
Haga clic en Finalizar. El proyecto MyLib abre tanto en la ventana de proyectos y la ventana de archivos.
Crear un proyecto de aplicación Java 1.
Seleccione el menú Archivo> Nuevo proyecto. En Categorías, seleccione Java. En Proyectos, seleccione Aplicación Java. Haga clic en Siguiente.
2.
En Nombre de proyecto, escriba MyApp . Asegúrese de que la ubicación del proyecto se ajusta a NetBeansProjects .
3.
(Opcional) Compruebe la carpeta de uso dedicado para el almacenamiento de casilla Bibliotecas.
4.
Ingrese acrostic.Main como la clase principal.
5. Asegúrese de que la casilla de verificación Create Main Class está marcada. 6.
Haga clic en Finalizar. El proyecto MyApp se muestra en la ventana de proyecto y Main.java se abre en el editor de código.
Configuración de la Compilación Classpath Desde MyApp va a depender de una clase en MyLib, hay que agregar al classpath MyLib de MyApp. Al hacerlo, también se asegura de que las clases en el proyecto MyApp puede hacer referencia a las clases en el proyecto MyLib sin causar errores de compilación. Además, esto le permite usar la implementación del código en el proyecto MyApp para llenar en el código basado en el proyecto MyLib. En el IDE, la ruta de clase se representa visualmente por el nodo Bibliotecas.
Para agregar clases de la biblioteca de utilidad al classpath del proyecto:
1.
En la ventana Proyectos, haga clic en el nodo Bibliotecas para el proyecto MyApp y elija Agregar proyecto, como se muestra en la imagen de abajo.
2.
Busque NetBeansProjects / y seleccione el MyLib carpeta del proyecto. El Proyecto Archivos JAR panel muestra los archivos JAR que se pueden agregar al proyecto. Tenga en cuenta que un archivo JAR para MyLib está en la lista a pesar de que no se han construido aún el archivo JAR. Este archivo JAR se construirá al generar y ejecutar el proyecto MyApp.
3.
Haga clic en Añadir archivos JAR del proyecto.
4.
Expanda el nodo Bibliotecas. El expediente del proyecto de MyLib JAR se añade al proyecto MyApp es classpath.
Creación y edición de código fuente de Java Ahora lo que necesita para crear un paquete Java y agregue el método que va a utilizar para construir el acróstico. Después de que usted necesita para poner en práctica elacróstico en el método principal de la clase.
Creación de un paquete Java y el archivo de clase 1.
Haga clic derecho en el nodo del proyecto MyLib y elija New> Java Class. Tipo LibClass como el nombre de la nueva clase, tipo org.me.mylib en el campo Paquete y haga clic en Finalizar. LibClass.java se abre en el editor de código.
2.
En LibClass.java , coloque el cursor en la línea después de la declaración de clase ( clase
pública {LibClass .
3. 4. 5. 6.
Escriba o pegue el código siguiente método:
acróstico public static String (String [] args) { StringBuffer b = new StringBuffer (); for (int i = 0; i
7.
if (args [i]. length ()> i) {
8.
b.append (args [i] charAt (i).);
9. 10.
} Else { b.append ('?');
11.
}
12.
}
13.
volver b.toString (); }
14. Si el código que pegó en no t iene el formato correcto, presione Alt + Mayúsculas + F para reformatear el archivo completo.
15. Presione Ctrl-S para guardar el archivo.
Edición de un archivo Java Ahora va a añadir algo de código para Main.java . Al hacerlo, verá completado el editor de fuentes de código y plantillas de código (abreviatura) características.
1.
Seleccione la Main.java ficha en el editor de código. Si no está abierto, expandir MyApp> Paquetes> Fuente acróstico en la ventana de proyectos y haga doble clic Main.java .
2.
Elimine el / / Código TODO lógica de la aplicación aquí comentar en el principal método.
3.
En lugar de la observación escriba lo siguiente:
String resultado = Li Deje el cursor inmediatamente después de Li . En el siguiente paso que va a utilizar la finalización de código para activar Li en LibClass .
4.
Presione Ctrl-Space para abrir el cuadro de finalización de código. Una breve lista de posibles formas para completar la palabra aparece. Sin embargo, la clase que usted desea, LibClass no podría estar allí.
5.
Presione Ctrl-Space de nuevo para mostrar una lista más larga de posibles coincidencias.
LibClass debería estar en esta lista.
6.
Seleccione LibClass y pulse Intro. El IDE rellena el resto del nombre de la clase y también crea automáticamente una sentencia import para la clase.
Nota: El IDE también abre un cuadro encima del cuadro de finalización de código que muestra la información de Javadoc para la clase o paquete seleccionado. Dado que no existe información de Javadoc para este paquete, el cuadro muestra el mensaje "No se puede encontrar Javadoc" mensaje.
7.
En el procedimiento principal, escriba un punto (.) Después de LibClass . El cuadro de finalización de código se abre de nuevo.
8.
Seleccione el acróstico (String [] args) método y pulse Intro. El IDE rellena el acróstico método y la pone de relieve la args parámetro.
9.
Pulse Intro para aceptar args como parámetro.
10. Escriba un punto y coma (;). La línea final debe ser similar a la siguiente línea.
String resultado = LibClass.acrostic (args);
11. Pulse Intro para iniciar una nueva línea. A continuación, escriba sout y presione Tab. El sout abreviatura se expande a System.out.println (""); con el cursor posicionado entre las comillas. Tipo Resultado = dentro de las comillas y resultado + después de la comilla final. La línea final debe ser similar a la siguiente línea.
System.out.println ("Resultado =" + resultado);
12. Presione Ctrl-S para guardar el archivo. Nota: sout es una de las muchas plantillas de código que están disponibles en el editor de código. Para buscar y editar la lista de plantillas de código, seleccione Herramientas> Opciones> Editor> Plantilla Código.
Compilar y ejecutar la aplicación Ahora es necesario configurar la clase principal y argumentos de ejecución para que pueda ejecutar el proyecto.
Nota: De forma predeterminada, los proyectos se han creado con la compilación en función Guardar está activado, por lo que no es necesario compilar el código primero para ejecutar la aplicación en el IDE. Para obtener más información sobre la compilación en función Guardar, consulte la sección Guardar en Compilar de laCreación, importación y configuración de Java Proyectos guía.
Configuración de la clase principal y argumentos de ejecución La salida de este programa se basa en los argumentos que le proporcionan al ejecutar el programa. Como argumentos, se le proveerá de cinco palabras, de las cuales el acróstico "Hola" se generarán. El acróstico se ensambla a partir de la primera letra de la primera palabra, la segunda letra de la palabra segunda, la tercera letra de la palabra tercero, y así sucesivamente.
Para agregar los argumentos de la IDE a utilizar al ejecutar la aplicación:
1.
Haga clic derecho en el nodo del proyecto MyApp, elija Propiedades y seleccione el nodo de ejecución en el panel izquierdo del cuadro de diálogo. La clase principal ya debe estar configurado para acrostic.Main .
2.
Tipo Sin embargo todos nos sentimos celosos en el campo Argumentos y haga clic en Aceptar.
Ejecutar la aplicación Ahora que ha creado la aplicación en tiempo de ejecución y aportó argumentos para la aplicación, puede probar ejecutar la aplicación en el IDE.
Para ejecutar la aplicación en el IDE:
1.
Haga clic derecho en el nodo del proyecto MyApp y elija Limpiar y Construir.
2.
Seleccione Ejecutar> Ejecutar proyecto (F6). En la ventana de resultados debe ver la salida del programa, Resultado = Hola (el acróstico de la frase que se ha pasado al programa como un argumento).
Probar y depurar la aplicación Ahora vas a crear y ejecutar una prueba para el proyecto usando JUnit y luego ejecutar la aplicación en el depurador del IDE para comprobar si hay errores. En la prueba de JUnit, que pondrá a prueba la LibClass pasando una frase para el acróstico método y el uso de una afirmación para indicar lo que creo que el resultado debe ser.
Creación de pruebas JUnit 1.
Haga clic con el LibClass.java nodo en la ventana Projects y seleccione Herramientas> Crear pruebas JUnit (Ctrl + Mayúsculas + U). Si esta es la primera vez que se han creado pruebas JUnit en el IDE, se le aparezca el cuadro de diálogo Seleccionar JUnit Version. Pulse Intro para seleccionar 4.x JUnit y continuar con el cuadro de diálogo Crear pruebas.
2.
En el cuadro de diálogo Crear pruebas, haga clic en Aceptar para ejecutar el comando con las opciones por defecto. El IDE crea el org.me.mylib paquete y elLibClassTest.java archivo en una
separado test carpeta. Usted puede encontrar este archivo expandiendo el nodo Paquetes de prueba y elorg.me.mylib subnodo.
3.
En LibClassTest.java , elimine el cuerpo de la testAcrostic public void () método.
4.
En lugar de la eliminada líneas, tipo pasta o en la siguiente:
5. System.err.println ("Ejecución testAcrostic ..."); 6. Resultado Cadena LibClass.acrostic = (new String [] 7.
{"Fnord", "Polly", "tropismo"}); assertEquals ("Valor correcto", "foo", resultado);
8.
Guarde el archivo presionando Ctrl-S.
Ejecución de pruebas JUnit 1.
Seleccione el nodo del proyecto y elija MyLib> Ejecutar proyecto de prueba (MyLib) o pulse Alt-F6. El MyLib
(test) ficha se abre en la ventana de resultados.Los casos de prueba JUnit se compila y ejecuta. El resultado del test JUnit demuestra que la prueba pasa.
2.
También puede ejecutar un archivo de prueba único en lugar de probar el proyecto en su totalidad. Seleccione la LibClass.java ficha en el Source Editor y seleccione Ejecutar> Archivo de prueba.
La documentación JUnit API está disponible desde el IDE. Seleccione Ayuda> Referencias Javadoc> JUnit VersionNumber . Usted puede aprender más sobre JUnit visitando http://www.junit.org
Depurar la aplicación En esta sección, se utiliza el depurador para recorrer la aplicación y ver los valores de las variables cambian como el acróstico está montado.
Para ejecutar la aplicación en el depurador:
1.
En el LibClass.java archivo, vaya al acróstico método y sitúe el punto de inserción en cualquier lugar dentro de b.append (args [i] charAt (i).) . A continuación, pulse Ctrl-F8 para establecer un punto de interrupción.
2.
Seleccione Depurar> Depurar proyecto (Ctrl + F5). El IDE abre las ventanas del depurador y ejecuta el proyecto en el depurador hasta el punto de ruptura se alcanza.
3.
Seleccione la ventana Variables locales en la parte inferior del IDE y ampliar el args nodo. La matriz de cadenas que contiene la frase que escribió como los argumentos del comando.
4.
Presione F7 (o seleccione Depurar> Paso a paso) para pasar por el programa y ver el b cambio variable como el acróstico se construye. Cuando el programa llega al final, cerrar las ventanas del depurador.
Para obtener más información, consulte Escribiendo las pruebas JUnit en el IDE NetBeans .
La construcción, funcionamiento, aplicación y distribución Una vez que esté satisfecho de que su aplicación funciona correctamente, puede preparar la aplicación para la implementación fuera del IDE. En esta sección se basará archivo JAR de la aplicación y, a continuación, ejecute el archivo JAR desde la línea de comandos.
Creación de la aplicación El comando build principal en el IDE es el comando Clean and Build. El comando elimina limpiar y construir previamente compilado clases y otros artefactos construir y luego vuelve a generar el proyecto desde el inicio.
Notas: También hay un comando Build, que no elimina los artefactos antiguos compilación, pero este comando está desactivado por defecto. Consulte la sección Guardar en Compilar de la Creación, importación y configuración de Java Proyectos guía para obtener más información.
Para crear la aplicación:
Elija Ejecutar> Limpiar y Build Project (Shift-F11). La salida del script Ant build aparece en la ventana de resultados. Si la ventana de resultados no aparece, puede abrirlo manualmente seleccionando Ventana> Salida> Salida. Al limpiar y construir su proyecto, se producen las siguientes:
Carpetas de salida que se han generado por las anteriores acciones de compilación se borran ("limpia"). (En la mayoría de los casos, estos son los build ydist carpetas.)
construir y dist carpetas se agregan a la carpeta del proyecto (en lo sucesivo denominado el PROJECT_HOME carpeta). Puede ver estas carpetas en la ventana de archivos.
Todas las fuentes se compilan en clase. archivos, que se colocan en el PROJECT_HOME / build carpeta.
Un archivo JAR que contiene el proyecto se crea en el int erior del PROJECT_HOME / dist carpeta.
Si ha especificado ninguna biblioteca para el proyecto (además de la JDK), un lib carpeta se crea en el dist carpeta. Las bibliotecas se copian en dist / lib .
El archivo de manifiesto en el JAR se actualiza para incluir entradas que designan la clase principal y las bibliotecas que forman parte de classpath del proyecto.
Nota: Puede ver el contenido del m anifiesto en la ventana del IDE Files. Después de haber construido su proyecto, cambiar a la ventana de archivos y vaya a dist / MyApp.jar . Expanda el nodo para el archivo JAR, expanda el META-INF carpeta y haga doble clic en MANIFEST.MF para mostrar el manifiesto en el editor de código.
Main-Class: acrostic.Main Class-Path: lib / MyLib.jar (Para saber más acerca de los archivos de manifiesto, se puede leer este capítulo del Tutorial de Java.)
Ejecución de la aplicación fuera del IDE Para ejecutar la aplicación fuera del IDE:
1.
En su sistema, abra una ventana de línea de comandos o terminal.
2.
En el símbolo del sistema, cambie los directorios a la MyApp / dist del directorio.
3.
En la línea de comandos, escriba el siguiente comunicado:
java-jar MyApp.jar Sin embargo todos nos sentimos celosos La aplicación se ejecuta y devuelve la salida siguiente, como se muestra en la siguiente imagen:
Resultado = Hola
La distribución de la aplicación a otros usuarios Ahora que se ha comprobado que la aplicación funciona fuera del IDE, usted está listo para distribuir la aplicación.
Para distribuir la aplicación:
1.
En su sistema, cree un archivo zip que contiene el archivo JAR aplicación ( MyApp.jar ) y el acompañamiento lib carpeta que contiene MyLib.jar .
2.
Enviar el archivo a las personas que vayan a utilizar la aplicación. Dígales que descomprimir el archivo zip, asegurándose de que el MyApp.jar archivo y el libcarpeta está en la misma carpeta.
3.
Indique a los usuarios a seguir los pasos de la Ejecución de la aplicación fuera del IDE . apartado anterior
Otras tareas comunes Ya ha completado la parte principal del tutorial, pero todavía hay algunas tareas básicas que no han sido cubiertos. Esta sección incluye algunas de esas tareas.
Hacer el Javadoc Disponible en el IDE Para ver la documentación de la API JavaSE en el IDE NetBeans, utilice la Fuente> Documentación comando Show o elija Ventana> Javadoc Otros> en el menú principal para ver la documentación de la API en una ventana separada. Sin embargo, para algunas bibliotecas de terceros, documentación de la API no está disponible. En estos casos, los recursos Javadoc debe ser manualmente asociado con el IDE.
Para hacer la documentación de la API Javadoc disponibles para el comando Mostrar Javadoc:
1.
Descargue la API Javadoc documentación fuente.
2.
Seleccione Herramientas> Bibliotecas hormigas.
3.
En la lista Libraries, seleccione la biblioteca que su p royecto utiliza.
4.
Haga clic en la pestaña Javadoc.
5.
Haga clic en Add ZIP / Folder botón y desplácese hasta el archivo zip o la carpeta que contiene la documentación de la API Javadoc en el sistema. Seleccione el archivo zip o la carpeta y haga clic en Add ZIP / Folder botón.
6.
Haga clic en Cerrar.
Generar Javadoc para un proyecto Puede generar documentación recopilada Javadoc para su proyecto basado en los comentarios Javadoc que se ha agregado a tus clases.
Para generar la documentación Javadoc para un proyecto:
1.
Seleccione el proyecto MyLib.
2.
Elija Ejecutar> Generar Javadoc para "MyLib" en el menú principal del IDE. El Javadoc generado se añade a la dist carpeta del proyecto. Además, el IDE se abre un navegador web que muestra el Javadoc.
Configuración de las propiedades del servidor MySQL NetBeans IDE viene con soporte para el RDBMS MySQL. Antes de poder acceder al servidor de base de datos MySQL en NetBeans IDE, debe configurar las propiedades del servidor MySQL. 1. Haga clic en el nodo Bases de datos en la ventana Servicios y seleccione Registrar servidor MySQL para abrir el servidor MySQL cuadro de diálogo Propiedades.
2. Confirme que el nombre de host del servidor y el puerto sean correctos. Tenga en cuenta que el IDE entra localhost como nombre predeterminado del servidor host y 3306 el número de puerto por defecto del servidor. 3. Introduzca el nombre de usuario del administrador (si no se visualiza). Nota: necesita acceso administrativo para poder crear y eliminar bases de datos. 4. Introduzca la contraseña de administrador. El valor predeterminado es en blanco. Nota: Una contraseña en blanco también puede ser una contraseña. 5. Haga clic en la ficha Propiedades Admin en la parte superior del cuadro de diálogo.
La ficha Propiedades Admin se muestra a continuación, que le permite introducir información para controlar el servidor MySQL. 6. En el archivo. Sendero / URL al campo de administración de herramientas, escriba o vaya a la ubicación de la aplicación de administración de MySQL, como la herramienta de administración de MySQL, PhpMyAdmin, u otras basadas en la Web herramientas de administración Nota: mysqladmin es la herramienta de administración de MySQL se encuentra en el compartimiento de carpetas del directorio de instalación de MySQL.Es una herramienta de línea de comandos y no es ideal para su uso con el IDE. Escriba los argumentos de la herramienta de administración en el campo Argumentos. 7. En el camino para iniciar comandos, escriba o vaya a la ubicación de la orden de inicio de MySQL. Para encontrar el orden de arranque, busque mysqld en el bincarpeta del directorio de instalación de MySQL. Nota: El binario recomendado para Unix y NetWare es mysql_safe . El comando de inicio también puede variar si MySQL se instala como parte de una instalación AMP. Escriba los argumentos para el comando de inicio en el campo Argumentos. 8. En el camino hacia la parada campo de comandos, escriba o vaya a la ubicación de la orden de parada MySQL. Este suele ser el camino a mysqladmin en el bincarpeta del directorio de instalación de MySQL. Si el comando es mysqladmin , en el campo Argumentos, escriba -u root dejar de conceder raíz permisos para detener el servidor. 9. Cuando haya terminado, en la ficha Propiedades de administración debería parecerse a la siguiente figura. Si satified con la configuración, haga clic en Aceptar.
Arrancar el servidor MySQL Antes de conectarse a un servidor de base de datos MySQL, primero debe asegurarse de que el servidor de base de datos MySQL se está ejecutando en su máquina. El nodo MySQL Server en el Servicio indica si el servidor de base de datos MySQL está conectado, como se muestra en la siguiente imagen.
Después de asegurarse de que el servidor de base de datos MySQL se está ejecutando en su máquina, haga clic en las Bases de datos> nodo MySQL Server en la ventana Servicios y seleccione Conectar.
Cuando se expande el nodo MySQL Server muestra todas las bases de datos disponibles en MySQL.
Creación y conexión a la instancia de base Una forma común de interactuar con bases de datos es a través de un editor de SQL. NetBeans IDE tiene un Editor incorporado en SQL para este propósito. El editor de SQL de acceso general a través de la opción Ejecutar comando en el menú contextual del nodo de conexión (o de nodos secundarios del nodo de conexión). Ahora que está conectado al servidor MySQL, puede crear una instancia de base de datos nueva con el Editor de SQL. Para efectos de este tutorial, cree una instancia llamada MyNewDatabase : 1. En la ventana del IDE Servicios, haga clic en el nodo MySQL Server y seleccione Crear base de datos. Crear base de datos MySQL El cuadro de diálogo se abre.
2.
3.
En el cuadro de diálogo Crear base de datos MySQL, escriba el nombre de la nueva base de datos. Usaremos MyNewDatabase para este tutorial. Deje la casilla sin seleccionar en este momento.
Nota: También puede conceder acceso total a un usuario determinado. De forma predeterminada, sólo el administrador dispondrá de los permisos necesarios para realizar ciertos comandos. La lista desplegable le permite asignar estos permisos a un usuario específico. Haga clic en Aceptar. La nueva base de datos aparece en el nodo Servidor MySQL en la ventana Servicios.
Creación de tablas de bases de datos Ahora que se ha conectado a MyNewDatabase , puede comenzar a explorar cómo crear tablas, rellenar con datos, y modificar los datos mantenidos en tablas. Esto le permite tener una mirada más cercana a la funcionalidad ofrecida por el Explorador de bases de datos, así como soporte de NetBeans IDE para los archivos de SQL. MyNewDatabase está actualmente vacía. En el IDE, es posible agregar una tabla de base de datos, ya sea usando el cuadro de diálogo Crear tabla, o mediante la introducción de una consulta SQL y ejecutarlo directamente desde el editor de SQL. Aquí se puede explorar ambos métodos: 1. Uso del editor de SQL 2.
Utilización del diálogo Crear tabla
Uso del editor de SQL 1.
En el Explorador de base de datos, expanda el MyNewDatabase nodo de conexión ( cuenta que hay tres subcarpetas: Tablas, Vistas y Procedimientos.
) y tenga en
2.
Haga clic derecho en la carpeta Tablas y seleccione Ejecutar comando. Un lienzo en blanco se abre en el editor de SQL en la ventana principal.
3.
En el Editor de SQL, escriba la siguiente consulta. Esta es una definición de tabla para el Consejero tabla que está a punto de crear.
4. CREAR Consejero TABLE ( 5. Identificación del SMALLINT NO UNSIGNED NULL AUTO_INCREMENT, 6. 7.
firstName VARCHAR (50), Apodo VARCHAR (50),
8. 9.
lastName VARCHAR (50), teléfono VARCHAR (25),
10.
correo electrónico VARCHAR (50),
11.
memberSince DEFAULT FECHA '0000-00-00 ',
12.
PRIMARY KEY (id) );
Nota: Las consultas se forman en el editor de SQL se analizan en Lenguaje de consulta estructurado (SQL). SQL se adhiere a estrictas reglas de sintaxis que se debe conocer cuando se trabaja en el Editor del IDE. Al ejecutar una consulta, retroalimentación del motor SQL se genera en la ventana de resultados indica si la ejecución fue correcta o no.
13. Para ejecutar la consulta, haga clic en el SQL Run ( ) de la barra de tareas en la parte superior (Ctrl + Mayúsculas + E), o haga clic derecho en el editor de SQL y elija Estado de ejecución. El IDE genera el Consejero de tabla en la base de datos, y recibirá un mensaje similar al siguiente en la ventana de resultados.
14. Para comprobar los cambios, haga clic en el nodo Tablas en el Explorador de base de datos y elija Actualizar. Las actualizaciones de la opción de actualización de base de datos del Explorador de interfaz del componente para el estado actual de la base de datos especificada. Tenga en cuenta que el nuevo Consejero denodo de tabla ( ) muestra ahora en Tablas en el explorador de base de datos. Si expande el nodo de tabla puedes ver las columnas (campos) que ha creado, a partir de la clave principal ( ).
Utilización del diálogo Crear tabla 1.
En el Explorador de base de datos, haga clic en el nodo Tablas y seleccione Crear tabla. El cuadro de diálogo Crear tabla se abre.
2.
En el campo de la tabla de texto Nombre, escriba Asunto .
3.
Haga clic en Agregar columna.
4.
Para el nombre de la columna, introduzca id . Elige SMALLINT para el tipo de datos del tipo de la lista desplegable. Haga clic en Aceptar.
5.
Seleccione la casilla de verificación Clave Primaria en el cuadro de diálogo Agregar columna. Está especificando la clave principal de la tabla. Todas las tablas que se encuentran en bases de datos relacionales debe contener una clave principal. Tenga en cuenta que cuando se selecciona la casilla de verificación de claves, el Índice y cajas únicas de verificación también se selecciona automáticamente y la casilla de verificación Nula no está seleccionada. Esto es porque las claves primarias se utilizan para identificar una única fila en la base de datos, y por la forma predeterminada el índice de la tabla. Debido a que todas las filas deben ser identificados, las claves primarias no puede contener un valor Null.
6.
Repita este procedimiento mediante la adición de las columnas restantes, como se muestra en la tabla siguiente.
Clave
Índice
Nulo
[Consulta] [Consulta]
7.
Único
Nombre de la columna
[Consulta] identificación
Tipo de Tamaño datos SMALLINT 0
[Consulta]
nombre
VARCHAR 50
[Consulta]
descripción
VARCHAR 500
[Consulta]
FK_counselorID
SMALLINT 0
Ustedes están creando una tabla denominada Asunto que contendrá los datos de cada uno de los siguientes registros. Nombre: nombre de la asignatura
Descripción: descripción del objeto
Consejero Identificación: ID consejero que corresponde a un identificador de la tabla Consejero
Asegúrese de que los campos en el cuadro de diálogo Crear tabla coincidir con los presentados anteriormente, a continuación, haga clic en Aceptar. El IDE genera el Asunto tabla en la base de datos, y se puede ver un nuevo Asunto nodo de tabla ( Explorador de base de datos.
) se muestran inmediatamente en Tablas en el
Trabajar con datos de tabla Con el fin de trabajar con los datos de la tabla, puede hacer uso del Editor de SQL de NetBeans IDE. Al ejecutar consultas SQL en una base de datos, puede agregar, modificar y eliminar los datos mantenidos en las estructuras de base de datos. Para agregar un nuevo registro (fila) a la Consejera tabla, haga lo siguiente: 1. Seleccione Ejecutar comandos en la carpeta Tablas en el Explorador de base de datos. Un lienzo en blanco se abre en el editor de SQL en la ventana principal. 2.
En el Editor de SQL, escriba la siguiente consulta.
3. INSERT INTO Consejero VALUES (1, 'Ricky', '"The Dragon" "," Steamboat', '334 612-5678 "," [email protected] ', '1996-01-01')
4.
Para ejecutar la consulta, haga clic derecho en el editor de SQL y elija Estado de ejecución. En la ventana de salida, se puede ver un mensaje que indica que la consulta se ha ejecutado correctamente.
5.
Para verificar que el nuevo registro se ha agregado a la Consejera de mesa, en el Explorador de base de datos, haga clic con el Consejero de nodo de tabla y seleccione Ver datos. Un nuevo panel SQL Editor se abre en la ventana principal. Cuando elija Ver datos, una consulta para seleccionar todos los datos de la tabla se genera automáticamente en la región superior del Editor de SQL. Los resultados de la instrucción se muestran en una vista de tabla en la región inferior. En este ejemplo, el Consejero tabla muestra. Tenga en cuenta que una nueva fila se ha añadido con los datos que acaba suministrados desde la consulta SQL.
Ejecución de una secuencia de comandos SQL Otra forma de gestionar los datos de la tabla en NetBeans IDE es ejecutar una secuencia de comandos SQL externo directamente en el IDE. Si ha creado un script SQL en otra parte, sólo tiene que abrirlo en el IDE Ne tBeans y ejecutarlo en el editor de SQL. Para fines demostrativos, descargar ifpwafcad.sql y guárdelo en un lugar en el equipo. Esta secuencia de comandos crea dos tablas similares a lo que usted acaba de crear por encima ( Consejero y Asunto ), e inmediatamente les rellena con datos. Debido a que la secuencia de comandos sobreescribe las tablas, si ya existen, elimine el consejero y Asunto tablas ahora lo que se hace evidente que las tablas se crean nuevas cuando se ejecuta el script. Para eliminar tablas: 1. Haga clic con el consejero y Asunto nodos de tabla en el Explorador de base de datos y elija Eliminar. 2.
Haga clic en Sí en el cuadro de diálogo Confirmar la eliminación del objeto. Observe que el cuadro de diálogo muestra las tablas que se van a eliminar.
Al hacer clic en Sí en el cuadro de diálogo Confirmar la eliminación de objetos, los nodos de la tabla se elimina automáticamente del Explorador de bases de datos. Para ejecutar la secuencia de comandos SQL en MyNewDatabase : 1. Elija Archivo> Abrir desde el menú principal del IDE. En el explorador de archivos vaya a la ubicación donde guardó previamente ifpwafcad.sql y haga clic en Abrir. La secuencia de comandos se abre automáticamente en el editor de SQL.
2.
Asegúrese de que su conexión a MyNewDatabase se selecciona la conexión de cuadro desplegable en la barra de herramientas en la parte superior del Editor.
3.
Haga clic en el SQL Run ( ) situado en la barra de tareas, el Editor de SQL. El script se ejecuta en la base de datos seleccionada, y cualquier comentario que se genera en la ventana de resultados.
4.
Para comprobar los cambios, haga clic en el MyNewDatabase nodo de conexión en la ventana de tiempo de ejecución y seleccione Actualizar. Las actualizaciones de la opción de actualización de base de datos del Explorador de interfaz del componente para el estado actual de la base de datos especificada. Tenga en cuenta que las dos nuevas tablas a partir de la secuencia de comandos SQL ahora se muestran como nodos de tabla en MyNewDatabase en el Explorador de base de datos.
5.
Seleccione Ver datos en el menú del botón derecho de un nodo de tabla seleccionada para ver los datos contenidos en las tablas nuevas. De esta manera, usted puede comparar los datos de tabla con los datos contenidos en la secuencia de comandos SQL para ver si coinciden.
Ejercicio 1: Crear un proyecto El primer paso es crear un proyecto de IDE para la aplicación que vamos a desarrollar. Vamos a nombrar a nuestro proyecto NumberAddition . 1. Elija Archivo > Nuevo proyecto . Como alternativa, puede hacer clic en el icono New Project en la barra de herramientas IDE. 2.
En el panel Categorías, seleccione el nodo Java. En el panel Proyectos, seleccione Aplicación Java. Haga clic en Siguiente.
3.
Escriba NumberAddition en el campo Nombre de proyecto y especificar una ruta de acceso, por ejemplo, en tu directorio personal, como la ubicación del proyecto.
4.
(Opcional) Seleccione la carpeta de uso dedicado para el almacenamiento de Bibliotecas casilla y especifique la ubicación de la carpeta de bibliotecas. Ve r Compartiendo Bibliotecas del proyecto para obtener más información sobre esta opción.
5.
Desactive la casilla de verificación Crear clase principal, si está activada.
6.
Haga clic en Finalizar.
Ejercicio 2: Construir el Front End Para continuar con la construcción de nuestra interfaz, tenemos que crear un contenedor de Java en el que vamos a colocar los otros componentes requeridos GUI. En este paso vamos a crear un contenedor utilizando el JFrame componente. Vamos a colocar el recipiente en un nuevo paquete, que aparecerá en el nodo Source Packages.
Cree un contenedor JFrame 1.
En la ventana Proyectos, haga clic con el NumberAddition nodo y seleccione Nuevo > Otro .
2.
En el cuadro de diálogo Nuevo archivo, seleccione el Swing GUI Forms categoría y el Formulario JFrame tipo de archivo. Haga clic en Siguiente.
3.
Ingrese NumberAdditionUI como el nombre de la clase.
4.
Introduce my.numberaddition como el paquete.
5.
Haga clic en Finalizar.
El IDE crea el NumberAdditionUI forma y el NumberAdditionUI clase dentro del NumberAddition aplicación, y se abre la NumberAdditionUI forma en el Constructor de GUI. El my.NumberAddition paquete reemplaza el paquete por defecto.
Adición de componentes: Haciendo el Front End A continuación vamos a utilizar la paleta para rellenar parte delantera de nuestra aplicación con un JPanel. A continuación, vamos a añadir tres JLabels, JTextFields tres y t res JButtons. Si usted no ha utilizado el Constructor de GUI antes, usted puede encontrar información en el diseño de una interfaz gráfica de usuario Swing en NetBeans IDE tutorial sobre los componentes de posicionamiento útiles. Una vez que haya terminado de arrastrar y colocar los componentes antes mencionados, el JFrame debería parecerse a la siguiente captura de pantalla.
Si no ve la ventana de la paleta en la esquina superior derecha de la IDE, elija Ventana> Paleta. 1. Para empezar, seleccione un Grupo de la categoría Contenedores Swing en Paleta y suéltelo en el JFrame. 2.
Mientras que el JPanel se pone de relieve, vaya a la ventana Propiedades y haga clic en los puntos suspensivos (...) situado junto a la frontera de elegir un estilo de borde.
3.
En el cuadro de diálogo Borde, seleccione TitledBorder de la lista, y el tipo de adición número en el campo Título. Haga clic en Aceptar para guardar los cambios y salir del cuadro de diálogo.
4.
Ahora debería ver un JFrame vacío titulado que dice Adición número como en la captura de pantalla. Mira la captura de pantalla y añadir tres JLabels, JTextFields tres y tres JButtons como ves arriba.
Cambiar el nombre de los componentes En este paso vamos a cambiar el nombre del texto de la pantalla de los componentes que se acaba de agregar a la JFrame. 1. Haga doble clic en jLabel1 y cambie la propiedad de texto a Primer número
2.
Haga doble clic en jLabel2 y cambiar el texto para Segundo Número
3.
Haga doble clic en jLabel3 y cambiar el texto de Resultado
4.
Elimine el texto de la muestra de jTextField1 . Puede hacer que el texto de la pantalla puede editar haciendo clic derecho en el campo de texto y seleccionando Editar texto en el menú emergente. Puede que tenga que cambiar el tamaño de la jTextField1 a su tamaño original. Repita este paso para jTextField2 y jTextField3 .
5.
Cambie el nombre del texto de la pantalla de jButton1 a Borrar . (Puede editar el texto de un botón, haga clic en el botón y seleccionando Editar texto. O bien, puede hacer clic en el botón de pausa y, a continuación, haga clic de nuevo.)
6.
Cambie el nombre del texto de la pantalla de jButton2 a Añadir .
7.
Cambie el nombre del texto de la pantalla de jButton3 a la salida .
Su acabado GUI debería parecerse a la siguiente captura de pantalla:
Ejercicio 3: Agregar la funcionalidad En este ejercicio vamos a dar funcionalidad a las opciones Agregar, Borrar y botones de Salir. Los jTextField1 y jTextField2 cajas se utiliza para la entrada de usuario y jTextField3 para la salida de programa - lo que estamos creando es una calculadora muy simple. Vamos a comenzar.
Hacer rendir el botón Exit Con el fin de dar a los botones de función, hay que asignar un controlador de eventos para cada uno de responder a eventos. En nuestro caso, queremos saber cuando se pulsa el botón, ya sea por medio del ratón o con el teclado. Así que vamos a utilizar ActionListener responder a ActionEvent. 1. Haga clic en el botón Salir. En el menú emergente elija Eventos> Acción> actionPerformed. Tenga en cuenta que el menú contiene más eventos que puedan responder a! Cuando se selecciona el actionPerformed caso, el IDE añadirá automáticamente un ActionListener al botón Salir y generar un método de control para el manejo de método actionPerformed del oyente. 2.
El IDE se abrirá la ventana de código fuente y vaya a donde se implementa la acción que desea que el botón para hacer cuando se presiona el botón (ya sea por medio del ratón o con el teclado). La ventana de código fuente debe contener las siguientes líneas:
3. private void jButton3ActionPerformed (java.awt.event.ActionEvent evt) { 4.
5.
/ / TODO agregar su código de manejo aquí: }
Ahora vamos a añadir código para lo que queremos en el botón Salir para hacerlo. Reemplace la línea TODO con System.exit (0); . El código terminado botón Exit debería tener este aspecto:
6. private void jButton3ActionPerformed (java.awt.event.ActionEvent evt) { 7. System.exit (0); }
Hacer rendir el botón Clear 1.
Haga clic en la pestaña Diseño en la parte superior de su área de trabajo para volver al diseño de formularios.
2.
Haga clic en el botón Clear ( jButton1 ). A partir de los eventos del menú emergente, seleccione> Acción> actionPerformed.
3.
Vamos a tener el botón Borrar borra todo el texto de las JTextFields. Para ello, se agregará un código como el anterior. Su código fuente terminada debe verse así:
4. private void jButton1ActionPerformed (java.awt.event.ActionEvent evt) { 5. 6.
jTextField1.setText (""); jTextField2.setText ("");
7.
jTextField3.setText (""); }
El código anterior cambia el texto en nuestros tres JTextFields para nada, en esencia, se sobrescribe el texto existente con un espacio en blanco.
Hacer rendir el botón Agregar El botón Agregar, se realizan tres acciones. 1. Va a aceptar la entrada del usuario desde jTextField1 y jTextField2 y convertir la entrada de un tipo String a un flotador. 2.
A continuación, realizar la suma de los dos números.
3.
Y, por último, convertirá la suma a un tipo String y colocarlo en jTextField3 .
Vamos a empezar! 1. Haga clic en la pestaña Diseño en la parte superior de su área de trabajo para volver al diseño de formularios. 2.
Haga clic en el botón Add ( jButton2 ). En el menú desplegable, seleccione Eventos> Acción> actionPerformed.
3.
Vamos a añadir un poco de código para que nuestro trabajo botón Agregar. El código fuente completo se vería así:
4. private void jButton2ActionPerformed (java.awt.event.ActionEvent evt) { 5. 6.
/ / Primero definimos las variables de coma flotante. float num1, num2, resultado;
7.
/ / Tenemos que analizar el texto a un tipo float.
8.
num1 = Float.parseFloat (jTextField1.getText ());
9. 10.
num2 = Float.parseFloat (jTextField2.getText ()); / / Ahora podemos realizar la adición.
11.
resultado = num1 + num2;
12.
/ / Ahora vamos a pasar el valor de resultado a jTextField3.
13. 14.
/ / Al mismo tiempo, vamos a / / Cambiar el valor del resultado de un flotador en una cadena.
15.
jTextField3.setText (String.valueOf (resultado)); }
Nuestro programa se ha completado ahora podemos construir y ejecutarlo para verlo en acción
Ejercicio 4: Ejecución del programa Para ejecutar el programa en el IDE: 1. Seleccione Ejecutar> Ejecutar proyecto principal (alternativamente, pulse F6). Nota: Si recibe una ventana que le informa que NumberAddition proyecto no cuenta con un conjunto de clases principal, entonces usted debe seleccionar my.NumberAddition.NumberAdditionUI como la clase principal en la misma ventana y haga clic en el botón Aceptar.
Para ejecutar el programa fuera del IDE: 1. Elija Ejecutar> Limpiar y Generar proyecto principal (Mayúsculas + F11) para crear el archivo JAR aplicación. 2.
3.
Usando el explorador de archivos del sistema o gestor de archivos, vaya a la NumberAddition / dist del directorio. Nota: La ubicación de la NumberAddition directorio del proyecto depende de la trayectoria que ha especificado al crear el proyecto en el paso 3 del Ejercicio 1: Crear un proyecto de sección. Haga doble clic en el NumberAddition.jar archivo.
Después de unos segundos, la aplicación debe comenzar. Nota: Si al hacer doble clic en el archivo JAR no se ejecuta la aplicación, consulte este artículo para obtener información sobre la configuración de las asociaciones de archivos JAR en el sistema operativo. También puede iniciar la aplicación desde la línea de comandos. Para iniciar la aplicación desde la línea de comandos: 1. En su sistema, abra una ventana de línea de comandos o terminal. 2.
En el símbolo del sistema, cambie los directorios a la NumberAddition / dist del directorio.
3.
En la línea de comandos, escriba el siguiente comunicado: java-jar NumberAddition.jar Nota: Asegúrese de que my.NumberAddition.NumberAdditionUI se configura como la clase
principal antes de ejecutar la aplicación. Usted puede verificar esto haciendo clic derecho en el nodo del proyecto NumberAddition en el panel Proyectos, eligiendo Propiedades en el menú emergente y seleccionar la categoría Ejecutar en el cuadro de diálogo Propiedades del proyecto. El campo Clase principal debería mostrar my.numberaddition.NumberAdditionUI .
Cómo funciona el control de eventos Este tutorial ha mostrado cómo responder a un evento de botón simple. Hay muchos eventos más que usted puede tener su aplicación responda a. El IDE puede ayudar a encontrar la lista de eventos disponibles los componentes de interfaz gráfica de usuario puede manejar: 1. Ir de nuevo al archivo NumberAdditionUI.java en el editor. Haga clic en la pestaña Diseño para ver el diseño de la interfaz gráfica de usuario en el Constructor de GUI. 2.
Haga clic en cualquier componente de la GUI y seleccione Eventos en el menú emergente. Por ahora, sólo navegar por el menú para ver lo que hay, no es necesario realizar ninguna selección.
3.
Como alternativa, puede seleccionar Propiedades en el menú Ventana. En la ventana Propiedades, haga clic en la ficha Eventos. En la ficha Eventos, puede ver y editar controladores de eventos asociados al componente activo actualmente GUI.
4.
Usted puede tener su aplicación responda a pulsaciones de teclas, clics del ratón, individuales, dobles y triples, el movimiento del ratón, el tamaño de la ventana y los cambios de enfoque. Puede generar controladores de eventos para todos ellos en el menú Eventos. El evento más común que se utiliza es un evento de acción.(Aprenda las mejores prácticas para el manejo de eventos de Sun Java Tutorial de eventos .)
¿Cómo es el manejo de eventos de trabajo? Cada vez que se selecciona un evento desde el menú Evento, el IDE crea automáticamente un detector de eventos llamada para usted, y ganchos para arriba para su componente. Siga los pasos siguientes para ver cómo funciona el control de eventos. 1. Ir de nuevo al archivo NumberAdditionUI.java en el editor. Haga clic en la ficha Origen para ver la fuente de la GUI. 2.
Desplácese hacia abajo y observar los métodos jButton1ActionPerformed () , jButton2ActionPerformed () , y jButton3ActionPerformed () que acaba de aplicarse. Estos métodos se denominan controladores de eventos.
3.
Ahora desplácese a un método llamado initComponents () . Si usted no ve este método, busque una línea que dice el código generado , haga clic en el signo + junto a ella para ampliar las colapsadas initComponents () método.
4.
En primer lugar, tenga en cuenta el bloque azul alrededor de los initComponents () método. Este código fue generado automáticamente por el IDE y no se puede editar.
5.
Ahora, navegar a través de los initComponents () método. Entre otras cosas, contiene el código que inicializa y coloca los componentes de interfaz gráfica de usuario en el formulario. Este código se genera y se actualiza automáticamente cuando se coloca y editar componentes en la vista Diseño.
6.
En initComponents () , desplácese hacia abajo hasta donde dice
7. jButton3.setText ("Salir"); 8. jButton3.addActionListener (java.awt.event.ActionListener nuevo () { 9. public void actionPerformed (java.awt.event.ActionEvent evt) { 10. 11.
jButton3ActionPerformed (evt); } });
Este es el lugar donde se agrega un objeto de detector de eventos para el componente de interfaz gráfica de usuario, en este caso, se registra un ActionListener al jButton3 . La interfaz ActionListener tiene un método actionPerformed teniendo objeto ActionEvent que se lleva a cabo mediante una llamada telefónica a su jButton3ActionPerformed controlador de eventos. El botón está escuchando eventos de acción. Cada vez que se presiona un ActionEvent se genera y se pasa al método actionPerformed del oyente que a su vez ejecuta el código que usted proporcionó en el controlador de eventos para este evento. Hablando en general, para ser capaz de responder, cada componente interactivo de interfaz gráfica de usuario tiene que registrarse a un detector de eventos y necesita implementar un controlador de eventos. Como se puede ver, NetBeans IDE se encarga de conectar el detector de eventos para usted, para que pueda concentrarse en la implementación de la lógica de negocio real que debe ser activado por el evento.
Familiarizarse con el Constructor de GUI Ahora que hemos creado un nuevo proyecto para nuestra aplicación, vamos a tomar un minuto para familiarizarnos con la interfaz GUI Builder. Nota: Para explorar la interfaz GUI Builder con una demostración interactiva, vea la Exploración GUI Builder(swf). screencast.
Cuando agregamos el contenedor JFrame, el IDE abrió la recién creada ContactEditorUI forma en una pestaña Editor con una barra de herramientas con varios botones, como se muestra en la ilustración anterior. La forma ContactEditor abre en la vista Diseño de la GUI Builder y tres ventanas adicionales apareció automáticamente a lo largo de los bordes del IDE, lo que le permite navegar, organizar y editar formularios GUI como construirlos.
Varias ventanas del Constructor de GUI son: Área de Diseño. ventana principal de la GUI Builder para crear y editar formas Java GUI. Botón de la barra de herramientas Fuente le permite ver el código fuente de una clase, el botón Diseño le permite ver una vista gráfica de los componentes GUI, el botón Historia permite al usuario tener acceso a la historia local de los cambios del archivo. Los botones de la barra de herramientas adicionales proporcionan un cómodo acceso a los comandos comunes, como elegir entre la selección y los modos de conexión, alineación de los componentes, el establecimiento de componente auto-cambio de tamaño de la conducta, y vista previa de las formas. Navigator. Proporciona una representación de todos los componentes, tanto visuales y no visuales, en su aplicación como una jerarquía de árbol. El navegador también proporciona información visual acerca de qué componente en el árbol se está editando en el Constructor de GUI, así como le permite organizar los componentes de los paneles disponibles. Paleta. Aparecerá una lista personalizable de componentes disponibles que contienen las fichas de JFC / Swing, AWT y los componentes JavaBeans, así como los administradores de diseño. Además, puede crear, eliminar y reordenar las categorías que se muestran en la paleta utilizando el personalizador. Ventana de propiedades. Muestra las propiedades del componente seleccionado en el Constructor de GUI, ventana de Navigator, ventana o la ventana Proyectos, Archivos. Si hace clic en el botón Fuente, el IDE muestra el código de la aplicación Java de código en el Editor de secciones de código que se generan automáticamente por el Constructor de GUI indicado por áreas grises (que se conviertan en azul cuando se selecciona), llamados bloques vigilado. Bloques vigilado son áreas protegidas que no se pueden editar en la vista Código fuente. Sólo puede editar el código que aparece en las áreas blancas del editor cuando en la vista Código fuente. Si necesita realizar cambios en el código dentro de un bloque de guardado, haga clic en el botón Diseño devuelve Editor del IDE para el Constructor de GUI donde se pueden hacer los ajustes necesarios en el formulario. Al guardar los cambios, el IDE actualiza las fuentes del archivo. Nota: Para los desarrolladores avanzados, el Administrador de paletas está disponible que le permite agregar componentes personalizados de JAR, bibliotecas, u otros proyectos a la paleta. Para agregar componentes personalizados a través del Administrador de paletas, seleccione Herramientas> Paleta> Swing / AWT Componentes.
Conceptos clave El IDE GUI Builder resuelve el problema central de Java GUI creación mediante la racionalización del flujo de trabajo de creación de interfaces gráficas, liberando a los desarrolladores de las complejidades de los administradores de diseño Swing. Lo hace mediante la ampliación de la actual IDE NetBeans GUI Builder para apoyar un sencillo "Diseño Libre" paradigma de las normas de diseño simples que son fáciles de entender y utilizar. Al diseñar el formulario, el Constructor de GUI proporciona pautas visuales que sugieren espaciamiento óptimo y la alineación de los componentes. En el fondo, el Constructor de GUI traduce sus decisiones de diseño en una interfaz de usuario funcional que se lleva a cabo usando el gestor de GroupLayout nuevo diseño y otras construcciones Swing. Debido a que utiliza un modelo de diseño dinámico, GUI está construido con el Constructor de GUI se comportan como es de esperar en tiempo de ejecución, el ajuste para adaptarse a los cambios que realice sin alterar las relaciones definidas entre los componentes. Cada vez que se cambia el tamaño del formulario, locales de conmutación, o especificar un aspecto diferente, su interfaz gráfica de usuario se ajusta automáticamente a respetar el aspecto objetivo y las inserciones tacto y compensaciones.
Diseño Gratis En el IDE GUI Builder, puede crear sus formularios con sólo poner los componentes donde quieras como si estuviera usando la posición absoluta. Las cifras GUI Builder qué atributos de diseño son necesarios y genera el código de forma automática. Usted no tiene que preocuparse por las inserciones, anclajes, rellenos, etc.
Colocación automática de componentes (de resorte) A medida que añada componentes a un formulario, el Constructor de GUI proporciona retroalimentación visual que ayuda a los componentes de posicionamiento basado en la apariencia de tu sistema operativo y se siente. El Constructor de GUI proporciona consejos útiles en línea y otra retroalimentación visual en cuanto a que los componentes deben ser colocados en el formulario, automáticamente chasqueando los componentes en su posición a lo largo de guías. Se hace que estas sugerencias basadas en las posiciones de los componentes que ya han sido
colocados en la forma, mientras que permite el acolchado a permanecer flexible tal que la mirada de destino diferente y se siente representar correctamente en tiempo de ejecución.
Indicadores Visuales
El Constructor de GUI también proporciona información visual acerca componente de anclaje y las relaciones de encadenamiento. Estos indicadores le permiten identificar rápidamente las relaciones y el comportamiento de posicionamiento distintos componentes fijando que afectan a la forma en que su GUI ambos parecen y se comportan en tiempo de ejecución. Esto acelera el proceso de diseño de interfaz gráfica de usuario, que le permite crear de aspecto profesional rápidamente interfaces visuales que funcionan. Ahora que se ha familiarizado con la interfaz del constructor de GUI, es el momento para comenzar a desarrollar la interfaz de usuario de nuestra aplicación ContactEditor. En esta sección vamos a echar un vistazo al uso de la paleta del IDE para agregar los distintos componentes GUI que necesitamos de nuestro formulario. Gracias al paradigma de diseño libre del IDE, ya no tienen que luchar con los controladores de distribución para controlar el tamaño y la posición de los componentes dentro de sus contenedores. Todo lo que tienes que hacer es arrastrar y soltar los componentes que necesita para su forma GUI como se muestra en las ilustraciones siguientes. Nota: Consulte la adición de componentes individuales y múltiples (swf). screencast para una demostración interactiva en la siguiente sección.
Adición de componentes: Los Fundamentos Aunque la GUI IDE Builder simplifica el proceso de creación de interfaces Java, a menudo es útil para delinear la forma en que desea que su interfaz de mirar antes de comenzar a diseñar. Muchos diseñadores de interfaz de considerar esto como una "mejor práctica" técnica, sin embargo, para los propósitos de este tutorial puede simplemente mirar cómo nuestro formulario completado debe mirar al saltar por delante a la vista previa de su GUI sección. Dado que ya hemos añadido un JFrame como contenedor de alto nivel nuestro formulario, el siguiente paso es agregar un par de JPanels que nos permitirá agrupar los componentes de nuestra interfaz de usuario mediante fronteras titulados. Consulte las siguientes ilustraciones y observe el IDE de "arrastrar y soltar" comportamiento cuando lograr esto.
Para agregar un JPanel: 1.
En la ventana de la paleta, seleccione el componente panel de la categoría Contenedores Swing pulsando y soltando el botón del ratón.
2.
Mueva el cursor a la esquina superior izquierda del formulario en el Constructor de GUI. Cuando el componente está situado cerca de los bordes superior e izquierdo del contenedor, las guías de alineación horizontal y vertical aparecen indicando los márgenes preferidos. Haga clic en el formulario para colocar el JPanel en esta ubicación.
El JPanel componente aparece en la ContactEditorUI forma con resaltado de color naranja indica que está seleccionado.Después de soltar el botón del ratón, pequeños indicadores parecen mostrar las relaciones de anclaje del componente y un nodo JPanel correspondiente se muestra en la ventana del navegador, como se muestra en la siguiente ilustración.
A continuación, tenemos que cambiar el tamaño del JPanel para hacer espacio para los componentes que vamos a colocar en su interior un poco más tarde, pero vamos a tomar un momento para señalar otro de la visualización de la GUI Builder cuenta con primero. Para ello, se requiere para anular la selección JPanel que acaba de agregar. Porque no hemos añadido una frontera título, sin embargo, el panel desaparece. Nótese, sin embargo, que cuando se pasa el cursor sobre el JPanel, sus bordes cambiar a gris claro para que su posición se puede ver claramente. Sólo t iene que hacer clic en cualquier lugar dentro del componente a seleccionarla y hacer que las manijas de cambio de tamaño y los indicadores de anclaje a reaparecer.
Para cambiar el tamaño del JPanel: 1. Seleccione el JPanel que acaba de agregar. El cambio de tamaño pequeño cuadrado maneja reaparecer alrededor del perímetro del componente. 2.
Haga clic y mantenga el controlador de tamaño en el borde derecho de la JPanel y arrastre hasta que la guía de alineación de puntos aparece cerca del borde del formulario.
3.
Suelte el controlador de tamaño para cambiar el tamaño del componente.
El JPanel componente se extiende a extenderse entre los márgenes izquierdo y derecho del contenedor de acuerdo con el desplazamiento recomendado, como se muestra en la ilustración siguiente.
Ahora que hemos añadido un panel para contener la información de nuestros interfaz de usuario de nombre, hay que repetir el proceso para agregar otro directamente debajo de la primera por la información por e-mail. En referencia a las ilustraciones siguientes, repita los últimos dos tareas, prestando especial atención a la colocación sugirió el constructor GUI. Observe que el espaciamiento sugerido vertical entre las dos JPanels es mucho más estrecho que en los bordes. Una vez que haya agregado el JPanel en segundo lugar, cambiar su tamaño tal que ocupe todo el espacio restante de forma vertical.
Porque queremos distinguir visualmente las funciones en las secciones superior e inferior de nuestra GUI, necesitamos agregar un borde y un t ítulo a cada JPanel. En primer lugar vamos a lograr esto mediante la ventana Propiedades y, a continuación, vamos a tratar de usar el menú pop-up. Para agregar bordes título a la JPanels: 1. Seleccione el JPanel superior en el Constructor de GUI. 2.
En la ventana Propiedades, haga clic en el botón de puntos suspensivos (...) junto a la propiedad Border.
3.
En el editor Border JPanel que aparece, seleccione el nodo TitledBorder en el panel Bordes disponibles.
4.
En el panel Propiedades abajo, introduzca Nombre de la propiedad Title.
5.
Haga clic en los puntos suspensivos (...) junto a la propiedad de fuente, seleccione Negrita para el tipo de fuente y escriba 12 para el tamaño. Haga clic en Aceptar para salir de los cuadros de diálogo.
6.
Seleccione el JPanel inferior y repita los pasos 2 a 5, pero esta vez haga clic con el JPanel y acceder a la ventana Propiedades con el menú pop-up. Introduzca E-mail para la propiedad Título.
Titulado fronteras se añaden a ambos JPanel componentes.
Adición de componentes individuales al Formulario Ahora tenemos que empezar a añadir los componentes que se recogen los datos de contacto real en nuestra lista de contactos. En esta tarea vamos a añadir cuatro JTextFields que se mostrará la información de contacto y las JLabels que los describen. Si bien lograr esto, observe las directrices horizontales y verticales que las pantallas GUI Builder, lo que sugiere la separación componente preferido según lo definido por el aspecto de su sistema operativo y se siente. Esto asegura que su interfaz gráfica de usuario es automáticamente generado respetando el aspecto del sistema operativo de destino y se sientan como en tiempo de ejecución. Para agregar un JLabel al formulario: 1. En la ventana de la paleta, seleccione el componente Label de la categoría oscilación Controls. 2.
Mueva el cursor sobre el nombre JPanel que agregó anteriormente. Cuando las directrices parecen indicar que el JLabel se coloca en la esquina superior izquierda de la JPanel con un pequeño margen en los bordes superior e izquierdo, haga clic para colocar la etiqueta.
El JLabel se añade a la forma y un nodo correspondiente que representa el componente se añade a la ventana de inspección Antes de seguir adelante, tenemos que editar el texto de la pantalla de la JLabel que acaba de agregar. Aunque usted puede editar el texto de componente de visualización en cualquier momento, lo más fácil es hacerlo lo más que se agregan. Para editar el texto de la pantalla de un JLabel: 1. Haga doble clic en el JLabel para seleccionar el texto de la pantalla. 2.
Tipo de nombre: y pulse Intro.
El nuevo nombre del JLabel y también se muestra la anchura del componente ajusta como resultado de la edición. Ahora vamos a añadir un JTextField para que podamos obtener una visión de la función del Constructor de GUI de referencia de alineación.
Para agregar un JTextField al formulario: 1. En la ventana de la paleta, seleccione el campo de texto de la categoría oscilación Controls. 2.
Mueva el cursor inmediatamente a la derecha del nombre: JLabel que acaba de agregar. Cuando la guía horizontal que indica que la línea de base JTextField está alineada con la de la JLabel y el espaciamiento entre los dos componentes se sugiere con una guía vertical, haga clic para colocar el JTextField.
El JTextField encaje en su posición en forma alineada con la línea de base JLabel, como se muestra en la siguiente ilustración.Observe que el JLabel desplazado ligeramente hacia abajo con el fin de alinearse con el campo de texto de referencia más alto de.Como es habitual, un nodo que representa el componente se añade a la ventana del navegador.
Antes de seguir adelante, tenemos que agregar un adicional de JLabel y JTextField inmediatamente a la derecha de los que acaba de agregar, como se muestra en la siguiente ilustración. Esta vez entrar Apellido: como el texto de la pantalla JLabel y dejar el texto de los JTextFields "marcador de posición, ya que es por ahora
Para cambiar el tamaño de un JTextField: 1. Seleccione el JTextField que acaba de agregar a la derecha de la Apellido: JLabel. 2.
Arrastre el JTextField la manija derecha redimensionar borde hacia el borde derecho de la JPanel contiene.
3.
Cuando las guías de alineación vertical parecen sugerir que el margen entre el campo de texto y el borde derecho de la JPanel, suelte el botón del ratón para cambiar el ta maño del JTextField.
El borde derecho del JTextField encaje en su alineación con el margen del borde JPanel recomendado, como se muestra en la siguiente ilustración.
Adición de componentes múltiples para la Forma Ahora vamos a añadir el Título y Apodo: JLabels que describen dos JTextFields que vamos a añadir en un minuto. Vamos a arrastrar y soltar los componentes mientras presiona la tecla Shift, de forma rápida añadirlos al formulario. Si bien lograr esto, una vez más cuenta de que el Constructor de GUI muestra directrices horizontales y verticales que sugieren la separación componente preferido. Para agregar múltiples JLabels al formulario: 1. En la ventana de la paleta, seleccione el componente Label de la categoría oscilación controles haciendo clic y soltando el botón del ratón. 2.
Mueva el cursor sobre la forma justo debajo del nombre: JLabel que agregó anteriormente. Cuando las directrices parecen indicar que el borde izquierdo del JLabel nuevo está alineada con la de la anterior JLabel y un pequeño margen que existe entre ellos, shift-clic para colocar el JLabel primero.
3.
Mientras sigue presionando la tecla Shift, coloque otra JLabel inmediatamente a la derecha de la primera. Asegúrese de liberar la tecla Shift antes de colocar el segundo JLabel. Si se olvida de soltar la tecla Shift antes de colocar el JLabel pasado, simplemente pulse la tecla Escape.
Los JLabels se añaden a la forma de la creación de una segunda fila, como se muestra en la ilustración siguiente. Nodos que representan cada componente se añaden a la ventana del navegador.
Antes de continuar, tenemos que editar el nombre de los JLabels 'así que vamos a ser capaces de ver el efecto de las alineaciones vamos a establecer más adelante. Para editar el texto de la pantalla de JLabels: 1. Haga doble clic en el JLabel primero para seleccionar el texto de la pantalla. 2.
Tipo de Título: y pulse Intro.
3.
Repita los pasos 1 y 2, entrando Apodo: Nombre de la propiedad de la segunda JLabel.
Los nombres de los "nuevos JLabels se muestran en la forma y se desplazan como consecuencia de sus anchos editados, como se muestra en la siguiente ilustración
Inserción de componentes A menudo es necesario añadir un componente de entre los componentes que ya están colocados en un formulario. Cada vez que se agrega un componente entre dos componentes existentes, el Constructor de GUI desplaza automáticamente para hacer espacio para el nuevo componente. Para demostrar esto, vamos a insertar un JTextField entre los JLabels que añadimos anteriormente, como se muestra en las siguientes ilustraciones. Para insertar un JTextField entre dos JLabels: 1. En la ventana de la paleta, seleccione el campo de texto de la categoría oscilación Controls. 2.
Mueva el cursor sobre el Título y Apodo: JLabels en la segunda fila de tal manera que los solapamientos tanto JTextField y se ajuste a sus líneas de base. Si tiene problemas posicionando el nuevo campo de texto, se puede ajustar a la izquierda de la directrizApodo JLabel como se muestra en la primera imagen de abajo.
3.
Haga clic para colocar el JTextField entre el Título y Apodo: JLabels.
El JTextField encaje en su posición entre los dos JLabels. Los cambios más a la derecha JLabel hacia la derecha de la JTextField para dar cabida a la horizontal sugirió offset.
Todavía tenemos que añadir un JTextField adicional a la forma en que se mostrará apodo de cada contacto en el lado derecho del formulario Para agregar un JTextField: 1. En la ventana de la paleta, seleccione el campo de texto de la categoría de Swing. 2.
Mueva el cursor a la derecha del Apodo etiqueta y haga clic para colocar el campo de texto.
El JTextField encaje en su lugar al lado de la JLabel a su izquierda . Para cambiar el tamaño de un JTextField: 1. Arrastre los controladores de tamaño de la Apodo: JTextField etiqueta que agregó en la tarea anterior hacia la derecha de la JPanel contiene. 2.
Cuando las guías de alineación vertical parecen sugerir que el margen entre el campo de texto y los bordes JPanel, suelte el botón del ratón para cambiar el tamaño del JTextField.
El borde derecho del JTextField encaje en su alineación con el margen del borde JPanel recomendado y el Constructor de GUI deduce el comportamiento de cambio de tamaño apropiado. Presione Ctrl-S para guardar el archivo.
Moving Forward La alineación es uno de los aspectos más fundamentales de la creación de aspecto profesional GUIs. En la sección anterior se tiene una visión de las características de alineación del IDE al tiempo que añade el JLabel y JTextField componentes a nuestro formulario ContactEditorUI. A continuación, vamos a echar un análisis más en profundidad a las características de alineación de la GUI Builder como trabajamos con los otros diversos componentes que necesitamos para nuestra aplicación.
Alineación de componentes Nota: Consulte los componentes Alineación y anclaje (swf). screencast para una demostración interactiva en las siguientes secciones. Cada vez que se añade un componente a un formulario, el Constructor de GUI se alinea de manera eficaz, como lo demuestran las guías de alineación que aparecen. A veces es necesario, sin embargo, para especificar diferentes relaciones entre grupos de componentes así. Anteriormente hemos añadido cuatro JLabels que necesitamos para nuestro ContactEditor GUI, pero no los alinean. Ahora vamos a alinear las dos columnas de JLabels para que su línea bordes hacia arriba.
Para alinear componentes: 1. Mantenga presionada la tecla Ctrl y haga clic en la tecla para seleccionar el nombre: y Título: JLabels en el lado izquierdo de la forma. 2.
Haga clic en el botón Alinear a la derecha en la columna ( ) en la barra de herramientas. Como alternativa, puede hacer clic en cualquiera de ellas y seleccione Alinear> Derecha en la Columna en el menú emergente.
3.
Repita esto para el apellido: e Apodo: JLabels también.
Las posiciones de los JLabels 'cambiar de tal manera que los bordes derecho de su pantalla de texto están alineados. Las relaciones de anclaje se actualizan, lo que indica que los componentes han sido agrupados. Antes de que terminemos con las JTextFields hemos añadido antes, tenemos que asegurarnos de que los dos JTextFields se insertan entre las JLabels se establecen para redimensionar correctamente. A diferencia de los dos JTextFields que se extendían hasta el borde derecho de nuestro formulario, insertar componentes 'resizeability comportamiento no se ajusta automáticamente. Para establecer el comportamiento de los componentes resizeability: 1.
Control-clic en las dos insertan componentes JTextField para seleccionarlos en el Constructor de GUI.
2.
Con ambos JTextFields seleccionado, haga clic en uno de ellos y elegir Cambiar el tamaño del automóvil> Horizontal en el menú emergente.
Los JTextFields se establecen para redimensionar horizontalmente en tiempo de ejecución. Las guías de alineación y los indicadores de anclaje se actualizan, proporcionando retroalimentación visual de las relaciones de los componentes. Para configurar los componentes a ser del mismo tamaño: 1. Control-clic en las cuatro JTextFields en forma de seleccionarlos. 2.
Con los JTextFields seleccionado, haga clic en cualquiera de ellos y elija Tamaño Configurar Mismo> Mismo ancho en el menú emergente.
Los JTextFields están configurados con la misma anchura y los indicadores se añaden al borde superior de cada uno, proporcionando retroalimentación visual de las relaciones de los componentes. Ahora tenemos que añadir otro JLabel JComboBox que describe el que permitirá a los usuarios seleccionar el formato de la información de nuestra aplicación ContactEditor que aparezca publicado. Para alinear un JLabel para un grupo de componentes: 1. En la ventana de la paleta, seleccione el componente Label de la categoría de Swing. 2.
Mueva el cursor debajo del Nombre y Título JLabels en el lado izquierdo de la JPanel. Cuando la directriz que indica que el borde derecho del JLabel nuevo está alineada con los bordes derechos del grupo componente anterior (los dos JLabels), haga clic para colocar el componente.
El JLabel encaje en una posición alineada a la derecha con la columna de JLabels arriba, como se muestra en la ilustración siguiente.El Constructor de GUI actualiza las líneas de estado de alineación que indican separación del componente y las relaciones de anclaje.
Como en los ejemplos anteriores, haga doble clic en el JLabel para seleccionar su texto de la pantalla e introduzca Formato de pantalla: para el nombre para mostrar. Tenga en cuenta que cuando el JLabel encaje en su posición, los otros componentes cambian para adaptarse a la pantalla de texto más larga.
Línea de base de alineación Siempre que agregue o mover componentes que incluyen texto (JLabels, JTextFields, etc), el IDE sugiere alineaciones que se basan en las líneas de base del t exto de los componentes. Cuando se inserta el JTextField anteriormente, por ejemplo, su nivel de referencia se alinea automáticamente a los JLabels adyacentes.
Ahora vamos a añadir el menú desplegable que permitirá a los usuarios seleccionar el formato de la información que nuestra aplicación ContactEditor que aparezca publicado. Al añadir el JComboBox, vamos a alinear su línea de base para que el texto de la JLabel. Note una vez más las directrices de alineación de referencia que aparecen para que nos ayuden con el posicionamiento. Para alinear las líneas de base de los componentes: 1. En la ventana de la paleta, seleccione el componente Cuadro combinado de la categoría oscilación Controls. 2.
Mueva el cursor inmediatamente a la derecha del JLabel que acaba de agregar. Cuando la directriz horizontal que indica que la línea de base JComboBox está alineada con la línea de base del texto del JLabel, la separación entre los dos componentes se sugiere con una línea guía vertical, haga clic para colocar el cuadro combinado.
El componente de encaje en una posición alineada con la línea de base del texto en la JLabel a su izquierda, como se muestra en la ilustración siguiente. El Constructor de GUI muestra las líneas de estado que indica separación del componente y las relaciones de anclaje.
Para cambiar el tamaño del JComboBox: 1. Seleccione el cuadro combinado en el Constructor de GUI. 2.
3.
Arrastre el controlador de tamaño en el borde derecho del JComboBox hacia la derecha hasta que las guías de alineación aparecen sugiriendo la desviación preferente entre el JComboBox y bordes JPanel. Como se muestra en la siguiente ilustración, el borde derecho del JComboBox de encaje en su alineación con el margen del borde JPanel recomendada y ancho del componente se ajusta automáticamente al cambiar el tamaño de la forma. Presione Ctrl-S para guardar el archivo
Edición de modelos de componentes está más allá del alcance de este tutorial, así que por el momento dejaremos de JComboBox la lista de marcador de posición objeto tal como es
Cómo agregar, alinear y anclaje El Constructor de GUI le permite diseñar sus formularios de forma rápida y sencilla mediante la racionalización de los gestos típicos de flujo de trabajo. Cada vez que se agrega un componente a un formulario, el Constructor de GUI automáticamente encaje en las posiciones preferidas y establece las relaciones de encadenamiento necesarios para que pueda concentrarse en el diseño de sus formularios en lugar de luchar con los detalles de implementación complicadas. Para agregar, alinear y editar el texto de la pantalla de un JLabel: 1. En la ventana de la paleta, seleccione el componente Label de la categoría oscilación Controls. 2.
Mueva el cursor sobre la forma inmediatamente por debajo de E-mail el título de la parte inferior de JPanel. Cuando las directrices parecen indicar que está colocado en la esquina superior izquierda de la JPanel con un pequeño margen en los bordes superior e izquierdo, haga clic para colocar el JLabel.
3.
Haga doble clic en el JLabel para seleccionar el texto de la pantalla. A continuación, escriba un e-mail: y pulse Intro.
El JLabel encaje en la posición preferida en la forma, anclado en los bordes superior e izquierdo de la JPanel contiene. Al igual que antes, un nodo correspondiente que representa el componente se añade a la ventana del navegador.
