Tutorial JAVA con GUI e IDE NetBeans 8.x

[CompSystems]

Para los que solo han realizado programacion con entradas/salidas ( I/O E/S) tipo texto o consola tipo primitivo DOS, es TIEMPO para iniciar a programar en interfaces de ventanas de usuario GUI. Encontré unos super video tutoriales, implica que No soy el autor de los vídeos, pero realizare el resumen de todos los vídeos, con algunos anexos y variantes propias para hacerlo mas didáctico y explicativo, para mi esto es una forma de recordar mi autoavance en el autoaprendizaje de JAVA

Si deseas un nivel básico, y programas en consola de texto visita otro hilo que he creado http://www.todopic.com.ar/foros/index.php?topic=45009.0

Autor de los super vídeo tutoriales mil gracias a Daniel López Espinoza AKA/TCC (Also Know As/También Conocido Como) Nekszer
https://www.youtube.com/user/NEKSZER

video #1 Como crear nuestra primer Ventana o GUI (Graphical User Interface/Interface Gráfica de Usuario)

/!\ USAMOS LA BIBLIOTECA swing, que es predeterminada en java, hay otras bibliotecas que hacen lo mismo, pero iniciaremos con SWING, tal ves al comienzo no se entienda todo, pero la idea es avanzar  lo mas que se pueda ya que en en cada siguiente video se despejan las dudas que quedaron en el anterior

Resumen: El primer ejemplo consiste en colocar un botón y cada ves que se lo pulse mostrar un contador de pulsaciones

Primer paso descargar e instalar el IDE NetBeans https://netbeans.org/ no tiene misterio la instalación por eso no se anexara un video explicativo, NetBeans IDE también esta disponible en ESPAÑOL

PROYECTO #1 Componente o controlador tipo BUTTOM / BOTÓN y un uso simple del mismo

COMO construir PASO A PASO un proyecto con NETBEANS

PASO 0: iniciar el IDE NetBeans

PASO 0.1: luego crear un nuevo proyecto Menu (File > New Project) aparece una primer ventana para seleccionar el tipo de proyecto

sobre el listado de CATEGORIES seleccionar: JAVA
sobre el listado PROJECTS seleccionar JAVA APPLICATION

RESUMEN

CHOOSE PROJECT
CATEGORIA: JAVA
TIPO DE PROYECTO : JAVA APPLICATION

luego oprimir [NEXT]

PASO 0.2: La 2da ventana desplegada hace referencia al nombre y ubicación  del proyecto
sobre el campo PROJECT NAME: colocar un nombre por ejemplo GUI_1, se recomienda que inicie en Mayúscula
en PROJECT LOCATION, en mi caso lo almaceno en la carpeta Documentos, subfolder NetBeansProjects

C:\Users\<USER NAME>\Documents\NetBeansProjects\

En PROJECT FOLDER, escribir el subdirectorio del proyecto, se recomienda que cada proyecto este en un folder diferente.

C:\Users\<USER NAME>\Documents\NetBeansProjects\GUI_1

Sobre el campo CREATE MAIN CLASE, para este primer ejemplo deseleccionarlo para que no incorpore el archivo de clase principal.

PASO 1: en el lado izquierdo del IDE visualizar la ventana de titulo PROJECTS que muestra un árbol de proyectos recientemente creados, si este es el primer proyecto, solo aparecerá las siguientes ramas /GUI_1/SOURCE PACKAGES (este ultimo se almacena en el disco duro como src, ubicado luego de nombre del proyecto/GUI_1/src)

C:\Users\<USER NAME>\Documents\NetBeansProjects\GUI_1\src

1.1: crear un nuevo contenedor de paquetes para localizar y ordenar mejor las CLASEs de este proyecto, sobre la rama SOURCE PACKAGES dar clic derecho para desplegar una lista vertical de menús, seleccionar NEW/JAVA_PACKAGE y el campo NAME colocar por ejemplo paquete1 el resto de campos conservarlos como están, en futuros post se explicara el uso de modificarlos

2: luego crear una clase de tipo JFRAME FORM nombrarla como Frm_MiPrimerVentana
el archivo creado es Frm_MiPrimerVentana.java que pertenece al PAQUETE LLAMADO paquete1

FORM en castellano es HORMA o Molde que da forma a la ventana, el uso de FORM es un Contenedor de controles, como botón etc
se usa el Prefijo: Frm para denotar la clase de este tipo, al crear una HORMA en la ventana de edición tenemos una pestaña con el nombre de la clase en este caso  Frm_MiPrimerVentana.java que a su ves contiene 3 subpestañas [SOURCE][DESING][HISTORY]

resumen:

ARBOL del Proyecto
GUI_1
--SOURCE PACKAGES
----PAQUETE1
------Frm_MiPrimerVentana (C:\Users\<USER NAME>\Documents\NetBeansProjects\GUI1\src\paquete1\frm_MiPrimerVentana.java)
 
[DESING]  es una VENTANA de DISEÑO o mejor de EDICIÓN GRÁFICA, donde podemos empezar a colocar O ARRASTAR objetos como botones (teclas virtuales), menús, etc. para crear nuestra tan anhelada primer GUI, algunos libros lo llaman programacion a golpe de ratón, pero eso no es totalmente cierto, pues hay que digitar y crear subrutinas o métodos que hagan o efectúen cosas, y ello se hace en la pestaña  [SOURCE]. La ventana de edición gráfica asocia una archivo de extensión .FORM  que contiene el código gráfico escrito en lenguaje XML

en este caso es
C:\Users\<USER NAME>\Documents\NetBeansProjects\GUI1\src\paquete1\Frm_MiPrimerVentana.FORM

Al lado de la pestaña [DESING] esta la  pestaña  denominada [SOURCE] que contiene el código fuente en JAVA del archivo Frm_MiPrimerVentana.java, podemos decir que contiene la GUI en instrucciones de texto o lenguaje JAVA

Código simplificado de Mi_primer_ventana.java

//

Código: Java

1. //Main File: Frm_MiPrimerVentana.java
2. //Info: uso del control BUTTOM
3. // Nombre del paquete al cual pertenece el archivo
4. package paquete1;
5.  
6. // Nombre de la clase igual al nombre del archivo pero sin extensión (Frm_MiPrimerVentana)
7. // Frm_MiPrimerVentana hereda de javax.swing.JFrame  en futuros post se explicara la Herencia
8. // acceso publico
9. public class Frm_MiPrimerVentana extends javax.swing.JFrame {
10.    
11.     // Método Constructor, acceso publico y nombre igual a la clase
12.     public Frm_MiPrimerVentana() {
13.         // initComponents() es un método o función que inicializa los objetos controladores de la GUI
14.         initComponents();
15.     }
16.    
17.    // Método para inicializar los controladores, método creado por el IDE, también se puede crearlo manualmente, en próximos vídeos se abarcara esta opción
18.                        
19.     private void initComponents() {
20.     ...
21.     }
22.  
23.  
24.     // Variables declaration - do not modify                    
25.     private javax.swing.JButton btnContador;
26.     // End of variables declaration                  
27. }
28. //

3: dar un clic sobre la pestaña [DESING], se muestra en el lado derecho del IDE, una la pestaña [PALETTE] (paleta de controladores y contenedores) seleccionar BUTTOM (tecla virtual), y arrastrarlo a cualquier posición de la ventana [DESING]
/!\ en los bordes del botón se puede expandir o comprimir la dimensión del rectángulo del botón, expandirlo un poco horizontalmente para visualizar un texto largo que colocaremos en el.

4: con clic derecho sobre el botón creado se despliega un menú, seleccionar el menú EDIT TEXT y renombrarlo del nombre original que es JButtom1 (javaButtom#) por ejemplo a CONTAR PULSACIONES este nombre es el NOMBRE VISIBLE del boton, mientras como veremos posteriormente existe el nombre interno de programacion

5: renombrar el identificador de programacion, (clic derecho sobre el botón creado ...) desde el submenú CHANGE VARIABLE NAME ... de JButtom1 a por ejemplo btnContador con el propósito de identificarlo mas fácilmente dentro del JAVA SOURCE CODE

Componente/Controlador: Botón de comando
Nomenclatura: Button, interno JButtom#
Prefijo para el identificador/atributo/variable: btn (inicia en minúscula)
Uso: Ejecuta un comando o una acción.


Notamos que en el final del archivo Frm_MiPrimerVentana.java  se agrego la siguiente sentencia

//

Código: Java

1. private javax.swing.JButton btnContador; //

y dentro del método private void initComponents() { ...

aparece la sentencia que asigna el texto al botón, ademas de su posición y otros, que por ahora no nos interesa pues lo manejamos a nuestro gusto desde la subpestaña DESING

//

Código: Java

1. btnContador.setText("CONTAR PULSACIONES");//

Ahora dentro de nuestra primer acción a realizar, se requiere que al oprimir ese primer botón se efectué un comando, código o evento, por ejemplo algo demasiado simple, puede ser que contabilice el numero de pulsaciones realizadas

5.1: pasar de la pestaña [DESING] a la pestaña [SOURCE] y explorar el código fuente de Mi_primer_ventana.java

6: Al dar doble clic sobre el botón OBSERVAMOS que se agrega automáticamente al archivo Frm_MiPrimerVentana.java  el método del evento o acción realizada por el botón, este método SE DEFINE COMO btnContadorActionPerformed(...) agrega un POSTFIJO al nombre de variable (ActionPerformed/AcciónRealizada), por ahora no nos interesa los parámetros de este método

código del evento del botón dentro de Frm_MiPrimerVentana.java
//

Código: Java

1. // Método para el evento del botón que se crea una sola ves, al dar doble clic sobre el botón
2.     private void btnContadorActionPerformed(java.awt.event.ActionEvent evt) {                                            
3.         // Código a digitar por nosotros
4.     }
5. //

Ahora incluiremos el código para el contador de pulsaciones

//

Código: Java

1. int contador = 1;
2.     private void btnContadorActionPerformed(java.awt.event.ActionEvent evt) {                                            
3.         String mensajeContador = "contador actual en: " + contador;
4.         btnContador.setText(mensajeContador);
5.         contador = contador + 1;
6.     }  
7. //

En el cuerpo del evento del botón es el que esta entre corchetes, la sentencia btnContador.setText(mensaje); usa setText sobre el identificador o atributo del botón

el botón [PLAY] de la barra de herramientas del IDE, compila y ejecuta, nuestra primer ventana que contiene un botón y al dar el primer clic sobre ese botón despliega dentro del mismo el valor de 1, luego al segundo clic 2, ... 

Conclusión: Hemos agregado nuestro primer CONTROLADOR o Componente (Botón) a la GUI. ejemplo muy sencillo pero solo es el inicio

¿Que os parece este resumen que he realizado del vídeo? es comprensible, entusiasma a iniciarse en java ... ? sugerencias, ideas ...

[CompSystems]

Saltando a un vídeo del mismo autor que se relaciona con el ejemplo anterior, vamos a colocar un titulo a nuestra primera GUI y agregar un botón para cerrar la ventana y programar una función de lanzamiento de la ventana y como crear el archivo ejecutable

VIDEO #8 Como agregar un Titulo a la barra de títulos de nuestra primera ventana, como agregar un subtitulo, como programar un Botón Cerrar y como iniciar o desplegar la ventana

Un subtitulo es un texto dentro de la ventana, para esto se usa un nuevo controlador llamado jLABEL# o etiqueta

Componente/Controlador: Etiqueta de texto
Nomenclatura: LABEL, interno jLABEL#
Prefijo para el identificador/atributo/variable: lbl (inicia en minúscula)
Uso: Presenta un texto fijo o modificable, ademas en futuras explicaciones se mostraran otros usos como colocar imágenes

0: Arrastar un LABEL al DESING de Frm_MiPrimerVentana, con clic derecho y EDIT TEXT, digitar un subtitulo como "Uso de nuestro Primer Botón", cambiamos la variable de programacion de jLABEL1 a lblEtiqueta1, aunque esta aun no se utilizara en este ejemplo, sirve para adquirir practica en el remombramiento de las variables creadas automáticamente por el IDE

Luego se necesita crear una CLASE principal, para esto se requiere eliminar el método principal (main) del ejemplo anterior que esta en el archivo Frm_MiPrimerVentana.java

Buscar dentro de Frm_MiPrimerVentana.java  el método principal y eliminarlo

Código: Java

1. public static void main(String args[]) {... }

1: Crear una nueva CLASE PRINCIPAL, en el lado izquierdo del IDE visualizar la ventana PROJECTS, sobre la rama SOURCE PACKAGES dar clic derecho para desplegar una lista vertical de menús, seleccionar NEW/JAVA_CLASS y el campo NAME colocar por ejemplo ClMain,  mantener intactos los campos LOCATION y PACKAGE, finalmente  se crea un nuevo archivo ClMain.java que contiene lo siguiente

ARBOL del Proyecto
GUI_1
--SOURCE PACKAGES
----PAQUETE1
------Frm_MiPrimerVentana
------ClMain

//

Código: Java

1. package paquete_1;
2. public class  ClMain {
3.    
4. }
5. //

2: agregamos el método principal  en el cuerpo de la clase

public static void main(String[] args) {    }

TIP/CONSEJO: usar  LA SIGLA (letra inicial de un conjunto de palabras) psvm luego tecla TAB para pegar rápidamente (atajo por teclas o HOT-KEYS ) la plantilla anterior

psvm[TAB] despliega public static void main(String[] args) {    }

la lista de atajos se puede ver en el PDF (shortcuts.pdf) que esta dentro del menú HELP/KEYBOARD SHORTCUTS CARD

TIP/CONSEJO: cambiar el nombre identificador args por uno mas reconocible como argumentos_de_entrada

public static void main(String argumentos_de_entrada[]){  }

//

Código: Java

1. package paquete_1;
2. public class  ClMain {
3.     public static void main(String argumentos_de_entrada[]){  }
4. }
5. //

3: instrucciones para mostrar un titulo en la barra de títulos, centrar y visualizar la ventana

//

Código: Java

1. //File: ClMain.java
2. package paquete1;
3.  
4. public class ClMain {
5.     // Método Principal
6.     public static void main(String argumentos[]) {
7.         // Crea un objeto de nombre "win1_obj" apartir de la clase FORM: Frm_MiPrimerVentana
8.         Frm_MiPrimerVentana win1_obj = new Frm_MiPrimerVentana();
9.         // Coloca el titulo en la barra de títulos de la ventana del objeto "win1_obj"
10.         win1_obj.setTitle("Nuestra primer ventana en JAVA");
11.         // Instrucción para centrar la ventana "win1_obj"
12.         win1_obj.setLocationRelativeTo(win1_obj);
13.         // Permanece visible la ventana
14.         win1_obj.setVisible(true);
15.      }
16. }//

Luego agreguemos un segundo botón para cerrar la ventana , con nombre visible CERRAR, y nombre identificador de programación,  btnCerrar

la función creada por Netbeans es

//

Código: Java

1. private void btnCerrarActionPerformed(java.awt.event.ActionEvent evt) {                                          
2.        
3.     }
4. //

agregamos la sentencia para cerrar la ventana, la cual es System.exit(0);

//

Código: Java

1. ...
2.    btnCerrar.setText("Cerrar");
3.    ...
4.    private void btnCerrarActionPerformed(java.awt.event.ActionEvent evt) {                                          
5.         System.exit(0);
6.     }
7.    private javax.swing.JButton btnCerrar;
8. //

Continuamos creando el archivo ejecutable o DISTRIBUIBLE (*.JAR) del anterior ejemplo, en la barra de herramientas hay un icono con imagen de [martillo y escoba] lo oprimimos y genera el ejecutable en mi caso en la siguiente ruta

"C:\Users\<user name>\Documents\NetBeansProjects\GUI_1\dist\GUI_1.jar"

GUI_1
--dist
----GUI_1.jar

ya podemos ejecutar compartir =) la primer aplicación tipo ventana GUI_1.jar

Listo así de simple es JAVA, pues c++ me tenia loco con el manejo de PUnTEros

Conclusión: Hemos agregado un segundo CONTROLADOR o Componente (LABEL) a la GUI como subtitulo, hemos agregado un titulo, centrar la ventana, iniciar la ventana y crear el ejecutable 

[KILLERJC]

Excelente, no te lo agradecir en el otro por que mucho JAVA no toco. Por no decir que no toco nada xD. Sino me volveria loco con tantos lenguajes

[CompSystems]

Los grandes genios han sido locos o han terminados chiflados

Como un extra del primer ejemplo, podemos hacer que mientras no se pulse el botón [CONTAR PULSACIONES] esta deshabilitado/apagado/o atenuado el botón [CERRAR]. Al inicio del lanzamiento de la ventana debe aparecer el botón CERRAR atenuado,  instrucción  que debe incorporarse en el método constructor que inicializa los componentes 

public Frm_MiPrimerVentana() {
        // initComponents() es un método o función que inicializa los objetos controladores de la GUI
        initComponents();
        btnCerrar.setEnabled(false);
    }

luego en la primer pulsacion se lo debe activar btnCerrar.setEnabled(true);

private void btnContadorActionPerformed(java.awt.event.ActionEvent evt) {                                           
        String mensaje = "contador actual en: " + contador;
        btnContador.setText(mensaje);
        contador = contador + 1;
        btnCerrar.setEnabled(true);
 }


Ahora un nuevo ejemplo y vídeo, que permite entrar datos como Nombre y Edad dentro de una casilla o campo de entrada

VIDEO #9 Uso de controles TextField/Caja-CampoDeTexto y JOptionPane/Caja-PanelÓMarcoDeDiálogo]

Otro uso de los LABELS es etiquetar otros componentes o controladores, para mostrar al usuario que hace o acción realiza, podemos crear un nuevo proyecto GUI_2 o modificar el anterior, si solo modificamos eliminamos el botón CONTADOR y subtitulo, en este caso continuare sobre el mismo proyecto GUI_1

0: Arrastramos un nuevo campo ETIQUETA o LABEL (hacia DESING) para colocar un subtitulo en la ventana, damos doble clic sobre el campo jLabel1 y lo renombramos como "ENTRADA DE DATOS POR CAMPOS O CASILLAS",  cambiamos también la variable de programacion CHANGE VARIABLE NAME ... a lblEtiqueta1

Notamos que en el final del archivo Frm_MiPrimerVentana.java  se agrego la siguiente sentencia

//

Código: Java

1. private javax.swing.JLabel lblEtiqueta1;; //

y dentro del método private void initComponents() { ...

aparece la sentencia que asigna el texto a la etiqueta

//

Código: Java

1. lblEtiqueta1.setText("ENTRADA DE DATOS POR CAMPOS O CASILLAS");//

1: uso de un nuevo componente TEXT_FIELD / CAJA-CampoDeTexo: Proporciona un área comúnmente para escribir (entrada de datos) o también presentar texto (salida de datos).

Componente/Controlador: Campo de texto
Nomenclatura: TEXT_FIELD, interno jTextField#
Prefijo para el identificador/atributo/variable: fld ó tFld (inicia en minúscula)
Uso: Proporciona entrada/salida de datos (información)
Entrada: un texto/numero
Salida: cada ves que se da [enter] sobre el campo se almacena la entrada como texto en el ID de programación

Arrastramos un campo o rectángulo de entrada de datos TEXT_FIELD (hacia DESING)  para que un usuario pueda entrar o digitar la petición del mismo, esa petición requiere una etiqueta que puede ser "ENTRE SU NOMBRE", para esto se necesita arrastrar una nueva etiqueta jLabel

aproximadamente se visualizaría la ventana DESING de la siguiente manera:

una etiqueta y un campo de entrada

ENTRE SU NOMBRE [ _______ ]

se puede seleccionar la línea anterior copiarla y pegarla dentro de la ventana de diseño, para simplificar los pasos de arrastrar

una segunda entrada puede ser

ENTRE SU EDAD [ _______ ]

3: renombrar IDs de programacion los campos anteriores, clic derecho sobre cada uno....

otra manera de realizar esto, es modificando los parámetros o valores por campos que se muestran en la parte derecha de la ventana DESING, pestaña [JFrame Properties] Submenus [Properties] [Bindins][Events][Codigo]

si seleccionamos del campo de "ENTRE SU NOMBRE" en la pestaña CODE se muestra
...
Variable Name: jTextField1 Renombrar por ejemplo a tFldNombre
Variable Modifiers: private Cambiar el acceso a PUBLIC-STATIC para usarlo desde una clase externa que usaremos para definir los metodos de control de entrada y salida de datos, puede ser llamada por ejemplo ClMetodos_ES (E/S: Entrada-Salida)
...

realicemos algo similar sobre el campo de "ENTRE SU EDAD" debemos primero seleccionar este campo y en la pestaña CODE se muestra

Variable Name: jTextField2 Renombrar por ejemplo a tFldEdad
Variable Modifiers: private Cambiar el acceso a PUBLIC-STATIC para usarlo desde una clase externa ClMetodos_ES.java

4: Creamos ahora una nueva clase de nombre ClMetodos_ES.java

File: ClMetodos_ES.java
//

Código: Java

1. //File: ClMetodos_ES.java
2. package paquete1;
3. public class ClMetodos_ES {
4.    
5. } //

Resumen del ÁRBOL del Proyecto
GUI_1
--SOURCE PACKAGES
----PAQUETE1
------Frm_MiPrimerVentana
------ClMain
------ClMetodos_ES

4.1 agregamos el constructor
TIP/CONSEJO: con clic derecho sobre la venta de edición de texto, se despliega el menú INSERT CODE .. Constructor

//

Código: Java

1. //File: ClMetodos_ES.java
2. public class ClMetodos_ES {
3.     public ClMetodos_ES() {
4.        
5.     }
6. } //

Ahora digitaremos los códigos con los métodos de captura datos entrados en los campos fldName, fldEdad y los replicaremos en una caja de dialogo como salida de información

//

Código: Java

1. //File: ClMetodos_ES.java
2.  
3. import javax.swing.JOptionPane;
4.  
5. // Clase de manipulación de datos entrada salida
6. public class ClMetodos_ES {
7.  
8.     // Atributos o variables para contener los datos entrados en los campos fldName, fldEdad
9.     String str_nombre = "";
10.     Integer int_edad = 0;
11.  
12.     // Constructor
13.     public ClMetodos_ES() {
14.  
15.     }
16.  
17.     // Método para almacenar los datos entrados en los campos fldName, fldEdad para luego almacenarlos en str_nombre y int_edad
18.     public void metCapturarDatos() {
19.        // Como el TextField CAPTURA el dato como TEXTO o cadena debe ser STRING para NOMBRE (NO HAY MÉTODO DE CONVERSION DE TIPOS)
20.         str_nombre = Frm_MiPrimerVentana.tFldNombre.getText();
21.  
22.         // Como EDAD debe ser valor numérico, y como TextField captura el dato como TEXTO, hay que convertirlo a ENTERO para ser almacenado como valor numérico EDAD valido
23.         int_edad = Integer.parseInt( Frm_MiPrimerVentana.tFldEdad.getText() );
24.        }
25.  
26.     // Método para desplegar datos de salida str_nombre y int_edad
27.     public void metMostarDatos() {
28.         // uso de showMessageDialog como una caja de dialogo emergente
29.         JOptionPane.showMessageDialog(null, "El nombre es " + str_nombre + "\n la edad es " + int_edad, "Informacion de entrada", JOptionPane.PLAIN_MESSAGE);
30.  
31.       // El primer dato de showMessageDialog, por ahora es NULL, en otros post se mostrara otro uso
32.     }
33.    
34. } //

5: Agregamos un segundo botón (de nombre visible "MostrarDatos" y de nombre de progracion btnMostrarDatos) que replique los datos entrados

 Con el código anterior ya podemos crear un objeto y utilizar sus métodos, el objeto se crea después del constructor del archivo File: frm_MiPrimerVentana.java

//

Código: Java

1. // Método Constructor, acceso publico y nombre igual a la clase
2.     public Frm_MiPrimerVentana() {
3.         // initComponents() es un método o función que inicializa los objetos controladores de la GUI
4.         initComponents();
5.     }
6.     // objeto de nombre "metodos_ES_obj1" creado segun clase ClMetodos_ES
7.     // Finalidad llamar a los metodos metCapturarDatos() y metodos_ES_obj1.metMostarDatos() dentro del metodo btnMostrarDatosActionPerformed
8.     ClMetodos_ES metodos_ES_obj1 = new ClMetodos_ES();
9. ...
10.     private void btnMostrarDatosActionPerformed(java.awt.event.ActionEvent evt) {                                                
11.         metodos_ES_obj1.metCapturarDatos();
12.         metodos_ES_obj1.metMostarDatos();
13.     }  
14.      }//

   

Listo ahora se muestra un segundo botón que despliega una segunda ventana emergente de información con los datos de entrada
Próximamente se optimizara el código para detectar datos inválidos y campos vacíos

En este ejemplo los métodos  fldNameActionPerformed y fldEdadActionPerformed no se usan, ya que la clase ClMetodos_ES se encarga de obtener los datos, próximamente incluiré una versión alternativa de este código

  private void tFldNombreActionPerformed(java.awt.event.ActionEvent evt) {                                       
       
    }                                       

    private void tFldEdadActionPerformed(java.awt.event.ActionEvent evt) {                                       
       
    } 


código completo de


//

Código: Java

1. //Main File: frm_MiPrimerVentana.java
2. //Info: uso del control BUTTOM, TEXTFIELD & LABEL
3. // Nombre del paquete al cual pertenece el archivo
4. package paquete1;
5.  
6. // Nombre de la clase igual al nombre del archivo pero sin extension (frm_MiPrimerVentana)
7. // frm_MiPrimerVentana hereda de javax.swing.JFrame  en futuros post se explicara la Herencia
8. // acceso publico
9. public class Frm_MiPrimerVentana extends javax.swing.JFrame {
10.  
11.     // Método Constructor, acceso publico y nombre igual a la clase
12.     public Frm_MiPrimerVentana() {
13.         // initComponents() es un método o función que inicializa los objetos controladores de la GUI
14.         initComponents();
15.     }
16.     // objeto de nombre "metodos_ES_obj1" creado segun clase ClMetodos_ES
17.     // Finalidad llamar a los metodos metCapturarDatos() y metodos_ES_obj1.metMostarDatos() dentro del método btnMostrarDatosActionPerformed
18.     ClMetodos_ES metodos_ES_obj1 = new ClMetodos_ES();
19.    
20.    
21.     // Método para inicializar los controladores, método creado por el IDE, también se puede crearlo manualmente, en próximos vídeos se abarcara esta opción  
22.                    
23.     private void initComponents() {
24.  
25.         btnContador = new javax.swing.JButton();
26.    ....
27.     }                    
28.  
29.                                        
30.  
31.     private void btnCerrarActionPerformed(java.awt.event.ActionEvent evt) {                                          
32.         System.exit(0);
33.     }                                        
34.  
35.     private void tFldNombreActionPerformed(java.awt.event.ActionEvent evt) {                                        
36.        
37.     }                                      
38.  
39.     private void tFldEdadActionPerformed(java.awt.event.ActionEvent evt) {                                        
40.        
41.     }                                      
42.  
43.     private void btnMostrarDatosActionPerformed(java.awt.event.ActionEvent evt) {                                                
44.         metodos_ES_obj1.metCapturarDatos();
45.         metodos_ES_obj1.metMostarDatos();
46.     }                                              
47.  
48.    
49.  
50.     // Variables declaration - do not modify                    
51.     private javax.swing.JButton btnCerrar;
52.     private javax.swing.JButton btnMostrarDatos;
53.     public static javax.swing.JTextField tFldEdad;
54.     public static javax.swing.JTextField tFldNombre;
55.     private javax.swing.JLabel lblEdad;
56.     private javax.swing.JLabel lblName;
57.     // End of variables declaration                  
58. }//

nos vemos en el siguiente resumen

[CompSystems]

Resumen vídeo #10 ETIQUETAS (LABELs) Y ARREGLOS ESTATICOS

En estos dos vídeos se muestra como cambiar el valor de una etiqueta y como ingresar datos en un arreglo para simular un registro

0: 2 ids para identificar el máximo numero de "casillas o elementos" del registro y posición actual del registro
    public static Integer int_reg_max = 3;
    public static Integer int_pos_registro = 0;

1: se crean dos variables extra con prefijo "a" ARRAY para diferenciarlas de los contenedores de un solo valor
    static String astr_nombre[] = new String[int_reg_max];
    static Integer aint_edad[] = new Integer[int_reg_max];

2: Se coloca una nueva etiqueta de nombre lblContadorDeRegistro, que mostrara el registro actual introducido

El método CAPTURAR_DATOS se expandioconsiderablemente con respecto al anterior, cada NOMBRE y EDAD se coloca dentro del arreglo, se verifica si se desborda el registro y se lanza mensajes de advertencia

Código: Java

1. // Metodo para almacenar los datos entrados en str_nombre y int_edad
2.     public void metCapturarDatos() {
3.         if (int_pos_registro < int_reg_max) {
4.             // De la clase FrmMiPrimerVentana, identicador o atributo fldName se EXTRAE su valor cadena contenido
5.             str_nombre = FrmMiPrimerVentana.fldName.getText();
6.             // igualmente para el atributo fldEdad
7.             // pero como el FieldText almacena el dato como TEXTO o cadena hay que convertirlo a ENTERO para ser almacenado como valor numerico en EDAD
8.             int_edad = Integer.parseInt(FrmMiPrimerVentana.fldEdad.getText());
9.  
10.             // cada valor se ingresa al registro
11.             astr_nombre[int_pos_registro] = str_nombre;
12.             aint_edad[int_pos_registro] = int_edad;
13.  
14.             // se incrementa la posicion del registro
15.             int_pos_registro++;
16.             // se modifican los valores de texto de los LABELs o ETIQUETAS para mostrar en que registro se esta almacenando
17.             if (int_pos_registro < int_reg_max) {
18.                 // De la clase FrmMiPrimerVentana, identicador o atributo lblContadorDeRegistro se FIJA o almacena una cadena "#del registro + 1, de N maximos posibles"
19.                 FrmMiPrimerVentana.lblContadorDeRegistro.setText(String.valueOf(int_pos_registro + 1) + " de " + String.valueOf(int_reg_max));
20.             } else {
21.                 FrmMiPrimerVentana.lblContadorDeRegistro.setText("Registro lleno");
22.             }
23.         } else {
24.             JOptionPane.showMessageDialog(null, "Registro lleno");
25.         }
26.     }

El MÉTODO DE MOSTRAR DATOS, no cambio mucho, solo se usan dos variable extra para contener cada elemento del registro

Código: Java

1. // Metodo para desplegar datos str_nombre y int_edad
2.     public void metMostarDatos() {
3.         if (Objects.equals(int_pos_registro, 0)) {
4.             JOptionPane.showMessageDialog(null, "Registro vacio");
5.         } else {
6.             // uso de showMessageDialog como una caja de dialogo
7.             for (int int_pos = 0; int_pos < int_reg_max; int_pos++) {
8.                 str_nombre = astr_nombre[int_pos];
9.                 int_edad = aint_edad[int_pos];
10.                 JOptionPane.showMessageDialog(null, "El nombre del usuario " + (int_pos + 1) + " es: " + str_nombre + "\n su edad es " + int_edad, "Informacion de entrada del registro", JOptionPane.PLAIN_MESSAGE);
11.             }
12.         }
13.     }

el archivo final ClControl_ES.java

//

Código: Java

1. // File ClControl_ES.java
2. package paquete_1;
3.  
4. import java.util.Objects;
5. import javax.swing.JOptionPane;
6.  
7. // Clase de manipulaciion de datos entrada salida
8. public class ClControl_ES {
9.  
10.     // Atributos o variables para contener los datos entrados en los campos fldName, fldEdad
11.     static String str_nombre = "";
12.     static Integer int_edad = 0;
13.    
14.      public static Integer int_reg_max = 3;
15.     public static Integer int_pos_registro = 0;
16.  
17.     static String astr_nombre[] = new String[int_reg_max];
18.     static Integer aint_edad[] = new Integer[int_reg_max];
19.  
20.    
21.  
22.     public ClControl_ES() {
23.     }
24.  
25.     // Metodo para almacenar los datos entrados en str_nombre y int_edad
26.     public void metCapturarDatos() {
27.         if (int_pos_registro < int_reg_max) {
28.             // De la clase FrmMiPrimerVentana, identicador o atributo fldName se EXTRAE su valor cadena contenido
29.             str_nombre = FrmMiPrimerVentana.fldName.getText();
30.             // igualmente para el atributo fldEdad
31.             // pero como el FieldText almacena el dato como TEXTO o cadena hay que convertirlo a ENTERO para ser almacenado como valor numerico en EDAD
32.             int_edad = Integer.parseInt(FrmMiPrimerVentana.fldEdad.getText());
33.  
34.             // cada valor se ingresa al registro (arreglo)
35.             astr_nombre[int_pos_registro] = str_nombre;
36.             aint_edad[int_pos_registro] = int_edad;
37.  
38.             // se incrementa la posicion del registro
39.             int_pos_registro++;
40.             // se modifican los valores de texto de los LABELs o ETIQUETAS para mostrar en que registro se esta almacenando
41.             if (int_pos_registro < int_reg_max) {
42.                 // De la clase FrmMiPrimerVentana, identicador o atributo lblContadorDeRegistro se FIJA o almacena una cadena "#del registro + 1, de N maximos posibles"
43.                 FrmMiPrimerVentana.lblContadorDeRegistro.setText(String.valueOf(int_pos_registro + 1) + " de " + String.valueOf(int_reg_max));
44.             } else {
45.                 FrmMiPrimerVentana.lblContadorDeRegistro.setText("Registro lleno");
46.             }
47.         } else {
48.             JOptionPane.showMessageDialog(null, "Registro lleno");
49.         }
50.     }
51.  
52.     // Metodo para desplegar datos str_nombre y int_edad
53.     public void metMostarDatos() {
54.         if (Objects.equals(int_pos_registro, 0)) {
55.             JOptionPane.showMessageDialog(null, "Registro vacio");
56.         } else {
57.             // uso de showMessageDialog como una caja de dialogo
58.             for (int int_pos = 0; int_pos < int_reg_max; int_pos++) {
59.                 str_nombre = astr_nombre[int_pos];
60.                 int_edad = aint_edad[int_pos];
61.                 JOptionPane.showMessageDialog(null, "El nombre del usuario " + (int_pos + 1) + " es: " + str_nombre + "\n su edad es " + int_edad, "Informacion de entrada del registro", JOptionPane.PLAIN_MESSAGE);
62.             }
63.         }
64.     }
65.  
66. } //

en el archivo de nuestra primera ventana FrmMiPrimerVentana.JAVA los métodos de los EVENTOS de los botones INGRESAR REGISTRO Y MOSTRAR llaman a los métodos del archivo ClControl_ES.java

Código: Java

1. // objeto creado segun clase clControl_ES
2.     ClControl_ES Control_ES_obj1 = new ClControl_ES();
3. private void btnCapturarDatos_ActionPerformed(java.awt.event.ActionEvent evt) {                                                  
4.         Control_ES_obj1.metCapturarDatos();
5.         if (int_pos_registro < ClControl_ES.int_reg_max) {
6.             // despues de capturar el dato ingresado se limpia los campos de entrada
7.             FrmMiPrimerVentana.fldName.setText("");
8.             FrmMiPrimerVentana.fldEdad.setText("");
9.         }
10.     }                                                
11.  
12.     private void btnMostrarActionPerformed(java.awt.event.ActionEvent evt) {                                          
13.         Control_ES_obj1.metMostarDatos();
14.     }

[PalitroqueZ]

excelentes tutoriales CompSystems

yo varias veces he intentado dedicarme de lleno al JAVA, pero que va, hay algo en el diseño de las interfaces que no termina de convencerme, recuerdo que hace tiempo me topé con unas librerías que hacían que mejorara notablemente el aspecto gráfico, pero era más complicado y lo dejé hasta ahí.

pero de todas formas son muy instructivos los videos que traes, Gracias por compartirlo. 

[CompSystems]

los últimos IDEs de lenguaje orientados a objetos son muy "inteligentes" en especial NetBeans, hace unos años atrás, era mas difícil crear GUIs, ahora traen buena ayuda en tiempo real de codificación, super  herramientas de edición, etc...

del ejemplo anterior se mejorara por ejemplo si el registro se llena, el botón de (INGRESAR un nuevo dato) debe desactivase, verificar tipos de datos de entrada

VIDEO #11 Arreglos dinámicos ARRAYLIST

Ejemplo mostrando la forma de crear un campo o atributo o identificador tipo ARRAYLIST y suso de los métodos INSERTAR (ADD) y EXTRAER (GET)
//

Código: Java

1. // para poder usar arreglos dinámicos se requiere la siguiente sentencia
2. import java.util.ArrayList;
3. // para poder usar showMessageDialog se requiere la siguiente sentencia
4. import javax.swing.JOptionPane;
5.  
6. public class clMain {
7.    
8.     // 1: CAMPOS
9.     // Identificadores instancia de la clase clMain
10.     // Sentencia para crear un arreglo dinámico int_arregloDinamico
11.     ArrayList<Integer> int_arregloDinamico = new ArrayList();
12.  
13.    
14.     // 2: CONSTRUCTOR
15.     // no se necesita
16.  
17.     // 3: MÉTODOS
18.     // 3.1 Principal
19.     public static void main(String[] args) {
20.         // se crea un objeto denominado arregloDim1
21.         clMain arregloDim1 = new clMain();
22.        
23.         // se usan los metodos
24.         // insertamos dos valores
25.         arregloDim1.metInsertarDatos(9);
26.         arregloDim1.metInsertarDatos(8);
27.  
28.         arregloDim1.metMostrarDatos();
29.  
30.     }
31.    
32.     // 3.2 insertarDatos
33.     public void metInsertarDatos(int int_dato) {
34.         int_arregloDinamico.add(int_dato);
35.     }
36.  
37.     // 3.2 mostrar Datos
38.     public void metMostrarDatos() {
39.         for (int i = 0; i < int_arregloDinamico.size(); i++) {
40.             JOptionPane.showMessageDialog(null, "pos " + i + " = " + int_arregloDinamico.get(i));
41.         }
42.     }
43.  
44. }//

[CompSystems]

VIDEO#12 APLICACIÓN DEL VÍDEO# 11 calculo de la MEDIA

0: Creamos un proyecto,

CATEGORIA: JAVA
PROYECTO TIPO: JAVA APPLICATION
NOMBRE: ClMedia_Main
CREATE MAIN CLASS: paquete1.ClMedia_Main , significa que se creara un PAQUETE: paquete1, CLASE: ClMedia_Main
se crea un archivo de nombre ClMedia_Main.java que contiene las siguientes lineas

Código: Java

1. package paquete1;
2.  
3. public class ClMedia_Metodos {
4.  
5.     public static void main(String[] args) {
6.        
7.     }
8.    
9. }

1: ahora sobre el mismo PACKAGE creamos un nuevo archivo JFRAME_FORM para codificar la GUI
ClassName: Media_GUI

 se crea un archivo de Media_GUI.java que contiene las siguientes líneas

Código: Java

1. package paquete1;
2.  
3. public class ClMedia_GUI extends javax.swing.JFrame {
4.  
5.     // 1: CAMPOS
6.     // Identificadores instancia de la clase ClMedia_Metodos
7.     Integer int_pos_registro = 0;
8.  
9.     public ClMedia_GUI() {
10.         initComponents();
11.     }
12.  
13.     ClMedia_Metodos Media_obj1 = new ClMedia_Metodos();
14.  
15.     private void btn_agregarDatoActionPerformed(java.awt.event.ActionEvent evt) {                                                
16.         // Se transfiere al metodo el valor convertido de cadena a double
17.         Media_obj1.metAgregarDatos(Double.parseDouble(fldDato.getText()));
18.         // se incrementa la posicion del registro
19.         int_pos_registro++;
20.         lblContadorDeRegistro.setText(String.valueOf(int_pos_registro));
21.     }                                              
22.  
23.     private void fldDatoActionPerformed(java.awt.event.ActionEvent evt) {                                        
24.         //
25.     }                                      
26.  
27.     private void btnCerrarActionPerformed(java.awt.event.ActionEvent evt) {                                          
28.         System.exit(0);
29.     }                                        
30.  
31.     private void btnBorrarDatosActionPerformed(java.awt.event.ActionEvent evt) {                                              
32.         Media_obj1.metBorrarDato();
33.         lblContadorDeRegistro.setText("0");
34.         fldDato.setText("");
35.     }                                              
36.  
37.     private void btnCalcularMediaActionPerformed(java.awt.event.ActionEvent evt) {                                                
38.         Media_obj1.metCalcularMedia();
39.     }

2: Clase de métodos ClMedia_Metodos.java

Código: Java

1. package paquete1;
2.  
3. import java.util.ArrayList;
4. import javax.swing.JOptionPane;
5.  
6. public class ClMedia_Metodos {
7.  
8.     // 1: CAMPOS
9.     // Identificadores instancia de la clase ClMedia_Metodos
10.     // Sentencia para crear un arreglo dinámico dec_arrDinDatos
11.     ArrayList<Double> dec_arrDinDatos = new ArrayList();
12.     double dec_media = 0.0;
13.     // 3: MÉTODOS
14.     // 3.1 Principal
15.     public static void main(String[] args) {
16.  
17.     }
18.  
19.     // 3.2 insertar o adherir Datos al arreglo dinamico
20.     public void metAgregarDatos(Double dec_dato) {
21.         // dec_dato debe ser pasado del campo de texto con get()
22.         dec_arrDinDatos.add(dec_dato);
23.     }
24.  
25.     public void metBorrarDato() {
26.         dec_arrDinDatos.clear();
27.     }
28.  
29.     public void metCalcularMedia() {
30.  
31.         double dec_suma_acumulada = 0.0;
32.         for (int i = 0; i < dec_arrDinDatos.size(); i++) {
33.             dec_suma_acumulada = dec_suma_acumulada + dec_arrDinDatos.get(i);
34.         }
35.  
36.         dec_media = dec_suma_acumulada/dec_arrDinDatos.size();
37.         JOptionPane.showMessageDialog(null, "El valor de la media es " + dec_media);
38.     }
39. }

3: y Clase principal

//

Código: Java

1. package paquete1;
2.  
3. public class ClMedia_Main {
4.  
5.     public static void main(String argumentos_de_entrada[]) {
6.         ClMedia_GUI win_obj1 = new ClMedia_GUI();
7.         win_obj1.setTitle("Calcular Media");
8.         win_obj1.setLocationRelativeTo(win_obj1); // Instruccion para centrar la ventana
9.         win_obj1.setVisible(true);
10.     }
11. }
12. //

[CompSystems]

Video#13 Llamar una ventana exterior desde una principal

Archivo principal: ClVentanas_Main

Código: Java

1. package paquete1;
2. public class ClVentanas_Main {
3.     public static void main(String[] args) {
4.         FrmVentanaPrincipal win_obj1 = new FrmVentanaPrincipal();
5.         win_obj1.setTitle("Ventana Pricipal");
6.         win_obj1.setLocationRelativeTo(win_obj1); // Instruccion para centrar la ventana
7.         win_obj1.setVisible(true);
8.     }
9. }

Archivo para ventana PRINCIPAL FrmVentanaPrincipal.java

Código: Java

1. package paquete1;
2.  
3. public class FrmVentanaPrincipal extends javax.swing.JFrame {
4.  
5.     public FrmVentanaPrincipal() {
6.         initComponents();
7.     }
8.  
9.                          
10.     private void initComponents() {
11.       ...
12.     }                    
13.  
14.     private void btnVenExtActionPerformed(java.awt.event.ActionEvent evt) {                                          
15.         DlgVentanaExterior dialog = new DlgVentanaExterior(new javax.swing.JFrame(), true);
16.         //dialog.setLocationRelativeTo(null);
17.         dialog.setVisible(true);        
18.     }                                        
19.                  
20.     private javax.swing.JButton btnVenExt;
21.                    
22. }

Archivo VENTANA EXTERIOR DlgVentanaExterior.java

Código: Java

1. package paquete1;
2.  
3. public class DlgVentanaExterior extends javax.swing.JDialog {
4.  
5.      public DlgVentanaExterior(java.awt.Frame parent, boolean modal) {
6.         super(parent, modal);
7.         initComponents();
8.     }
9.  
10.                            
11.     private void initComponents() {
12.     ...
13.    }
14.        
15.     private void btnSalirActionPerformed(java.awt.event.ActionEvent evt) {                                        
16.        System.exit(0);
17.     }                                        
18.  
19.     private void btnRegresarActionPerformed(java.awt.event.ActionEvent evt) {                                            
20.         this.setVisible(false);
21.     }                                          
22.  
23.     private javax.swing.JButton btnRegresar;
24.     private javax.swing.JButton btnSalir;
25. }

/!\ en el ultimo IDE 8.1 no aparece la opción de agregar directamente "JDialog Form"
 pero se puede acceder siguiendo los pasos

click derecho en el Package >  New > Other.
Other es la ultima opción que sale y los manda a una ventana de new file  buscar "Swing GUI Forms", le dan click para que les muestre las opciones y verán en el cuadro del lado que la primer opción es un "JDialog Form" y listo.

[CompSystems]

VIDEO #14 Caja con Lista Opciones [Combo Box ]

Archivo  clComboBox_GUI.java que incluye la GUI con un ejemplo de ComboBox

Código: Java

1. package paquete1;
2.  
3. import javax.swing.JOptionPane;
4.  
5. ublic class clComboBox_GUI extends javax.swing.JFrame {
6.  
7.     public clComboBox_GUI() {
8.         initComponents();
9.     }
10.  
11.     private void initComponents() {
12. ...
13.  
14.     }                    
15.  
16.     private void btnSalirActionPerformed(java.awt.event.ActionEvent evt) {                                        
17.         System.exit(0);
18.     }                                        
19.  
20.     String strItemSeleccionado = "";
21.     private void cmBoxBasesActionPerformed(java.awt.event.ActionEvent evt) {                                          
22.         strItemSeleccionado = (String) cmBoxBases.getSelectedItem();
23.         JOptionPane.showMessageDialog(null, "El Item seleccionado es " + strItemSeleccionado);
24.     }                                          
25.  
26.     // Variables declaration - do not modify                    
27.     private javax.swing.JButton btnSalir;
28.     private javax.swing.JComboBox<String> cmBoxBases;
29.     private javax.swing.JLabel lbItem;
30.     // End of variables declaration                  
31. }

Archivo Principal

Código: Java

1. package paquete1;
2.  
3. public class ClListaDeOpciones_Main {
4.  
5.     public static void main(String argumentos_de_entrada[]) {
6.         clComboBox_GUI win_obj1 = new clComboBox_GUI();
7.         win_obj1.setTitle("Lista de Opciones");
8.         win_obj1.setLocationRelativeTo(win_obj1); // Instrucción para centrar la ventana
9.         win_obj1.setVisible(true);
10.     }
11. }

[elgarbe]

muy buenas explicaciones!
como me gustaría tener tiempo para ponerme un poco con esto!!!!

[CompSystems]

Un vídeo por semana en 4 meses tienes buenas bases

Video #15 Uso del bloque Try Catch (Detección De Errores) y como Poner imágenes en una ventana sobre un LABEL

Archivo PRINCIPAL: ClDeteccionDeErrores_Main.java
//

Código: Java

1. //File: ClDeteccionDeErrores_Main.java
2. package paquete1;
3.  
4. public class ClDeteccionDeErrores_Main {
5.     // Método Principal
6.     public static void main(String argumentos[]) {
7.         // Crea un objeto apartir de la clase FORM: FrmDeteccionDeErrores.java
8.         FrmDeteccionDeErrores win_obj1 = new FrmDeteccionDeErrores();
9.         // Coloca el titulo en la ventana
10.         win_obj1.setTitle("Imagenes sobre LABELs");
11.         // Instrucción para centrar la ventana
12.         win_obj1.setLocationRelativeTo(win_obj1);
13.         // Permanece visible la ventana
14.         win_obj1.setVisible(true);
15.     }
16. }//

Archivo de la GUI en si:  FrmDeteccionDeErrores.java
//

Código: Java

1. //File: FrmDeteccionDeErrores.java
2. package paquete1;
3. public class FrmDeteccionDeErrores extends javax.swing.JFrame {
4.    
5.     // Método Constructor
6.     public FrmDeteccionDeErrores() {
7.         // Inicializa los objetos de la GUI
8.         initComponents();
9.         // El metodo de nombre "met_cargarImagen" de la clase "Cl_Icon" se ejecuta dentro del constructor
10.         icon_obj1.met_cargarImagen();
11.     }
12.    
13.     // A partir de la clase "Cl_Icon" se crea un objeto de nombre "Icon_obj1"
14.     Cl_Icon icon_obj1 = new Cl_Icon();
15.  
16.      // Método para inicializar los componentes, método creado por el IDE, también se puede hacer manualmente, en proximos videos se abarcara esta opción              
17.     private void initComponents() {
18.    ....
19.     }                    
20.     //  Se pueden modificar con REFACTOR
21.     // Variables declaration - do not modify                    
22.     public static javax.swing.JLabel lblIcon;  
23.     // End of variables declaration                  
24.  
25. }//

Archivo de metodos :Cl_Icon.java
//

Código: Java

1. //File:Cl_Icon.java
2. package paquete1;
3.  
4. // Importa las bibliotecas requeridas
5. import javax.swing.Icon;
6. import javax.swing.ImageIcon;
7. import javax.swing.JOptionPane;
8.  
9. public class Cl_Icon {
10.  
11.     // métodos
12.     public void met_cargarImagen() {
13.         // INTENTA O TRATA  de leer un archivo imagen dentro de un paquete del mismo proyecto
14.         try {
15.             // Crea un objeto tipo ICONO de nombre "icon1_obj", se requiere ubicarlo dentro de un paquete llamado paq_images
16.             Icon icon1_obj = new ImageIcon(getClass().getResource("/paq_images/imagenDePrueba.png"));
17. /!\ la imagen debe estar dentro un paquete y que pertenezca al proyecto, de lo contrario hay que modificar la ruta de lectura
18.  
19.             // Sobre la etiqueta denominada "lblIcon" de la GUI denominada "FrmDeteccionDeErrores" se inserta o fija la imagen
20.             FrmDeteccionDeErrores.lblIcon.setIcon(icon1_obj);
21.         } catch (Exception id_errorCapturado) {
22.             // El TIPO DE ERROR es capturado en el identificador de nombre "id_errorCapturado"
23.             // Despliega un mensaje anunciando el tipo de error
24.             JOptionPane.showMessageDialog(null, "error " + id_errorCapturado);
25.         }
26.     }
27. }//

[CompSystems]

Un vídeo explicación de un nuevo componente denominado SPINNER o ROTADOR de números, cadenas etc, además se explicara como hacer una CURP CODIGO UNICO DE REGISTRO
Video #17

La siguientes explicaciones me baso, ademas del vídeo anterior en la siguiente pagina web http://www.codigojavalibre.com/2015/06/Curso-Java-SPINNER.html
Es bueno inspirarse en la redacción de otra persona, pues otra  persona tiene un conjunto de palabras diferentes o redacción personal, así evito la monotonía al repetir mis propias palabras

La clase JSpinner permite crear cuadros como el siguiente:



los SPINNER o ROTADOR son controles muy presenten en las GUI, los parámetros contenidos se pueden rotar o mover rápidamente por medio de los 2 botones triangulares, pero para una búsqueda o posición inicial se puede escribir un valor dentro de su campo, este permite escoger de una lista de opciones pero solo es visible 1 solo valor

La explicación de spinner del video inicia en el minuto 3.10, pero mostrare un ejemplo mas básico del uso de spinner,  según el tipo de datos a mostrar, se escoge el tipo de MODELO de spinner, el mas común es el numérico, que lista números, también puede listar fechas y  listas

MODELO POR DEFECTO: es un modelo NUMERICO de números enteros, puedes personalizarse como números decimales y otros tipos de datos

Añade un Rotador (JSpinner) a un proyecto actual o sobre un nuevo proyecto, cambia su id de programacion a spnRotador.
Añade una etiqueta (jLabel) con borde y eliminar el nombre visible, pero si renombrar su id de programacion a lblRotador , hasta ahora solo hemos agregado un LABEL por defecto, osea sin borde, pero si un LABEL no tiene nombre visible, desaparece de la vista de la GUI, por esta razón se debe agregar un borde

Pasos apara agregar un borde a un label:
dar clic derecho sobre el label, ir a propiedades, ... otras propiedades, añadir un LINE BORDER con cualquier color y listo tendrá un aspecto similar como un textFIELD

Este simple ejemplo hará que cuando cambie el JSpinner (ya sea porque se pulsaron los botones triangulares o porque se escribió dentro, o porque se uso los cursores del teclado para hacerlo rotar) aparezca el valor correspondiente dentro de la etiqueta lblRotador.

Si damos doble clic sobre el SPINNER vemos que no se agrega un método para capturar el evento, se requiere hacerlo manualmente y cuando ocurre el (state Changed) / (estado cambió)
dar clic derecho sobre el label, ir a EVENTS, luego CHANGE y dar clic en state Changed, en este momento se agrega el código del evento

private void spnRotadorStateChanged(javax.swing.event.ChangeEvent evt) {                                       
       
    }

la sentencia spnRotador.getValue() captura el valor actual a través del método getValue y como queremos mostrarlo como mensaje hay que convertirlo a cadena con el postfijo .toString()

la sentencia resultante es: spnRotador.getValue().toString()

ademas hay que almacenarlo en el campo de label a través del método setText , finalmente la sentencia que hace los últimos pasos se condensa en
 
lblRotador.setText("El valor es: "+spnRotador.getValue().toString());

Como puedes observar, lo que hace el programa es recoger el valor que tiene el JSpinner a través del método getValue y luego se lo asigna a la etiqueta con el clásico setText. (Es muy parecido a los deslizadores)

Código: Java

1. private void spnRotadorStateChanged(javax.swing.event.ChangeEvent evt) {                                        
2.      lblRotador.setText("El valor es: "+spnRotador.getValue().toString());  
3.     }

Podemos también limitar el dominio o rango de números a listar con los métodos setMaximum y setMinimum, además el paso e incremento,

manualmente es

SpinnerNumberModel Rotador_obj1 = new SpinnerNumberModel();
         Rotador_obj1.setMaximum(10);
         Rotador_obj1.setMinimum(0);
         Rotador_obj1.setStepSize(2);
         spnRotador.setModel(Rotador_obj1);



o desde propiedades/Modelo see escoge le modelo apropiado y parámetros según la lógica del código

[juaperser1]

hola CompSystems, me gustaría hacerte una pregunta:

yo he hecho interfaces gráficas, bastante buenas y muy complejas, con visual studio y C#, y con C++ y QT.

con java y widgets he hecho los típicos programitas chorras de pulsar un boton, calculadora etc. nada del otro mundo.

la pregunta es: ¿Qué podrías decirme para convencerme para dejar QT o Visual studio, y empezar a usar Java?
la respuesta de la portabilidad ya la se, me gustaría cosas mas específicas, como licencias, nivel de customización del GUI, tener que recurrir a librerías... ...  externas como para los puertos com... cosas de ese estilo. Visual studio y Qt creator son excelentes IDEs y ahora con el visual studio versión comunidad es gratis, y ambos tienen herramientas y librerías propias muy buenas e intuitivas, ¿tendrías las mismas facilidades en Java?

por cierto gran trabajo con tus tutoriales de Java

un saludo.

[CompSystems]

Una razón que nos puede interesar es que las GUI para pantallas táctiles que requieren nuestros proyectos de electrónica se pueden crear usando JAVA