Manual de Netbeans
37
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.
-
Upload
eiko-sanchez-rodriguez -
Category
Documents
-
view
216 -
download
13
Transcript of Manual de Netbeans
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.
Agregar código para el archivo 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 ("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 | Plantillas
* Y abra la plantilla en el editor.
* /
paquete helloworldapp;
/ **
*
* @ Author <nombre
* /
público HelloWorldApp clase {
/ **
* @ Param args los argumentos de línea de comandos
* /
public static void main (String [] args) {
System.out.println ("Hola Mundo!");
}
}
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:
Seleccione Ejecutar> Ejecutar proyecto (F6).
La siguiente figura muestra lo que ahora debería ver.
¡Felicitaciones! 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 funcionamiento 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 matriz 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 bibliotecas1. 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. VerCompartiendo 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 Java1. 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 ClasspathDesde 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 clase1. 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. Escriba o pegue el código siguiente método:
4. acróstico public static String (String [] args) {
5. StringBuffer b = new StringBuffer ();
6. for (int i = 0; i <args.length, i + +) {
7. if (args [i]. length ()> i) {
8. b.append (args [i] charAt (i).);
9. } Else {
10. b.append ('?');
11. }
12. }
13. volver b.toString ();
}
14. Si el código que pegó en no tiene 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 JavaAhora 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ónAhora 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ónLa 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ónAhora 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ónAhora 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 JUnit1. 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 JUnit1. 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ónEn 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ónEl 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 interior 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 manifiesto 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 IDEPara 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 usuariosAhora 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 IDEPara 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 proyecto 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 proyectoPuede 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 llamadaMyNewDatabase :
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. 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.
3. 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 SQL1. En el Explorador de base de datos, expanda el MyNewDatabase nodo de conexión ( ) y tenga en
cuenta que hay tres subcarpetas: Tablas, Vistas y Procedimientos.
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. firstName VARCHAR (50),
7. Apodo VARCHAR (50),
8. lastName VARCHAR (50),
9. 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 tabla1. 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 ÚnicoNombre de la
columnaTipo de datos
Tamaño
[Consulta] [Consulta] [Consulta] identificación SMALLINT 0
[Consulta] nombre VARCHAR 50
[Consulta] descripción VARCHAR 500
[Consulta] FK_counselorID SMALLINT 0
7. 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 ( ) se muestran inmediatamente en Tablas en el
Explorador de base de datos.
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 NetBeans 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 proyectoEl 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. VerCompartiendo 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 EndPara 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 JFrame1. 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 EndA 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 tres 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 componentesEn 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
parajTextField2 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 funcionalidadEn 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 ExitCon 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. / / TODO agregar su código de manejo aquí:
}
5. 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 Clear1. 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. jTextField1.setText ("");
6. 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 AgregarEl 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. / / Primero definimos las variables de coma flotante.
6. float num1, num2, resultado;
7. / / Tenemos que analizar el texto a un tipo float.
8. num1 = Float.parseFloat (jTextField1.getText ());
9. num2 = Float.parseFloat (jTextField2.getText ());
10. / / Ahora podemos realizar la adición.
11. resultado = num1 + num2;
12. / / Ahora vamos a pasar el valor de resultado a jTextField3.
13. / / Al mismo tiempo, vamos a
14. / / 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 programaPara 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 seleccionarmy.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. 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.
3. 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
mostrarmy.numberaddition.NumberAdditionUI .
Cómo funciona el control de eventosEste 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. jButton3ActionPerformed (evt);
11. }
});
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 aljButton3 . La interfaz ActionListener tiene un
método actionPerformed teniendo objeto ActionEvent que se lleva a cabo mediante una llamada telefónica a
sujButton3ActionPerformed 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 GUIAhora 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 claveEl 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 GratisEn 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 VisualesEl 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 FundamentosAunque 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 tiene 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 FormularioAhora 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 tamañ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 FormaAhora 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 componentesA 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 componentesNota: 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ónSiempre 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 texto 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. 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.
3. 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 anclajeEl 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.
Para agregar un JTextField: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 de la dirección de e-mail etiqueta que acaba de agregar. Cuando aparecen las directrices que indica que la línea de base JTextField está alineada con la línea de base del texto en la JLabel y el margen entre los dos componentes se sugiere con una guía vertical, haga clic para situar el campo de texto.
El JTextField encaje en su lugar a la derecha de la dirección de e-mail: JLabel y se encadena a la JLabel. Su nodo correspondiente también se agrega a la ventana Inspector.
3. Arrastre el controlador de tamaño de la JTextField hacia la derecha de la JPanel encierra hasta que las guías de alineación aparecen sugiere el desplazamiento entre el JTextField JPanel y bordes.
El borde derecho JTextField de ajuste a la línea que indica la alineación de los márgenes preferenciales. Ahora tenemos que añadir el JList que mostrará nuestra lista ContactEditor de contacto completa
Para agregar y cambiar el tamaño de un JList:
1. En la ventana de la paleta, seleccione el componente de lista de la categoría oscilación Controls.
2. Mueva el cursor inmediatamente por debajo de la dirección de e-mail JLabel que agregó anteriormente. Cuando las directrices indicando que el JList los bordes superior e izquierdo se alinean con los márgenes preferidos a lo largo del borde izquierdo de la JPanel y el JLabel arriba, haga clic para colocar el JList.
3. Arrastre el controlador de tamaño JList de la derecha hacia la derecha de la JPanel encierra hasta que las guías de alineación aparecen indicando que se trata de la misma anchura que el JTextField arriba.
El JList encaje en la posición designada por las guías de alineación y su nodo correspondiente se muestra en la ventana Inspector.Note también que la forma se amplía para dar cabida a la JList recién agregado.
Desde JLists se utilizan para mostrar largas listas de datos, por lo general requieren la adición de un JScrollPane. Cada
vez que se añade un componente que requiere un JScrollPane, el Constructor de GUI lo agrega automáticamente para
usted. Porque JScrollPanes son componentes no visuales, usted tiene que utilizar la ventana de información con el fin
de ver o editar cualquier JScrollPanes que el Constructor de GUI creado.
Componente de tallasA menudo es útil crear varios componentes relacionados, tales como botones en los diálogos modales, para tener el
mismo tamaño para mantener la coherencia visual. Para demostrar esto vamos a añadir cuatro JButtons a nuestro
formulario ContactEditor que nos permitirá añadir, editar y eliminar entradas individuales de nuestra lista de contactos,
como se muestra en las siguientes ilustraciones. A continuación, vamos a configurar los cuatro botones para tener el
mismo tamaño para que puedan ser fácilmente reconocidos como una funcionalidad relacionada.
