Temario: Java Frame Form – Nivel Básico

1. Introducción a las Aplicaciones Gráficas en Java

 Objetivo: Comprender los conceptos básicos de las aplicaciones gráficas en Java y el entorno
de desarrollo NetBeans.
 Qué es una aplicación gráfica.
 Ventajas de las aplicaciones gráficas sobre las aplicaciones de consola.
 Introducción a Swing y sus componentes básicos (JFrame, JButton, JLabel, JTextField,
etc.).
 Introducción a Java Frame Form en NetBeans.

2. Creación de un Proyecto Java con Frame Form

 Objetivo: Aprender a crear un nuevo proyecto en NetBeans utilizando Frame Form.

 Configuración de un proyecto Java con Java Frame Form.
 Navegación por el entorno de NetBeans.
 Estructura de un programa con formularios (JFrame, JPanel).
 Creación y ejecución de un formulario vacío.

3. Diseño de Interfaces Gráficas con Frame Form

 Objetivo: Aprender a agregar y organizar componentes en un Frame Form.

 Uso de la paleta de componentes en NetBeans.
 Colocación de componentes como:
o JLabel (etiquetas de texto).
o JButton (botones).
o JTextField (campos de texto).
o JCheckBox (casillas de verificación).
o JRadioButton (botones de opción).
 Ajuste de propiedades básicas de los componentes (tamaño, texto, color).

4. Manejo de Eventos en Java Frame Form

 Objetivo: Comprender el manejo de eventos y cómo capturar interacciones del usuario.

 Concepto de Listeners y eventos.
 Añadir un evento a un botón (ActionListener).
 Uso de métodos para manejar acciones (al hacer clic en un botón, al ingresar texto).
 Ejemplo: Crear una calculadora simple que realice sumas.

5. Uso de Variables y Operadores Aritméticos en Formularios

 Objetivo: Aplicar variables y operadores aritméticos en la programación de una GUI.

 Declaración y uso de variables dentro de eventos.
 Captura de datos del usuario mediante JTextField.
 Operadores aritméticos básicos: suma, resta, multiplicación y división.
  Ejemplo: Creación de un formulario para calcular el promedio de tres números ingresados por
el usuario.

6. Interacción entre Componentes de la Interfaz

 Objetivo: Desarrollar la capacidad de hacer que los componentes de la interfaz interactúen

entre sí.
 Uso de varios JTextField para capturar múltiples entradas.
 Actualización de etiquetas o resultados basados en entradas del usuario.
 Ejemplo: Programa que convierte grados Celsius a Fahrenheit.

7. Diseño de Formularios Usando Layout Managers

 Objetivo: Aprender a gestionar el diseño de los componentes utilizando diferentes

administradores de diseño.
 Introducción a los Layout Managers:
o FlowLayout.
o GridLayout.
o BorderLayout.
 Aplicación de Layout Managers en Frame Form.
 Ejemplo: Formulario organizado con GridLayout para diseñar una pequeña calculadora.

8. Manejo de Errores y Validaciones en Formulario

 Objetivo: Aprender a manejar errores y validar entradas en los formularios.

 Validación de entradas numéricas en JTextField.
 Manejo de excepciones (try-catch) para prevenir errores de tipo de datos.
 Ejemplo: Validación de un formulario que solo acepte números enteros para el cálculo de
operaciones matemáticas.

9. Guardado de Datos desde un Formulario

 Objetivo: Introducir el almacenamiento de datos en una aplicación gráfica.

 Guardar datos ingresados en un formulario en variables.
 Introducción a la escritura en archivos de texto (de manera simple).
 Ejemplo: Formulario que permita al usuario ingresar datos y guardarlos en un archivo de texto.

10. Proyecto Final: Creación de una Aplicación Gráfica Simple

 Objetivo: Aplicar todo lo aprendido en la creación de una pequeña aplicación.

 Requerimientos de la aplicación:
o Capturar datos del usuario (nombre, edad, etc.).
o Realizar una operación aritmética (como cálculo de IVA o conversión de unidades).
o Mostrar el resultado en la interfaz gráfica.
 Incluir validaciones básicas y manejo de eventos.
Duración del Curso

Este temario está diseñado para cubrirse en aproximadamente 15 a 20 horas de clase, dependiendo del
nivel de detalle en cada tema y la velocidad de los estudiantes.

Metodología

El curso debe enfocarse en el aprendizaje práctico. Cada concepto teórico debe estar acompañado de
ejemplos y ejercicios interactivos en los que los estudiantes puedan aplicar lo aprendido.

Herramientas

 NetBeans IDE (preferiblemente con el plugin de Java Swing).

 JDK (Java Development Kit) actualizado.

Resultados Esperados

Al finalizar este curso, los estudiantes podrán:

 Diseñar interfaces gráficas básicas utilizando Java Swing y Frame Form.

 Implementar funcionalidades interactivas utilizando eventos y manejo de acciones.
 Aplicar operaciones aritméticas básicas en una aplicación gráfica.
 Validar entradas del usuario y manejar errores comunes en formularios.

Este temario ofrece una base sólida para que los estudiantes continúen desarrollando aplicaciones más
complejas en Java utilizando Swing y otros conceptos avanzados.
Introducción a las Aplicaciones Gráficas en Java

Objetivo

El objetivo de este tema es comprender los conceptos básicos de las aplicaciones gráficas en Java, su
diferencia con las aplicaciones de consola, y aprender a utilizar Swing, una de las bibliotecas gráficas
más comunes en Java. Además, se estudiará el entorno de desarrollo NetBeans, específicamente su
herramienta Java Frame Form para la creación de interfaces gráficas.

1. ¿Qué es una Aplicación Gráfica?

Una aplicación gráfica (GUI), o interfaz gráfica de usuario, es un tipo de programa que permite la
interacción con el usuario a través de elementos visuales, como ventanas, botones, cuadros de texto,
menús, y otros componentes gráficos. A diferencia de las aplicaciones de consola que se basan en la
entrada y salida de texto, las aplicaciones gráficas ofrecen una forma más intuitiva y amigable para
interactuar con el software.

Ejemplo:

 Las aplicaciones de consola son aquellas donde el usuario interactúa escribiendo comandos en una
línea de texto.
 Las aplicaciones gráficas, como un navegador o una calculadora, permiten interactuar con el mouse y
el teclado a través de elementos visuales como botones y menús desplegables.

2. Ventajas de las Aplicaciones Gráficas sobre las Aplicaciones de Consola

1. Interactividad: Las GUIs permiten una mayor interacción del usuario, ya que las acciones se
realizan mediante botones, menús, y otros componentes visuales que son más intuitivos.
2. Facilidad de Uso: Las GUIs son más fáciles de entender para los usuarios, ya que las opciones
están visiblemente organizadas, lo que elimina la necesidad de recordar comandos específicos.
3. Aspecto Visual: Una GUI bien diseñada puede mejorar la experiencia del usuario, haciéndola
más atractiva y profesional.
4. Accesibilidad: Las GUIs permiten que los programas sean accesibles a una audiencia más
amplia, incluidos aquellos que no están familiarizados con el uso de la consola o comandos de
texto.
5. Organización: Los elementos gráficos permiten agrupar mejor las funciones y la información,
haciendo que las aplicaciones sean más organizadas y fáciles de navegar.

3. Introducción a Swing y sus Componentes Básicos

Swing es una biblioteca gráfica de Java que proporciona una amplia gama de componentes gráficos
para crear GUIs. Estos componentes incluyen ventanas, botones, cuadros de texto, tablas, entre otros, y
permiten crear aplicaciones gráficas independientes de la plataforma.

Componentes Básicos de Swing

1. JFrame:
o El JFrame es el contenedor principal para cualquier aplicación gráfica en Java. Representa una
ventana que puede contener otros componentes como botones, cuadros de texto, y etiquetas.
o Ejemplo:

java
Copiar código
JFrame ventana = new JFrame("Mi Ventana");
ventana.setSize(400, 300); // Tamaño de la ventana
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // Cerrar al
salir
ventana.setVisible(true); // Mostrar la ventana

2. JButton:
o Representa un botón que puede ser clicado por el usuario. Al hacer clic, se ejecuta un código
asociado.
o Ejemplo:

java
Copiar código
JButton boton = new JButton("Clic aquí");
boton.addActionListener(e -> System.out.println("¡Botón clicado!"));

3. JLabel:
o Se utiliza para mostrar texto o imágenes en la interfaz. No es interactivo, solo muestra
información.
o Ejemplo:

java
Copiar código
JLabel etiqueta = new JLabel("Hola, Mundo");

4. JTextField:
o Es un campo de texto que permite al usuario introducir información. Es útil para entradas
simples como nombres o números.
o Ejemplo:

java
Copiar código
JTextField campoTexto = new JTextField(20); // 20 caracteres de ancho

5. JPanel:
 o Un contenedor que puede agrupar varios componentes. Se usa para organizar la disposición
de los componentes dentro de una ventana.
o Ejemplo:

java
Copiar código
JPanel panel = new JPanel();
panel.add(boton); // Añadir componentes al panel
panel.add(etiqueta);

Ventajas de Swing:

 Portabilidad: Las aplicaciones Swing funcionan en cualquier plataforma que soporte Java.
 Flexibilidad: Permite personalizar los componentes gráficos y agregar interactividad fácilmente.
 Ligereza: No depende directamente del sistema operativo, por lo que los componentes son más
ligeros y consistentes entre plataformas.

4. Introducción a Java Frame Form en NetBeans

Java Frame Form es una herramienta en NetBeans que permite diseñar interfaces gráficas utilizando
un método visual de arrastrar y soltar componentes. En lugar de escribir todo el código a mano,
NetBeans genera automáticamente el código Java para los formularios gráficos.

Características de Java Frame Form:

 Diseño Visual: Permite arrastrar componentes como botones, etiquetas y cuadros de texto
directamente sobre un formulario gráfico, sin necesidad de escribir el código inicial
manualmente.
 Generación Automática de Código: Cuando se utiliza el diseñador visual, NetBeans genera el
código necesario para crear los componentes de la interfaz. Esto facilita el desarrollo de GUIs
complejas de manera más rápida y sin errores de sintaxis.
 Vista Previa en Tiempo Real: Permite ver cómo quedará la interfaz mientras se diseña, lo que
facilita la toma de decisiones sobre el diseño final.

Pasos para Crear una Aplicación Gráfica con Java Frame Form:

1. Crear un Nuevo Proyecto:

o Abrir NetBeans.
o Seleccionar Nuevo Proyecto -> Java -> Java Application.
o Nombrar el proyecto y finalizar.

2. Añadir un JFrame Form:

o Hacer clic derecho sobre el paquete del proyecto y seleccionar Nuevo -> JFrame Form.
o Se abrirá una ventana para diseñar la interfaz gráfica.

3. Arrastrar Componentes:
 o En la paleta de componentes (a la derecha), seleccionar y arrastrar un JLabel, JButton, y
JTextField al formulario.
o Usar las propiedades del componente para ajustar el texto, tamaño, y color.

4. Añadir Funcionalidad:
o Hacer doble clic en el botón (JButton) para abrir el editor de código y agregar la acción
deseada, como mostrar un mensaje al hacer clic.

java
Copiar código
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
System.out.println("Botón clicado");
}

5. Ejecutar la Aplicación:
o Guardar el proyecto y hacer clic en Ejecutar para ver el formulario en funcionamiento.

Conclusión

Las aplicaciones gráficas en Java permiten crear programas interactivos y visualmente atractivos,
mejorando la experiencia del usuario en comparación con las aplicaciones de consola. Swing
proporciona los componentes necesarios para crear estas interfaces gráficas, y NetBeans, con su
herramienta Java Frame Form, facilita enormemente el diseño de GUIs mediante su editor visual.
2. Creación de un Proyecto Java con Frame Form

Objetivo

El objetivo de este tema es aprender a crear un nuevo proyecto en NetBeans utilizando Java Frame
Form para diseñar interfaces gráficas de usuario (GUI). Se abordará la configuración inicial del
proyecto, la navegación por el entorno de desarrollo integrado (IDE) de NetBeans, la estructura de un
programa que incluye formularios, y finalmente, la creación y ejecución de un formulario vacío.

1. Configuración de un Proyecto Java con Java Frame Form

Para comenzar a trabajar con interfaces gráficas en Java, es necesario crear un proyecto en NetBeans
que incluya la funcionalidad de Java Frame Form. A continuación se describen los pasos para
configurar dicho proyecto:

Pasos para Crear un Proyecto Java con Frame Form:

1. Abrir NetBeans: Iniciar el entorno de desarrollo NetBeans.

2. Crear un Nuevo Proyecto:
o Ir a Archivo → Nuevo Proyecto o utilizar el atajo de teclado (Ctrl + Mayús + N).
o Seleccionar la categoría Java.
o Elegir la opción Java Application y hacer clic en Siguiente.

3. Configurar el Proyecto:
o Asignar un nombre al proyecto. Por ejemplo, ProyectoGUI.
o Seleccionar la ubicación donde se guardará el proyecto en tu sistema.
o Asegurarse de que la opción Crear clase principal esté marcada.
o Hacer clic en Finalizar.

4. Añadir un Frame Form al Proyecto:

o En el explorador de proyectos, hacer clic derecho sobre el paquete principal del proyecto
(normalmente el que tiene el mismo nombre que el proyecto).
o Seleccionar Nuevo → JFrame Form.
o Asignar un nombre al JFrame, por ejemplo, VentanaPrincipal.
o Hacer clic en Finalizar.

Ahora, se habrá generado automáticamente un formulario (JFrame) vacío dentro del proyecto,
el cual podremos empezar a personalizar.

2. Navegación por el Entorno de NetBeans

NetBeans es un IDE poderoso y completo que facilita el desarrollo de aplicaciones Java. Conocer su
estructura y las áreas clave es fundamental para trabajar de manera eficiente.
Componentes Clave del Entorno de NetBeans:

1. Explorador de Proyectos:
o Ubicado a la izquierda, este panel permite navegar por los archivos y recursos del proyecto.
o Aquí es donde se gestionan las clases, formularios, y otros archivos asociados al proyecto.

2. Editor de Código:
o El área central del IDE donde se escribe el código Java.
o Al crear un JFrame Form, esta área también permite alternar entre la vista de Diseño
(Design) y la vista de Código (Source).

3. Paleta de Componentes:
o Ubicada a la derecha, esta paleta contiene todos los elementos visuales (botones, cuadros de
texto, etiquetas, etc.) que se pueden arrastrar al formulario.

4. Propiedades:
o El panel de Propiedades muestra las características del componente seleccionado, como el
texto, tamaño, color, etc.

5. Salida:
o El panel inferior donde se muestran los resultados de la ejecución de la aplicación, así como
mensajes de error o advertencias.

3. Estructura de un Programa con Formularios (JFrame, JPanel)

Cuando trabajas con aplicaciones gráficas en Java, es importante entender la jerarquía de los
componentes.

JFrame:

 Es la ventana principal de la aplicación, lo que usualmente se llama el "contenedor raíz". Todos los
demás componentes gráficos se añaden a este contenedor.
 Un JFrame puede contener otros elementos como JPanel, JButton, JLabel, entre otros.

JPanel:

 Es un contenedor ligero que organiza los componentes dentro de un JFrame.

 Permite agrupar y organizar otros componentes visuales, mejorando la organización del diseño.

Relación entre JFrame y JPanel:

 El JFrame actúa como el contenedor superior de la ventana, mientras que los JPanel permiten
organizar componentes dentro de esa ventana.

Ejemplo de un programa con JFrame y JPanel:

java
Copiar código
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JButton;

public class VentanaPrincipal extends JFrame {

public VentanaPrincipal() {
// Crear un JPanel
JPanel panel = new JPanel();

// Añadir un botón al panel

JButton boton = new JButton("Clic aquí");
panel.add(boton);

// Añadir el panel al JFrame

this.add(panel);

// Configurar el JFrame
this.setSize(400, 300); // Tamaño de la ventana
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // Cerrar la
aplicación al cerrar la ventana
this.setVisible(true); // Hacer visible la ventana
}

public static void main(String[] args) {

new VentanaPrincipal(); // Crear y mostrar la ventana
}
}

4. Creación y Ejecución de un Formulario Vacío

Una vez que hayas configurado el proyecto y entendido la estructura de los formularios, el siguiente
paso es crear un formulario vacío y ejecutarlo. Los formularios vacíos son útiles para definir la
estructura básica de la interfaz antes de agregar funcionalidad.

Pasos para Crear un Formulario Vacío:

1. Abrir el Formulario en NetBeans:

o En el Explorador de Proyectos, hacer doble clic en el archivo del JFrame (por ejemplo,
VentanaPrincipal.java).
o Esto abrirá la vista de diseño, donde podrás ver una ventana vacía (el JFrame).

2. Configurar el Formulario:
o Ajustar el tamaño del formulario usando las propiedades del JFrame.
o Añadir un título para la ventana:
  Hacer clic en el JFrame y en el panel de Propiedades, buscar la opción title. Cambiar
el título a algo como "Mi Aplicación Gráfica".

3. Añadir un Componente (Opcional):

o Si lo deseas, puedes arrastrar un componente básico como un botón (JButton) desde la
Paleta de Componentes a la ventana del formulario. Esto te permitirá visualizar cómo los
componentes se añaden al formulario.

4. Guardar y Ejecutar:
o Guardar el proyecto haciendo clic en Archivo → Guardar todo.
o Para ejecutar el formulario, haz clic en el botón Ejecutar (un ícono verde con forma de
triángulo) o presiona F6.

Esto abrirá la ventana del formulario vacío que has creado.

Resultado Esperado:

Al ejecutar el proyecto, verás una ventana en blanco con el título "Mi Aplicación Gráfica". Si añadiste
algún componente como un botón, también aparecerá en la ventana.

Conclusión

La creación de un proyecto con Java Frame Form en NetBeans permite desarrollar aplicaciones
gráficas de forma visual e intuitiva. A través del uso de JFrame y JPanel, es posible estructurar
programas que proporcionen interfaces amigables y visualmente atractivas. Además, NetBeans facilita
enormemente la creación de estos formularios al ofrecer herramientas de diseño que generan
automáticamente el código necesario. En este primer paso, hemos aprendido a crear y ejecutar un
formulario vacío, el cual servirá como base para futuras aplicaciones más complejas.
3. Diseño de Interfaces Gráficas con Frame Form

Objetivo

El objetivo de este tema es aprender a agregar y organizar componentes visuales en un Java Frame
Form utilizando el entorno de desarrollo NetBeans. Los componentes gráficos como etiquetas,
botones, campos de texto, casillas de verificación y botones de opción son elementos fundamentales en
la creación de interfaces de usuario (GUI). También se abordará el ajuste de las propiedades básicas de
estos componentes, como tamaño, texto y color.

1. Uso de la Paleta de Componentes en NetBeans

La Paleta de Componentes es una de las herramientas clave al diseñar interfaces gráficas en

NetBeans. Esta paleta proporciona una amplia variedad de componentes visuales que se pueden
arrastrar y soltar directamente en el formulario (JFrame o JPanel).

Componentes Principales de la Paleta:

 JLabel: Muestra texto o imágenes.

 JButton: Permite crear botones interactivos.
 JTextField: Campo para ingresar texto de una sola línea.
 JCheckBox: Casilla de verificación que puede estar seleccionada o no.
 JRadioButton: Botón de opción que se agrupa con otros para permitir una única selección.

Cómo Usar la Paleta:

1. Abrir el JFrame Form en NetBeans (en la vista de diseño).

2. Seleccionar un componente en la Paleta de Componentes.
3. Arrastrar el componente y soltarlo en el formulario.
4. Ajustar la posición y tamaño del componente directamente en la vista de diseño o desde las
Propiedades.

2. Colocación de Componentes

A continuación, se describen los componentes más comunes utilizados en interfaces gráficas y cómo
agregarlos a un formulario.

a) JLabel (etiquetas de texto)

Un JLabel es un componente simple que muestra texto estático en la interfaz.

1. Agregar un JLabel:
o Desde la Paleta de Componentes, selecciona JLabel.
 o Arrástralo y suéltalo en el formulario.

2. Cambiar el Texto:
o Selecciona el JLabel y ve al panel de Propiedades.
o En la propiedad text, escribe el mensaje que quieres mostrar, por ejemplo: “Nombre:”.

3. Ajuste de Propiedades:
o Puedes ajustar el tamaño y la fuente del texto, o cambiar el color del fondo o del texto desde
el panel de Propiedades.

b) JButton (botones)

Un JButton es un componente que el usuario puede hacer clic para realizar una acción.

1. Agregar un JButton:
o Desde la Paleta de Componentes, selecciona JButton.
o Arrástralo y suéltalo en el formulario.

2. Cambiar el Texto del Botón:

o En las Propiedades, busca la propiedad text y cambia el texto, por ejemplo, “Enviar”.

3. Ajuste de Propiedades:
o Cambiar el tamaño del botón arrastrando los bordes en la vista de diseño.
o En las Propiedades, puedes ajustar el color de fondo y el color del texto, así como la acción
que realiza el botón.

c) JTextField (campos de texto)

Un JTextField es un campo donde el usuario puede ingresar texto.

1. Agregar un JTextField:
o Desde la Paleta de Componentes, selecciona JTextField y colócalo en el formulario.

2. Configurar el Ancho:
o Ajusta el tamaño arrastrando los bordes del componente en el formulario, o en las
Propiedades, cambia el valor de la propiedad columns para definir el número de caracteres
visibles.

3. Propiedades Útiles:
o Puedes definir el texto inicial que aparece en el campo usando la propiedad text.
o Puedes limitar el número de caracteres usando un DocumentFilter, pero esto es un paso
avanzado.
d) JCheckBox (casillas de verificación)

Un JCheckBox es una casilla que el usuario puede marcar o desmarcar.

1. Agregar un JCheckBox:
o Selecciona JCheckBox de la paleta y colócalo en el formulario.

2. Cambiar el Texto de la Casilla:

o En las Propiedades, cambia el valor de text para definir el mensaje que acompaña la casilla,
por ejemplo, “Aceptar términos y condiciones”.

3. Ajuste de Estado Inicial:

o Puedes configurar la casilla para que aparezca marcada inicialmente cambiando la propiedad
selected a true.

e) JRadioButton (botones de opción)

Un JRadioButton es un botón de opción que generalmente se agrupa con otros botones de opción,
permitiendo una sola selección dentro del grupo.

1. Agregar un JRadioButton:
o Desde la Paleta de Componentes, selecciona JRadioButton y colócalo en el formulario.

2. Agrupar JRadioButtons:
o Para agrupar varios JRadioButton, debes crear un grupo utilizando la clase ButtonGroup.
o En el código, añade los botones al grupo:

java
Copiar código
ButtonGroup grupoOpciones = new ButtonGroup();
grupoOpciones.add(radioButton1);
grupoOpciones.add(radioButton2);

3. Ajuste de Propiedades:
o Cambia el texto asociado al botón desde la propiedad text, por ejemplo, “Opción A”.
o Configura uno de los botones para que esté seleccionado por defecto usando la propiedad
selected.

3. Ajuste de Propiedades Básicas de los Componentes

Cada componente gráfico tiene una serie de propiedades que pueden ser ajustadas para cambiar su
comportamiento o apariencia. Los ajustes más comunes incluyen el tamaño, el texto, y los colores.
a) Tamaño:

 El tamaño de los componentes se puede ajustar directamente en el formulario arrastrando los bordes
del componente, o especificando el ancho y alto en las Propiedades del componente (propiedades
width y height).

b) Texto:

 Los componentes como JLabel, JButton, JCheckBox, y JRadioButton tienen una propiedad
llamada text que permite definir el texto que aparece en pantalla.

c) Color:

 El color del texto se ajusta mediante la propiedad foreground.

 El color de fondo se ajusta mediante la propiedad background. En algunos componentes, como
JTextField, es necesario habilitar la opción de opaque para que el color de fondo se aplique.

Ejemplo de ajuste de propiedades:

java
Copiar código
JButton boton = new JButton("Aceptar");
boton.setText("Enviar"); // Cambiar el texto del botón
boton.setBackground(Color.BLUE); // Cambiar el color de fondo del botón
boton.setForeground(Color.WHITE); // Cambiar el color del texto del botón
boton.setSize(100, 50); // Ajustar el tamaño del botón

Conclusión

El diseño de interfaces gráficas en Java con NetBeans y el uso de Frame Form permite crear
aplicaciones de forma visual e intuitiva. A través del uso de la Paleta de Componentes es posible
agregar y organizar elementos clave como etiquetas, botones, campos de texto, casillas de verificación
y botones de opción, que forman la base de cualquier interfaz gráfica. Con el ajuste de propiedades
básicas como el tamaño, texto y color, se puede personalizar la apariencia y el comportamiento de cada
componente para crear interfaces de usuario atractivas y funcionales.
4. Manejo de Eventos en Java Frame Form

Objetivo

El objetivo de este tema es aprender a manejar eventos en las aplicaciones gráficas de Java utilizando
Frame Form en NetBeans, capturando interacciones del usuario. Veremos cómo añadir eventos a
componentes como botones, capturar la entrada de texto, y manejar las acciones a través de Listeners.
Además, se desarrollará un ejemplo práctico de una calculadora simple para realizar sumas.

1. Concepto de Listeners y Eventos

En Java, un evento es una acción que ocurre como resultado de una interacción del usuario, como
hacer clic en un botón o ingresar texto en un campo de texto. Los listeners son interfaces que permiten
detectar estos eventos y ejecutar código en respuesta.

Tipos Comunes de Eventos:

 ActionEvent: Se dispara cuando se realiza una acción, como hacer clic en un botón.
 KeyEvent: Se dispara cuando se presiona o suelta una tecla.
 MouseEvent: Se dispara cuando ocurre una acción del mouse (clic, movimiento).

Concepto de Listener:

Un listener es una interfaz que se encarga de "escuchar" un evento específico. El listener define el
comportamiento de la interfaz cuando se produce el evento.

 Ejemplo de listener: ActionListener que captura acciones en un botón.

2. Añadir un Evento a un Botón (ActionListener)

El ActionListener es el listener más común utilizado para manejar eventos de botones ( JButton).
Cuando el usuario hace clic en un botón, se dispara un evento que puede ser capturado por este
listener.

Pasos para Añadir un Evento a un Botón:

1. Seleccionar el Botón:
o En el Java Frame Form de NetBeans, selecciona el botón al que deseas añadir el evento.

2. Añadir un ActionListener:
o Haz clic derecho sobre el botón y selecciona la opción Eventos > Action > actionPerformed.
o NetBeans automáticamente generará el código para capturar el evento del botón.
 3. Escribir el Código del Evento:
o Dentro del método actionPerformed, puedes definir lo que sucederá cuando el usuario
haga clic en el botón.

Ejemplo de código:

java
Copiar código
jButton1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton1ActionPerformed(evt);
}
});

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {

// Acción al hacer clic en el botón
System.out.println("Botón clickeado!");
}

3. Uso de Métodos para Manejar Acciones

Es importante separar la lógica de negocio en métodos específicos para cada acción. Esto facilita el
mantenimiento y legibilidad del código.

a) Al Hacer Clic en un Botón

Cuando el usuario hace clic en un botón, se puede manejar el evento utilizando el método
actionPerformed. Como vimos en el ejemplo anterior, puedes realizar diversas acciones, como
cambiar el texto de un campo, mostrar un mensaje, o realizar cálculos.

b) Al Ingresar Texto

Para capturar eventos cuando el usuario ingresa texto en un JTextField, se utiliza un

ActionListener o un KeyListener. Un ActionListener se dispara cuando el usuario presiona
Enter después de escribir texto.

Ejemplo:

java
Copiar código
jTextField1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jTextField1ActionPerformed(evt);
}
});

private void jTextField1ActionPerformed(java.awt.event.ActionEvent evt) {

String textoIngresado = jTextField1.getText();
System.out.println("Texto ingresado: " + textoIngresado);
}
4. Ejemplo: Crear una Calculadora Simple que Realice Sumas

A continuación, vamos a desarrollar una pequeña aplicación gráfica de una calculadora simple que
permita realizar la suma de dos números ingresados por el usuario.

Componentes Necesarios:

1. 2 JTextFields: Para que el usuario ingrese los números.

2. 1 JButton: Para realizar la suma.
3. 1 JLabel: Para mostrar el resultado.

Pasos para Crear la Calculadora:

1. Diseñar la Interfaz:
o Abre un nuevo Java Frame Form en NetBeans.
o Arrastra y suelta dos JTextField, un JButton, y un JLabel desde la Paleta de
Componentes al formulario.
o Ajusta las posiciones y el tamaño de los componentes.
o Cambia el texto del botón a “Sumar” y el del JLabel a “Resultado:”.

2. Añadir el Evento al Botón:

o Selecciona el botón, haz clic derecho, ve a Eventos > Action > actionPerformed.
o Escribe el siguiente código dentro del método actionPerformed del botón para realizar la
suma.

Código Completo del Evento:

java
Copiar código
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
// Obtener los textos ingresados en los JTextField
String numero1Text = jTextField1.getText();
String numero2Text = jTextField2.getText();

// Convertir los textos a números

try {
double numero1 = Double.parseDouble(numero1Text);
double numero2 = Double.parseDouble(numero2Text);

// Realizar la suma
double resultado = numero1 + numero2;

// Mostrar el resultado en el JLabel

jLabel1.setText("Resultado: " + resultado);
} catch (NumberFormatException e) {
// Manejar el error en caso de que el usuario no ingrese un número
válido
jLabel1.setText("Error: Ingrese números válidos.");
}
}
Explicación del Código:

1. Obtener Texto: Los valores ingresados por el usuario en los JTextField se capturan utilizando el
método getText().
2. Convertir Texto a Números: Se utiliza Double.parseDouble() para convertir el texto ingresado en
números. El bloque try-catch se utiliza para manejar posibles errores si el usuario no ingresa un
número válido.
3. Realizar la Suma: Se suman los dos números capturados.
4. Mostrar el Resultado: El resultado se muestra en el JLabel usando el método setText().

Conclusión

El manejo de eventos en aplicaciones gráficas de Java es fundamental para interactuar con el usuario.
Utilizando ActionListener y otros tipos de listeners, es posible capturar eventos como clics de botones
o la entrada de texto, y responder de manera adecuada. En este ejemplo, hemos creado una calculadora
sencilla para realizar sumas, demostrando cómo capturar eventos y manipular la información ingresada
por el usuario.
5. Uso de Variables y Operadores Aritméticos en Formularios

Objetivo

El objetivo de este tema es aplicar variables y operadores aritméticos básicos en la programación de

una Interfaz Gráfica de Usuario (GUI) en Java utilizando Frame Form. Se aprenderá cómo declarar
y utilizar variables dentro de eventos, capturar datos ingresados por el usuario mediante componentes
como JTextField, y utilizar operadores aritméticos como suma, resta, multiplicación y división. Se
desarrollará un ejemplo práctico para calcular el promedio de tres números ingresados por el usuario.

1. Declaración y Uso de Variables dentro de Eventos

En una aplicación gráfica en Java, las variables pueden ser declaradas dentro de los métodos que
manejan los eventos (como actionPerformed). Estas variables se utilizan para almacenar y manipular
datos, como los valores ingresados por el usuario.

Pasos para Declarar Variables en Eventos:

1. Declarar la Variable: Las variables se declaran de manera similar a cualquier programa Java,
pero dentro del método que maneja el evento. Ejemplo:

java
Copiar código
double numero1, numero2, numero3;

2. Inicializar las Variables: Se asignan valores a las variables capturando la entrada del usuario
desde los componentes de la interfaz gráfica, como JTextField. Ejemplo:

java
Copiar código
numero1 = Double.parseDouble(jTextField1.getText());

3. Usar las Variables: Una vez que las variables han sido inicializadas con los datos del usuario,
se pueden utilizar en cualquier operación aritmética o lógica. Ejemplo:

java
Copiar código
double promedio = (numero1 + numero2 + numero3) / 3;

2. Captura de Datos del Usuario mediante JTextField

Para capturar la entrada del usuario en un JTextField, se utiliza el método getText(). Este método
devuelve el texto ingresado como una cadena (String), por lo que debe convertirse en un tipo de dato
numérico (por ejemplo, double) para poder realizar operaciones aritméticas.

Ejemplo de Captura de Datos:

java
Copiar código
String textoNumero1 = jTextField1.getText(); // Capturar el texto ingresado
double numero1 = Double.parseDouble(textoNumero1); // Convertirlo a un número
(double)

3. Operadores Aritméticos Básicos

En Java, se utilizan los operadores aritméticos básicos para realizar operaciones matemáticas con las
variables. Los operadores que cubriremos son:

 Suma (+): Suma dos números.

 Resta (-): Resta dos números.
 Multiplicación (*): Multiplica dos números.
 División (/): Divide un número entre otro.

Ejemplos:

 Suma: resultado = numero1 + numero2;

 Resta: resultado = numero1 - numero2;
 Multiplicación: resultado = numero1 * numero2;
 División: resultado = numero1 / numero2;

4. Ejemplo: Creación de un Formulario para Calcular el Promedio de Tres Números

A continuación, desarrollaremos un ejemplo práctico para calcular el promedio de tres números

ingresados por el usuario en un formulario.

Componentes Necesarios:

1. 3 JTextField: Para que el usuario ingrese los tres números.

2. 1 JButton: Para realizar el cálculo.
3. 1 JLabel: Para mostrar el resultado (el promedio calculado).

Diseño de la Interfaz:

1. Crea un nuevo Java Frame Form en NetBeans.

2. Arrastra y suelta tres JTextField desde la Paleta de Componentes al formulario para que el usuario
ingrese los números.
3. Agrega un JButton con el texto "Calcular Promedio".
 4. Añade un JLabel que mostrará el resultado, por ejemplo, con el texto inicial "Resultado:".

Pasos para Crear el Formulario:

1. Captura los Valores Ingresados por el Usuario: Utiliza el método getText() de los
JTextField para obtener los valores que el usuario ingresa.

Ejemplo:

java
Copiar código
String numero1Text = jTextField1.getText();
String numero2Text = jTextField2.getText();
String numero3Text = jTextField3.getText();

2. Convierte el Texto en Números: Utiliza el método Double.parseDouble() para convertir los

valores de texto en números de tipo double.

Ejemplo:

java
Copiar código
double numero1 = Double.parseDouble(numero1Text);
double numero2 = Double.parseDouble(numero2Text);
double numero3 = Double.parseDouble(numero3Text);

3. Realiza el Cálculo del Promedio: Aplica la fórmula del promedio: (n1 + n2 + n3) / 3.

Ejemplo:

java
Copiar código
double promedio = (numero1 + numero2 + numero3) / 3;

4. Muestra el Resultado en el JLabel: Finalmente, muestra el resultado en el JLabel utilizando

el método setText() para cambiar el texto.

Ejemplo:

java
Copiar código
jLabel1.setText("Resultado: " + promedio);
Código Completo del Evento:
java
Copiar código
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
// Capturar los valores ingresados por el usuario
String numero1Text = jTextField1.getText();
String numero2Text = jTextField2.getText();
String numero3Text = jTextField3.getText();

// Convertir los valores de texto a números

try {
double numero1 = Double.parseDouble(numero1Text);
double numero2 = Double.parseDouble(numero2Text);
double numero3 = Double.parseDouble(numero3Text);

// Calcular el promedio
double promedio = (numero1 + numero2 + numero3) / 3;

// Mostrar el resultado en el JLabel

jLabel1.setText("Resultado: " + promedio);
} catch (NumberFormatException e) {
// Manejar el error si los valores no son números válidos
jLabel1.setText("Error: Ingrese números válidos.");
}
}

Explicación del Código:

1. Captura de Datos: Se capturan los datos del usuario desde los JTextField.
2. Conversión a Números: Utilizando Double.parseDouble(), los datos capturados (en forma de
texto) se convierten a números para realizar cálculos.
3. Cálculo del Promedio: Se suman los tres números y se dividen entre 3 para obtener el promedio.
4. Mostrar el Resultado: El resultado del promedio se muestra en un JLabel.
5. Manejo de Errores: Se maneja el caso en que el usuario ingrese datos no válidos (por ejemplo, texto
en lugar de números) mediante el uso de un bloque try-catch.

Conclusión

Este tema abarcó el uso de variables y operadores aritméticos básicos en formularios gráficos
utilizando Java Frame Form en NetBeans. Aprendimos cómo capturar datos del usuario utilizando
JTextField, aplicar operadores aritméticos para realizar cálculos, y mostrar los resultados en
componentes gráficos como JLabel. El ejemplo práctico de una calculadora de promedio demostró
cómo integrar todos estos conceptos para crear una aplicación interactiva.
6. Interacción entre Componentes de la Interfaz

Objetivo

El objetivo de este tema es aprender a hacer que los componentes de una interfaz gráfica interactúen
entre sí. Los componentes como JTextField, JButton, y JLabel trabajarán juntos para capturar
entradas, realizar cálculos o transformaciones, y actualizar la interfaz con los resultados. Al finalizar,
se habrá desarrollado una aplicación que convierte grados Celsius a Fahrenheit, mostrando cómo los
datos ingresados en un JTextField pueden ser procesados y reflejados en un JLabel o en otro
componente de la interfaz.

1. Uso de Varios JTextField para Capturar Múltiples Entradas

Cuando se trabaja con varios JTextField, es común capturar diferentes valores para realizar
operaciones o transformaciones con esos datos. Cada JTextField puede representar un valor o
parámetro diferente que luego será utilizado en los cálculos.

Pasos para Capturar Múltiples Entradas:

1. Diseño de la Interfaz: Coloca dos o más JTextField en el formulario, asegurándote de que

cada campo sea para una entrada específica.
2. Captura de los Valores: Utiliza el método getText() de cada JTextField para capturar las
entradas del usuario. Ejemplo:

java
Copiar código
String entrada1 = jTextField1.getText();
String entrada2 = jTextField2.getText();

3. Convertir las Entradas a un Tipo Numérico: Convierte las entradas a un tipo numérico,
como double, utilizando Double.parseDouble(), para poder realizar cálculos. Ejemplo:

java
Copiar código
double valor1 = Double.parseDouble(entrada1);
double valor2 = Double.parseDouble(entrada2);

2. Actualización de Etiquetas o Resultados Basados en Entradas del Usuario

Una de las funciones comunes en las interfaces gráficas es actualizar un componente, como un JLabel,
en respuesta a la interacción del usuario. Esto permite mostrar resultados o mensajes basados en los
datos ingresados.
Actualización de un JLabel con un Resultado:

Para mostrar un resultado en un JLabel, se utiliza el método setText(), el cual cambia el texto
mostrado por el componente.

Ejemplo:

java
Copiar código
jLabel1.setText("Resultado: " + resultado);

Este método puede utilizarse para mostrar cualquier tipo de información, desde el resultado de un
cálculo hasta un mensaje de error o confirmación.

3. Ejemplo: Programa que Convierte Grados Celsius a Fahrenheit

En este ejemplo, desarrollaremos un programa simple que convierte una temperatura en grados
Celsius, ingresada por el usuario en un JTextField, a grados Fahrenheit, y muestra el resultado en un
JLabel.

Diseño de la Interfaz:

1. 1 JTextField: Para que el usuario ingrese la temperatura en grados Celsius.

2. 1 JButton: Para realizar la conversión cuando el usuario haga clic en él.
3. 1 JLabel: Para mostrar el resultado de la conversión en grados Fahrenheit.

Pasos para Crear el Formulario:

1. Captura del Valor Ingresado por el Usuario: Utiliza el método getText() para obtener el
valor ingresado en el JTextField.

Ejemplo:

java
Copiar código
String textoCelsius = jTextField1.getText();
 2. Conversión del Valor a Número: Utiliza Double.parseDouble() para convertir el valor de
texto a un número de tipo double.

Ejemplo:

java
Copiar código
double celsius = Double.parseDouble(textoCelsius);

3. Cálculo de la Conversión de Celsius a Fahrenheit: Aplica la fórmula de conversión:

F=(C×1.8)+32F = (C \times 1.8) + 32F=(C×1.8)+32.

Ejemplo:

java
Copiar código
double fahrenheit = (celsius * 1.8) + 32;

4. Mostrar el Resultado en el JLabel: Usa el método setText() para mostrar el resultado en el

JLabel.

Ejemplo:

java
Copiar código
jLabel1.setText("Fahrenheit: " + fahrenheit);

Código Completo del Evento:

java
Copiar código
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
// Captura el valor ingresado en Celsius
String textoCelsius = jTextField1.getText();

// Convertir el valor de texto a número

try {
double celsius = Double.parseDouble(textoCelsius);

// Realizar la conversión a Fahrenheit

double fahrenheit = (celsius * 1.8) + 32;

// Mostrar el resultado en el JLabel

jLabel1.setText("Fahrenheit: " + fahrenheit);
} catch (NumberFormatException e) {
// Manejar el error si el valor no es un número válido
jLabel1.setText("Error: Ingrese un número válido.");
}
}
Explicación del Código:

1. Captura de Datos: El valor ingresado por el usuario en el JTextField es capturado en formato de texto.
2. Conversión de Texto a Número: El texto se convierte en un número de tipo double utilizando
Double.parseDouble(). Esto permite realizar cálculos aritméticos.
3. Cálculo de la Conversión: Utilizando la fórmula de conversión de grados Celsius a Fahrenheit, el valor
de Celsius se transforma a Fahrenheit.
4. Mostrar el Resultado: El resultado de la conversión se muestra en un JLabel.
5. Manejo de Errores: Si el usuario ingresa un valor no numérico, se maneja una excepción
NumberFormatException y se muestra un mensaje de error en el JLabel.

Conclusión

En este tema, aprendimos a hacer que varios componentes de una interfaz gráfica en Java Frame
Form interactúen entre sí. Utilizando componentes como JTextField, JLabel, y JButton, se puede
capturar la entrada del usuario, realizar cálculos u operaciones, y mostrar los resultados o mensajes en
otros componentes de la interfaz. El ejemplo práctico de conversión de grados Celsius a Fahrenheit
demostró cómo estos componentes pueden trabajar en conjunto para crear una aplicación interactiva y
funcional.
7. Diseño de Formularios Usando Layout Managers

Objetivo

El objetivo de este tema es comprender cómo gestionar la disposición de los componentes en un

formulario utilizando diferentes Layout Managers. Esto es crucial para crear interfaces gráficas bien
organizadas y funcionales, independientemente del tamaño de la ventana o la resolución de la pantalla.
Al finalizar, serás capaz de utilizar administradores de diseño como FlowLayout, GridLayout, y
BorderLayout para distribuir los componentes de manera eficiente en un Java Frame Form.

1. Introducción a los Layout Managers

Los Layout Managers son responsables de organizar los componentes dentro de un contenedor en un
formulario. Java proporciona varios tipos de administradores de diseño, cada uno con sus propias
características y formas de organizar los elementos.

Principales Layout Managers:

1. FlowLayout:
o Organiza los componentes en fila, alineándolos de izquierda a derecha.
o Los componentes fluyen al siguiente renglón si el espacio es insuficiente.
o Es el diseño predeterminado de muchos contenedores, como JPanel.

Ejemplo de creación:

java
Copiar código
JPanel panel = new JPanel();
panel.setLayout(new FlowLayout());

2. GridLayout:
o Organiza los componentes en una cuadrícula de filas y columnas.
o Todos los componentes tienen el mismo tamaño.
o Útil para formularios en los que se necesite una distribución uniforme, como una calculadora.

Ejemplo de creación:

java
Copiar código
JPanel panel = new JPanel();
panel.setLayout(new GridLayout(3, 3)); // Una cuadrícula de 3x3

3. BorderLayout:
o Divide el contenedor en cinco regiones: Norte (North), Sur (South), Este (East), Oeste (West) y
Centro (Center).
 o Cada componente se coloca en una de estas regiones.
o Es útil cuando se necesita una organización jerárquica de los componentes.

Ejemplo de creación:

java
Copiar código
JPanel panel = new JPanel();
panel.setLayout(new BorderLayout());

2. Aplicación de Layout Managers en Frame Form

Cuando trabajas con Java Frame Form en NetBeans, los Layout Managers te permiten gestionar
cómo se distribuyen los componentes en la ventana de la aplicación. En el entorno de NetBeans,
puedes cambiar fácilmente el Layout Manager a través de las propiedades del contenedor o
componente, utilizando la paleta visual.

Pasos para Aplicar un Layout Manager en NetBeans:

1. Seleccionar el Panel o Contenedor: En el Frame Form, selecciona el JPanel o contenedor

donde deseas aplicar el Layout Manager.
2. Cambiar el Layout:
o En el panel de propiedades de NetBeans, busca la opción Layout.
o Selecciona el Layout Manager que deseas aplicar, como FlowLayout, GridLayout, o
BorderLayout.

3. Organizar los Componentes: Una vez aplicado el Layout Manager, arrastra los componentes
(como JLabel, JButton, JTextField) dentro del panel, y verás cómo se organizan
automáticamente según el Layout Manager seleccionado.

3. Ejemplo: Formulario con GridLayout para Diseñar una Calculadora

En este ejemplo, diseñaremos una calculadora simple utilizando el GridLayout. El formulario

contendrá una cuadrícula de botones que representarán los números y las operaciones básicas.

Componentes a Utilizar:

 JTextField: Para mostrar los números ingresados y el resultado.

 JButton: Para los números y operaciones (+, -, *, /, =).

Pasos para Crear el Formulario de la Calculadora:

1. Crear el JFrame y el JPanel: Crea un JFrame como contenedor principal y un JPanel para
alojar los botones y el campo de texto.
 2. Aplicar el GridLayout: Aplica el GridLayout al JPanel, configurando una cuadrícula de 4x4
(4 filas y 4 columnas) para los botones.
3. Agregar Componentes:
o Coloca un JTextField en la parte superior del formulario para mostrar los números y
resultados.
o Agrega los botones de la calculadora dentro del JPanel usando el GridLayout.

Código de Ejemplo:
java
Copiar código
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class Calculadora extends JFrame implements ActionListener {

private JTextField pantalla;
private JPanel panelBotones;
private String[] botones = {
"7", "8", "9", "/",
"4", "5", "6", "*",
"1", "2", "3", "-",
"0", "C", "=", "+"
};

private double resultado;

private String operacion;
private boolean nuevaOperacion = true;

public Calculadora() {
// Configurar el JFrame
setTitle("Calculadora");
setSize(300, 400);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setLayout(new BorderLayout());

// Crear la pantalla de la calculadora

pantalla = new JTextField();
pantalla.setEditable(false);
pantalla.setHorizontalAlignment(JTextField.RIGHT);
add(pantalla, BorderLayout.NORTH);

// Crear el panel de botones con GridLayout

panelBotones = new JPanel();
panelBotones.setLayout(new GridLayout(4, 4));

// Agregar botones al panel

for (String boton : botones) {
JButton btn = new JButton(boton);
btn.addActionListener(this); // Agregar ActionListener a cada botón
panelBotones.add(btn);
}

// Agregar el panel de botones al JFrame

add(panelBotones, BorderLayout.CENTER);

setVisible(true);
}
 // Manejo de eventos al hacer clic en un botón
@Override
public void actionPerformed(ActionEvent e) {
String input = e.getActionCommand();

if (input.equals("C")) {
pantalla.setText("");
resultado = 0;
operacion = "";
nuevaOperacion = true;
} else if (input.equals("=")) {
calcular(Double.parseDouble(pantalla.getText()));
pantalla.setText("" + resultado);
operacion = "";
nuevaOperacion = true;
} else if (input.equals("+") || input.equals("-") || input.equals("*")
|| input.equals("/")) {
operacion = input;
resultado = Double.parseDouble(pantalla.getText());
nuevaOperacion = true;
} else {
if (nuevaOperacion) {
pantalla.setText(input);
nuevaOperacion = false;
} else {
pantalla.setText(pantalla.getText() + input);
}
}
}

// Método para realizar el cálculo

private void calcular(double valor) {
switch (operacion) {
case "+":
resultado += valor;
break;
case "-":
resultado -= valor;
break;
case "*":
resultado *= valor;
break;
case "/":
if (valor != 0) {
resultado /= valor;
} else {
pantalla.setText("Error");
}
break;
}
}

public static void main(String[] args) {

new Calculadora();
}
}
Explicación del Código:

1. Diseño con GridLayout: El JPanel principal de botones utiliza un GridLayout de 4x4, donde
cada celda contiene un botón que representa un número o una operación.
2. Eventos: Cada botón tiene un ActionListener que maneja las interacciones del usuario.
Dependiendo del botón presionado, se realiza una acción específica (como agregar un número a
la pantalla, realizar una operación, o borrar los valores).
3. Cálculos: La calculadora realiza operaciones básicas como suma, resta, multiplicación y
división, mostrando el resultado en el JTextField.

Conclusión

El uso de Layout Managers permite gestionar eficazmente la disposición de los componentes en un

formulario de Java, creando interfaces gráficas más organizadas y funcionales. En este tema, vimos
cómo aplicar los tres principales Layout Managers (FlowLayout, GridLayout, BorderLayout), y
creamos una calculadora básica utilizando GridLayout. Con estos conceptos, podrás diseñar interfaces
más complejas y adaptativas para aplicaciones de escritorio en Java.
8. Manejo de Errores y Validaciones en Formularios

Objetivo

El objetivo de este tema es aprender a manejar errores y validar las entradas de datos en los
formularios de Java. A través de la validación de entradas numéricas y el manejo de excepciones, se
garantiza que los usuarios ingresen datos correctos y se previenen errores en tiempo de ejecución. Al
finalizar, serás capaz de validar datos en JTextField y utilizar bloques try-catch para manejar
excepciones como entradas incorrectas.

1. Validación de Entradas Numéricas en JTextField

En una interfaz gráfica, es común que se necesiten validaciones para asegurarse de que el usuario
introduzca los tipos de datos esperados. En el caso de las entradas numéricas, se debe verificar que el
texto ingresado en un JTextField sea un número antes de procesarlo.

Validación de Texto en JTextField

Para validar que el texto ingresado en un JTextField sea numérico, puedes utilizar el método
getText() y verificar si lo que se ingresó es un número.

Ejemplo de validación manual:

java
Copiar código
String entrada = textoField.getText();

try {
int numero = Integer.parseInt(entrada); // Intentar convertir la entrada a
número
// Si la conversión es exitosa, la entrada es válida
System.out.println("Número válido: " + numero);
} catch (NumberFormatException e) {
// Si ocurre una excepción, la entrada no es un número
System.out.println("Entrada no válida. Por favor, ingrese un número.");
}

2. Manejo de Excepciones (try-catch)

Java proporciona el bloque try-catch para manejar excepciones que pueden ocurrir en tiempo de
ejecución, como cuando un usuario introduce un tipo de dato incorrecto. Esto es esencial cuando se
trabaja con entradas de usuario para prevenir errores que podrían hacer que la aplicación falle.
Uso de try-catch

El bloque try-catch se utiliza para "atrapar" excepciones y manejar errores sin detener el programa.
Cuando se produce una excepción dentro de un bloque try, el flujo del programa pasa
automáticamente al bloque catch, donde se maneja el error.

Ejemplo de manejo de excepciones:

java
Copiar código
try {
// Código que puede generar una excepción
int resultado = Integer.parseInt(textoField.getText());
System.out.println("El número ingresado es: " + resultado);
} catch (NumberFormatException e) {
// Manejo del error
JOptionPane.showMessageDialog(null, "Por favor, ingrese un número válido.",
"Error", JOptionPane.ERROR_MESSAGE);
}

En este ejemplo, si el usuario ingresa algo que no puede convertirse en un número entero, se muestra
un cuadro de diálogo informando del error.

3. Ejemplo: Validación de un Formulario para Números Enteros

A continuación, vamos a crear un formulario sencillo donde el usuario pueda ingresar dos números
enteros para realizar una operación matemática (como la suma), y validaremos que ambas entradas
sean números válidos.

Pasos para Crear el Formulario de Validación

1. Crear el JFrame y JTextFields: Se crearán dos JTextFields para que el usuario ingrese los
números, un JButton para realizar la operación y un JLabel para mostrar el resultado.
2. Validar las Entradas: Se utilizará un bloque try-catch para validar que los datos ingresados
en los JTextFields sean números enteros antes de realizar la operación.
3. Mostrar Mensajes de Error: Si el usuario ingresa un valor no numérico, se mostrará un
mensaje de error mediante un JOptionPane.

Código de Ejemplo:
java
Copiar código
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class ValidadorNumerico extends JFrame {

private JTextField textoNumero1;
private JTextField textoNumero2;
private JButton botonCalcular;
private JLabel resultadoLabel;

public ValidadorNumerico() {
// Configuración del JFrame
setTitle("Validación de Números Enteros");
setSize(300, 200);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setLayout(null);

// Crear componentes
JLabel label1 = new JLabel("Número 1:");
label1.setBounds(20, 20, 80, 25);
add(label1);

textoNumero1 = new JTextField();

textoNumero1.setBounds(100, 20, 150, 25);
add(textoNumero1);

JLabel label2 = new JLabel("Número 2:");

label2.setBounds(20, 60, 80, 25);
add(label2);

textoNumero2 = new JTextField();

textoNumero2.setBounds(100, 60, 150, 25);
add(textoNumero2);

botonCalcular = new JButton("Calcular Suma");

botonCalcular.setBounds(20, 100, 150, 25);
add(botonCalcular);

resultadoLabel = new JLabel("Resultado:");

resultadoLabel.setBounds(20, 140, 150, 25);
add(resultadoLabel);

// Añadir ActionListener al botón

botonCalcular.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
calcularSuma();
}
});

setVisible(true);
}

// Método para calcular la suma y validar las entradas

private void calcularSuma() {
try {
// Obtener los textos ingresados y convertirlos a enteros
int numero1 = Integer.parseInt(textoNumero1.getText());
int numero2 = Integer.parseInt(textoNumero2.getText());

// Realizar la suma
int suma = numero1 + numero2;

// Mostrar el resultado
resultadoLabel.setText("Resultado: " + suma);
} catch (NumberFormatException e) {
// Mostrar un mensaje de error si las entradas no son válidas
 JOptionPane.showMessageDialog(null, "Por favor, ingrese solo números
enteros.", "Error de Validación", JOptionPane.ERROR_MESSAGE);
}
}

public static void main(String[] args) {

new ValidadorNumerico();
}
}

Explicación del Código:

1. Validación de Entradas: En el método calcularSuma(), se utiliza Integer.parseInt()

para convertir los valores ingresados en los JTextFields a números enteros. Si el usuario
ingresa un valor no numérico, se lanza una NumberFormatException, que es capturada por el
bloque catch.
2. Manejo de Excepciones: Si ocurre una excepción, se muestra un mensaje de error mediante un
JOptionPane que informa al usuario que debe ingresar solo números enteros.
3. Interfaz Gráfica: El formulario contiene dos JTextFields para que el usuario ingrese los
números, un JButton para realizar la operación y un JLabel donde se muestra el resultado.

Conclusión

El manejo de errores y la validación de entradas son aspectos cruciales en cualquier aplicación gráfica.
Al validar las entradas del usuario y manejar las excepciones correctamente, se previene que la
aplicación falle y se mejora la experiencia del usuario. En este tema, aprendimos a validar entradas
numéricas en un formulario de Java usando JTextField y manejamos las excepciones utilizando try-
catch. Además, vimos cómo implementar un formulario que realiza una operación matemática solo si
los valores ingresados son válidos.
9. Guardado de Datos desde un Formulario

Objetivo

El objetivo de este tema es aprender a almacenar datos ingresados en un formulario gráfico en una
aplicación Java y guardar esos datos en un archivo de texto. A través de este proceso, entenderás cómo
capturar datos desde la interfaz gráfica, cómo manejarlos en variables, y cómo realizar operaciones de
escritura en archivos para persistir la información.

1. Guardar Datos Ingresados en Variables

Cuando un usuario ingresa datos en un formulario, esos datos se capturan a través de los componentes
de la interfaz gráfica como JTextField o JTextArea. Estos datos se almacenan en variables para su
posterior procesamiento o almacenamiento.

Ejemplo de Captura de Datos

java
Copiar código
// Supongamos que tienes un JTextField para ingresar el nombre
JTextField nombreField = new JTextField();
String nombre = nombreField.getText(); // Captura el texto ingresado en el
JTextField

2. Introducción a la Escritura en Archivos de Texto

Para guardar datos en un archivo de texto, puedes utilizar la clase FileWriter junto con
BufferedWriter en Java. Estos permiten escribir datos de manera eficiente en un archivo de texto.

Uso Básico de FileWriter y BufferedWriter

java
Copiar código
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class GuardarDatos {

public static void guardarEnArchivo(String contenido) {
try (BufferedWriter escritor = new BufferedWriter(new
FileWriter("datos.txt", true))) {
escritor.write(contenido);
escritor.newLine(); // Añadir una nueva línea
} catch (IOException e) {
e.printStackTrace();
}
}
}
En este código:

 FileWriter se usa para crear o abrir un archivo llamado datos.txt. El segundo parámetro true
permite agregar al final del archivo sin sobrescribirlo.
 BufferedWriter se usa para escribir datos de manera eficiente en el archivo.
 try-with-resources se utiliza para asegurar que el archivo se cierre automáticamente al finalizar la
escritura, incluso si ocurre una excepción.

3. Ejemplo: Formulario para Ingresar Datos y Guardarlos en un Archivo de Texto

Vamos a crear un formulario simple que permita al usuario ingresar su nombre y una breve
descripción. Luego, los datos ingresados se guardarán en un archivo de texto llamado datos.txt.

Código del Ejemplo

java
Copiar código
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class FormularioGuardarDatos extends JFrame {

private JTextField nombreField;
private JTextArea descripcionArea;
private JButton guardarButton;
private JLabel resultadoLabel;

public FormularioGuardarDatos() {
// Configuración del JFrame
setTitle("Guardar Datos en Archivo");
setSize(400, 300);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setLayout(null);

// Crear componentes
JLabel nombreLabel = new JLabel("Nombre:");
nombreLabel.setBounds(20, 20, 100, 25);
add(nombreLabel);

nombreField = new JTextField();

nombreField.setBounds(120, 20, 250, 25);
add(nombreField);

JLabel descripcionLabel = new JLabel("Descripción:");

descripcionLabel.setBounds(20, 60, 100, 25);
add(descripcionLabel);

descripcionArea = new JTextArea();

descripcionArea.setBounds(120, 60, 250, 100);
add(descripcionArea);

guardarButton = new JButton("Guardar");

guardarButton.setBounds(20, 180, 100, 25);
add(guardarButton);
 resultadoLabel = new JLabel("");
resultadoLabel.setBounds(20, 220, 350, 25);
add(resultadoLabel);

// Añadir ActionListener al botón

guardarButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
guardarDatos();
}
});

setVisible(true);
}

// Método para guardar los datos en un archivo

private void guardarDatos() {
String nombre = nombreField.getText();
String descripcion = descripcionArea.getText();

String contenido = "Nombre: " + nombre + "\nDescripción: " +

descripcion;

try (BufferedWriter escritor = new BufferedWriter(new

FileWriter("datos.txt", true))) {
escritor.write(contenido);
escritor.newLine(); // Añadir una nueva línea para separar entradas
resultadoLabel.setText("Datos guardados con éxito.");
} catch (IOException e) {
resultadoLabel.setText("Error al guardar los datos.");
e.printStackTrace();
}
}

public static void main(String[] args) {

new FormularioGuardarDatos();
}
}

Explicación del Código

1. Interfaz Gráfica: El formulario tiene un JTextField para ingresar el nombre, un JTextArea

para la descripción, y un JButton para guardar los datos. También hay un JLabel para mostrar
el resultado de la operación de guardado.
2. Captura de Datos: En el método guardarDatos(), se obtiene el texto ingresado en el
JTextField y JTextArea.
3. Escritura en Archivo: Los datos se guardan en datos.txt usando FileWriter y
BufferedWriter. El archivo se abre en modo de anexado ( true en el constructor de
FileWriter), lo que permite agregar nuevas entradas sin sobrescribir el contenido existente.
4. Manejo de Excepciones: Si ocurre una excepción durante la escritura, se muestra un mensaje
de error en el JLabel y se imprime la traza del error.
Conclusión

El guardado de datos desde un formulario a un archivo es una tarea común en el desarrollo de

aplicaciones. A través de este tema, aprendiste a capturar datos desde la interfaz gráfica, cómo manejar
esos datos en variables, y cómo guardar la información en un archivo de texto usando FileWriter y
BufferedWriter. Este conocimiento te permitirá crear aplicaciones que persistan información y
proporcionen una experiencia de usuario más completa.
10. Proyecto Final: Creación de una Aplicación Gráfica Simple

Objetivo

El objetivo de este proyecto final es aplicar todos los conocimientos adquiridos para desarrollar una
pequeña aplicación gráfica en Java utilizando el entorno de desarrollo NetBeans y la biblioteca Swing.
La aplicación debe capturar datos del usuario, realizar una operación aritmética y mostrar el resultado
en la interfaz gráfica. Además, se incluirán validaciones básicas y manejo de eventos para asegurar que
la aplicación sea funcional y robusta.

Requerimientos de la Aplicación

1. Capturar Datos del Usuario:

o Ingresar nombre y edad del usuario.
o Ingresar un monto para el cálculo (por ejemplo, monto para calcular IVA).

2. Realizar una Operación Aritmética:

o Calcular el IVA del monto ingresado.
o Mostrar el resultado en la interfaz gráfica.

3. Mostrar el Resultado en la Interfaz Gráfica:

o Mostrar el resultado del cálculo en un componente gráfico (por ejemplo, un JLabel).

4. Incluir Validaciones Básicas y Manejo de Eventos:

o Validar que el usuario haya ingresado datos numéricos válidos.
o Manejar eventos de clic en botones para realizar el cálculo.

Desarrollo del Proyecto

1. Crear un Nuevo Proyecto en NetBeans

1. Abrir NetBeans:
o Inicia NetBeans y selecciona "Nuevo Proyecto".

2. Seleccionar Tipo de Proyecto:

o Elige "Java" y luego "Aplicación Java con Marco de Formulario" (Java Application with Frame
Form).

3. Configurar Proyecto:
o Nombra el proyecto (por ejemplo, CalculadoraIVA).
o Selecciona la ubicación del proyecto y haz clic en "Finalizar".
2. Diseño de la Interfaz Gráfica

1. Abrir el Formulario:
o Dentro del proyecto, abre el archivo Frame1.java (o el nombre que hayas dado al
formulario).

2. Agregar Componentes al Formulario:

o Abre la paleta de componentes y arrastra los siguientes componentes al formulario:
 JLabel: Para las etiquetas "Nombre", "Edad", "Monto".
 JTextField: Para capturar el nombre, edad y monto.
 JButton: Para realizar el cálculo (etiquetado como "Calcular").
 JLabel: Para mostrar el resultado.

3. Configurar los Componentes:

o Establece los textos de las etiquetas y los tamaños de los campos de texto.
o Organiza los componentes usando el administrador de diseño (por ejemplo, GridLayout).

3. Implementación de la Lógica de la Aplicación

1. Captura de Datos y Manejo de Eventos:

o Añade un ActionListener al botón para manejar el evento de clic.

2. Código de la Aplicación:

java
Copiar código
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class Frame1 extends JFrame {

private JTextField nombreField;

private JTextField edadField;
private JTextField montoField;
private JButton calcularButton;
private JLabel resultadoLabel;

public Frame1() {
// Configuración del JFrame
setTitle("Calculadora de IVA");
setSize(400, 300);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setLayout(null);

// Crear y configurar componentes

JLabel nombreLabel = new JLabel("Nombre:");
nombreLabel.setBounds(20, 20, 100, 25);
add(nombreLabel);

nombreField = new JTextField();

nombreField.setBounds(120, 20, 250, 25);
add(nombreField);
 JLabel edadLabel = new JLabel("Edad:");
edadLabel.setBounds(20, 60, 100, 25);
add(edadLabel);

edadField = new JTextField();

edadField.setBounds(120, 60, 250, 25);
add(edadField);

JLabel montoLabel = new JLabel("Monto:");

montoLabel.setBounds(20, 100, 100, 25);
add(montoLabel);

montoField = new JTextField();

montoField.setBounds(120, 100, 250, 25);
add(montoField);

calcularButton = new JButton("Calcular IVA");

calcularButton.setBounds(20, 140, 150, 25);
add(calcularButton);

resultadoLabel = new JLabel("");

resultadoLabel.setBounds(20, 180, 350, 25);
add(resultadoLabel);

// Añadir ActionListener al botón

calcularButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
calcularIVA();
}
});

setVisible(true);
}

// Método para calcular el IVA y mostrar el resultado

private void calcularIVA() {
try {
// Captura de datos
String nombre = nombreField.getText();
String edadStr = edadField.getText();
String montoStr = montoField.getText();

// Validación de datos
if (nombre.isEmpty() || edadStr.isEmpty() || montoStr.isEmpty()) {
resultadoLabel.setText("Por favor, complete todos los campos.");
return;
}

int edad = Integer.parseInt(edadStr);

double monto = Double.parseDouble(montoStr);

if (edad < 0 || monto < 0) {

resultadoLabel.setText("Edad y monto deben ser valores
positivos.");
return;
}

// Cálculo del IVA (suponiendo una tasa del 16%)

 double iva = monto * 0.16;
double total = monto + iva;

// Mostrar el resultado
resultadoLabel.setText(String.format("Hola %s, el total con IVA es:
%.2f", nombre, total));

} catch (NumberFormatException e) {
resultadoLabel.setText("Error: Ingrese valores numéricos válidos.");
}
}

public static void main(String[] args) {

new Frame1();
}
}

Explicación del Código

1. Configuración del Formulario:

o Se crean y configuran los componentes del formulario.
o Se colocan en el formulario con posiciones y tamaños específicos.

2. Manejo de Eventos:
o Se añade un ActionListener al botón de cálculo para manejar el clic del usuario.

3. Lógica de Cálculo:
o Se capturan y validan los datos ingresados por el usuario.
o Se realiza el cálculo del IVA (asumiendo una tasa del 16%).
o Se muestra el resultado en una etiqueta.

4. Validación:
o Se validan las entradas para asegurar que no estén vacías y que los valores sean numéricos.
o Se muestran mensajes de error si los datos son incorrectos.

Conclusión

Este proyecto final integra todos los aspectos clave del desarrollo de aplicaciones gráficas en Java
utilizando Swing. A través de la creación de una aplicación que captura datos del usuario, realiza
cálculos y muestra resultados, puedes practicar el diseño de interfaces, el manejo de eventos, la
validación de datos y el almacenamiento en archivos. Este conocimiento te permitirá desarrollar
aplicaciones gráficas funcionales y robustas en Java.