TODOPIC

Lenguajes de programación para PC => C, C#, C++ => Mensaje iniciado por: CompSystems en 08 de Enero de 2016, 15:27:31

Título: Tutorial JAVA con GUI e IDE NetBeans 8.x
Publicado por: CompSystems en 08 de Enero de 2016, 15:27:31
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 ...
Título: Re:GUIs con JAVA y NetBeans 8.x
Publicado por: CompSystems en 10 de Enero de 2016, 23:53:37
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  :-/
Título: Re:GUIs con JAVA y NetBeans 8.x
Publicado por: KILLERJC en 11 de Enero de 2016, 00:07:00
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 :P
Título: Re:GUIs con JAVA y NetBeans 8.x
Publicado por: CompSystems en 11 de Enero de 2016, 00:21:11
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
Título: Re:GUIs con JAVA y NetBeans 8.x
Publicado por: CompSystems en 11 de Enero de 2016, 23:27:00
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.     }

Título: Re:GUIs con JAVA y NetBeans 8.x
Publicado por: PalitroqueZ en 11 de Enero de 2016, 23:58:55
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.  :)
Título: Re:GUIs con JAVA y NetBeans 8.x
Publicado por: CompSystems en 12 de Enero de 2016, 14:01:31
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. }//

Título: Re:GUIs con JAVA y NetBeans 8.x
Publicado por: CompSystems en 12 de Enero de 2016, 18:44:50
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. //
Título: Re:GUIs con JAVA y NetBeans 8.x
Publicado por: CompSystems en 13 de Enero de 2016, 10:49:21
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.
Título: Re:GUIs con JAVA y NetBeans 8.x
Publicado por: CompSystems en 13 de Enero de 2016, 11:00:26
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. }


Título: Re:GUIs con JAVA y NetBeans 8.x
Publicado por: elgarbe en 13 de Enero de 2016, 11:47:43
muy buenas explicaciones!
como me gustaría tener tiempo para ponerme un poco con esto!!!!
Título: Re:GUIs con JAVA y NetBeans 8.x
Publicado por: CompSystems en 13 de Enero de 2016, 16:13:46
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. }//
Título: Re:GUIs con JAVA y NetBeans 8.x
Publicado por: CompSystems en 14 de Enero de 2016, 00:43:03
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:

(http://2.bp.blogspot.com/-2AFrAwSISBY/VZMMxY7oebI/AAAAAAAAAPI/WSaWmk2darg/s1600/clase-JSpinner-java.png)

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 (http://1.bp.blogspot.com/-BzgPsFU-g9Q/VZMMyPGxYeI/AAAAAAAAAPo/XxKvg1or0sA/s1600/ventana-JSpinner-java.png)

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.     }

(http://1.bp.blogspot.com/-Xzy5l6s1W4Q/VZMMxubGK5I/AAAAAAAAAPk/RAnqzG62uMc/s1600/ventana-JSpinner-java-ejecutamos.png)

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);

(http://2.bp.blogspot.com/-QGoiGM2erQE/VZMMx0yKhDI/AAAAAAAAAPg/oRAuCJWDaGQ/s1600/ventana-JSpinner-java-ejecutamos2.png)

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

Título: Re:GUIs con JAVA y NetBeans 8.x
Publicado por: juaperser1 en 16 de Enero de 2016, 22:39:50
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.





Título: Re:GUIs con JAVA y NetBeans 8.x
Publicado por: CompSystems en 16 de Enero de 2016, 23:54:08
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
Título: Re:GUIs con JAVA y NetBeans 8.x
Publicado por: CompSystems en 18 de Enero de 2016, 00:01:25
Unos vídeo donde se muestra mas sobre el control SPINNER, visto en el vídeo anterior

video 1/3



El siguiente video explica los 3 tipos de spinner comunes


En base al video anterior añadimos 2 nuevos SPINNERs, uno de fecha con ID de programación spnRotador_fecha
y otro spinner de listas con ID de programación spnRotador_lista

al inicio del método initComponents() DESING agregan las definiciones de creación de objetos de cada uno de los nuevos spinners

Código: Java
  1. private void initComponents() {
  2.         ....
  3.         spnRotador_numeros = new javax.swing.JSpinner();
  4.         spnRotador_fecha = new javax.swing.JSpinner();
  5.         spnRotador_lista = new javax.swing.JSpinner();
  6.         ...
y también se agrega DESING el modelo con setModel

Código: Java
  1. spnRotador_lista.setModel(new javax.swing.SpinnerListModel(new String[] {"Item 0", "Item 1", "Item 2", "Item 3"} ));
  2.  
  3.  
  4.      spnRotador_fecha.setModel(new javax.swing.SpinnerDateModel(
  5. new java.util.Date(1453484940000L),  
  6. new java.util.Date(1453484940000L),
  7. new java.util.Date(1453571340000L),
  8. java.util.Calendar.DAY_OF_MONTH)
  9. );

los  parámetros de SpinnerDateModel( ... ) son 4 parámetros o submétodos
El primer parámetros es el valor de fecha  inicial, seguido de valor de fecha mínimo, luego valor de fecha máximo y finalmente tipo de incremento
       
el  parámetros de SpinnerListModel( ... ) es una arreglo de cadenas, con el nombre de cada ITEM, si e IDE esta en inglés agrega una lista de 4 cadenas de la forma {"Item 0", "Item 1", "Item 2", "Item 3"}

Vamos a modificar por código los parámetros de spnRotador_lista

Después del método initComponents(); escribimos
Código: Java
  1. initComponents();
  2.         ...
  3.        
  4.         DateFormatSymbols formatoFechaObj1 = new DateFormatSymbols(Locale.US);
  5.         // Cadena de nombre strMeses que contiene los meses en ingles        
  6.         String[] strMeses = formatoFechaObj1.getMonths();
  7.         // Objeto tipo SpinnerList de nombre mesesUSobj1
  8.         SpinnerModel mesesUSobj1 = new SpinnerListModel(strMeses);
  9.         // Fijamos el mesesUSobj1 al spinner de nombre spnRotador_lista
  10.         spnRotador_lista.setModel(mesesUSobj1);

En este caso se visualizaran {"January", "February", "March", ....}  pero en la pestana DESING este control aun sigue mostrando {"Item 0", "Item 1", ...}

Aun no se como modificar la línea que agrega el editor grafico, pues el editor bloquea el acceso

spnRotador_lista.setModel(new javax.swing.SpinnerListModel(new String[] {"Item 0", "Item 1", "Item 2", "Item 3"}));

Vamos a crear un evento codificado manualmente, seguido de los códigos anteriores

 ChangeListener obj1 = new ChangeListener() {
            public void stateChanged(ChangeEvent evt) {
                // obtiene el valor inicial "
                JSpinner spnRotador_listaObj1 = (JSpinner) evt.getSource();
                JOptionPane.showMessageDialog(null, "evento creado manualmente: El valor inicial es: " + spnRotador_listaObj1.getValue());
            }
        };
        spnRotador_lista.addChangeListener(obj1);

El código anexado es
Código: Java
  1. public Frm_MiPrimerVentana() {
  2.         // initComponents() es un método o función que inicializa los objetos controladores de la GUI
  3.         initComponents();
  4.         btnCerrar.setEnabled(false);
  5.  
  6.         DateFormatSymbols formatoFechaObj1 = new DateFormatSymbols(Locale.US);
  7.         // Cadena de nombre strMeses que contiene los meses en ingles        
  8.         String[] strMeses = formatoFechaObj1.getMonths();
  9.         // Objeto tipo SpinnerList de nombre mesesUSobj1
  10.         SpinnerModel mesesUSobj1 = new SpinnerListModel(strMeses);
  11.         // Fijamos el mesesUSobj1 al spinner de nombre spnRotador_lista
  12.         spnRotador_lista.setModel(mesesUSobj1);
  13.         // en este caso se visualizaran {"January", "February", "March", ....}
  14.         // pero en la pestana DESING este control aun sigue mostrando {"Item 0", "Item 1", ...}
  15.  
  16.         ChangeListener obj1 = new ChangeListener() {
  17.             public void stateChanged(ChangeEvent evt) {
  18.                 // obtiene el valor inicial "
  19.                 JSpinner spnRotador_listaObj1 = (JSpinner) evt.getSource();
  20.                 JOptionPane.showMessageDialog(null, "evento creado manualmente: El valor inicial es: " + spnRotador_listaObj1.getValue());
  21.             }
  22.         };
  23.         spnRotador_lista.addChangeListener(obj1);
  24.     }

El contenedor del evento creado por DESING

Código: Java
  1. private void spnRotador_listaStateChanged(javax.swing.event.ChangeEvent evt) {                                              
  2.         // obtine el valor inicial "
  3.         JSpinner spnRotador_listaObj1 = (JSpinner) evt.getSource();
  4.         JOptionPane.showMessageDialog(null, "Evento creado por DESING. El valor inicial es: " + spnRotador_listaObj1.getValue());
  5.     }

Título: Tutorial JAVA con GUI e IDE NetBeans 8.x
Publicado por: CompSystems en 22 de Enero de 2016, 19:30:49
Recordemos algo de JAVA y lenguajes de programación, antes de continuar

Resumen basado en mis autoaprendizaje de varios lenguajes, video tutoriales, libros, documentos de internet etc, se aceptan sugerencias, mejoras, correcciones etc

INTRODUCCION

1: DATOS

Un programa informático gestiona datos sobre una maquina computacional (computador/ordenador, calculadora, sistema embebido, PLC, etc.), los datos pueden estar incorporados dentro del programa, o pueden ser obtenidos en el transcurso de su ejecución, ya sea por medio de un usuario o automata, en el primer caso usa por ejemplo un teclado real o virtual, selección de un archivo almacenado en el disco duro o dispositivo externo, en el segundo caso la entrada de datos puede ser automática, adquirida por un sensor electrónico, un correo o teléfono celular que envía datos programados, a través de un interface electronica y/o aplicación de software etc.

Las maquinas computacionales se crearon para "entender" un alfabeto binario "0" y "1"ya que su hardware se basa en un lógica simple de dos estados, en palabras no complejas es ausencia o no de una señal eléctrica, es imposible hasta ahora crear maquinas computacionales para operar sobre un alfabeto completo, tendría un capacidad de razonamiento similar al ser humano tal ves algún día llegaremos a un tipo de inteligencia artificial similar a la nuestra

Los datos al final se convierten en cadenas de números binarios para que puedan ser interpretados por el procesador, pero lo que nos interesa por ahora es el código de programa o código fuente y lo especial o mágico es que tan solo se requiere para ser codificado un poco menos de los 95 caracteres imprimibles o visibles del ASCII. o (Código Estándar Estadounidense para el Intercambio de Información)

lista de caracteres visibles del ASCII
! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
@ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _
` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~

Lenguajes modernos como JAVA puede gestionar caracteres Unicode, es decir caracteres especiales o no disponibles en ASCII, para poder visualizar símbolos de lenguajes naturales como JAPONES, ESPAÑOL, ARABE etc
además de símbolos matemáticos como ∂ ∫ ∬ ≠, símbolos técnicos, etc.

Sobre los lenguajes de programación, abarcan desde el lenguaje de maquina o código final para el procesador que son cadenas de dígitos binarios, luego esta el lenguaje ensamblador o conocido también como lenguaje de bajo nivel, que se caracteriza por un nivel complejo de sintaxis en el código fuente y difícil interpretación humana para llevar la lógica de un problema a código fuente, pero con la ventaja de que el programa compilado o ejecutable sera el mas optimo con respecto a velocidad de ejecución del siguiente caso, el cual es lenguaje de alto nivel, se codifica por lo general en instrucciones que en su mayoría son palabras tomadas del idioma INGLES, usa operadores aritméticos que en gran parte son idénticos a los símbolos matemáticos « x +, -, /, <, > », otros no lo son porque por ejemplo en ASCCI no existe el símbolo MAYOR o MENOR E IGUAL QUE, entonces se requiere la combinación de al menos dos símbolos (DIGRAPHS) ASCCI como « >= », « <= » para hacer equivalencia a los verdaderos símbolos aritméticos ≦ ≧, usa también operadores que no se definen en la aritmética, como incremento « ++ »,  decremento « -- », y otros son cruzados como « % », que no significa porcentaje, sino residuo o modulo de la division aritmética y su expresión es x mod y, similarmente en aritmética el símbolo « ! » es factorial, mientras que en java es negación de una expresión boleana

Los lenguajes de alto nivel no los puede interpretar los procesadores, requieren convertirse y para esto necesitan bibliotecas o paquetes con cientos de subrutinas, implica que el código ejecutable creado sea mas grande y redundante con respecto si se crease el código desde un lenguaje ensamblador.

Los lenguajes interpretados, son dos tipos, unos que en tiempo real toman cada sentencia y llaman a funciones internas de interpretación como  el QBASIC (version antigua, por que la actual es compilada), otros como es el caso de java compila el código fuente, y crea un código ejecutable (ByteCode) que requiere una capa por software o también llamada MAQUINA VIRTUAL COMPUTACIONAL, esto con el propósito de ser ejecutable sobre cualquier marca y tipo de procesador desde ordenadores, celulares, relojes a tabletspc

Sobre los compiladores son de 2 tipos, los que generan el código ejecutable para el mismo tipo de procesador y el otro para otro procesador distinto a aquél en la que el compilador se ejecuta, este tipo de compilador se denomina compilador cruzado, los IDEs de java son de este tipo

El principal objetivo de un programa es gestionar números (enteros en formato decimal, octal, hexadecimal y números decimales (en forma de coma o punto flotante), también los lenguajes pueden operan cadenas de texto, pero  necesitan contenedores para diferenciarlas de las sentencias o conjuntos de instrucciones de un lenguaje de programación, estos contenedores son en su mayoría un par de comillas dobles « " " » o simples « ' ' ». Las comillas dobles son para encerrar textos mas de un carácter y comillas simples para encerrar un solo carácter, el primer contenedor se dice que es el contenedor de abertura y el final de cierre, al igual que los paréntesis en aritmética no pueden estar un solo, se requiere siempre uno de apertura y otro de cierre, si elimínanos el primer paréntesis o paréntesis de apertura de 2*(3 + 1) se obtiene 2*3+1) que cambia el resultado de la expresión o genera un error de sintaxis, análogamente para (2^31)-1, si eliminamos el segundo paréntesis o paréntesis de cierre se obtiene otro resultado (2^31-1
 
Ejemplo

"x = 2*(3 + 1)" es un texto que puede significar una formula en un libro de texto, mientras que
 x = 2*(3 + 1) ; es una sentencia de programación que en C/C++/C#/java y otros es una operación de asignación que usa el operador igual « = » para almacenar en la variable « x » el resultado de la evaluación de expresión del lado derecho « 2*(3 + 1)"  » que además contiene el operador suma y dos números enteros
mientras  que '=', '+', 'x', '1'  '3' '2' '*' son interpretados solo como caracteres

Algunos lenguajes también operan sobre conjuntos de datos del mismo tipo, llamados « ARRAYS » como arreglos de números enteros, e incluso arreglos de cadenas de texto, y muchos lenguajes llegan hasta este punto, el poder de los lenguajes modernos es que pueden gestionar estructuras de datos que simulan objetos de la realidad, como cuentas de usuario de bancos, cuentas de usuario de internet, objetos matemáticos para crear kernels de algebra simbólica etc.

El objeto mas simple y común en java se denomina la CLASE STRING, antes de hablar de la clase STRING, se necesita el concepto de VARIABLE o IDENTIFICADOR

2: VARIABLE o IDENTIFICADOR (ID)

Este es un nombre que identifica un dato dentro de un código fuente, pero que dentro del código ejecutable UBICA el dato u objeto en la memoria física del sistema computacional. Dentro del código fuente el ID es tan solo un nombre o secuencia de caracteres ASCII con ciertas reglas de construcción, la mas importante es que no debe llamarse como un nombre del conjunto de instrucciones propio del lenguaje y la segunda mas importante es que no debe contener el carácter espacio ' ', además de otras condiciones que se exploraran próximamente.

El nombre ID puede contener n caracteres de longitud para servir como base de identificación rápida y auto-documentación del código fuente, a mayor numero de caracteres mayor sera el tamaño del código de fuente,
es una mala practica de programación, la cual es crear identificadores con nombre cortos, ya que se desconoce que dentro del código ejecutable el identificador al igual que todo el resto es tan solo una cadena de números binarios, en donde cada identificador se convierte en dirección de memoria de pocos bytes de tamaño.

ejemplo

usarioN1 es un ID valido y mejor que u1,

usarioN1 y u1 podría contener un nombre de persona y como se dijo anteriormente un texto o mejor en la jerga de JAVA una cadena o secuencia de caracteres  de caracteres « String » debe ser contenida por doble par de comillas

usarioN1 = "Juan";
u1 = "Jaime";

usarioN1 puede tener como ubicación o dirección  0x3A98 y u1 la dirección siguiente en +/- 1 o n bytes, por esta razón la longitud del nombre identificador no implica mas o menos tamaño de memoria requerida, mientras que el contenido del ID si aumenta o disminuye el tamaño de memoria en ciertos tipos de datos, en especial los « String »

2.1: ALMACENAMINETO DINAMICO

Primera característica del objeto STRING, se almacena en un campo de memoria dinámica
 
veamos

Si en el trascurso de un programa  el contenido de usarioN1 es el primer nombre y luego se expande incluyendo un segundo nombre y apellido tenemos

usarioN1 = "Juan Camilo Salazar";

y luego un segundo apellido

usarioN1 = "Juan David Salazar Ortiz";

vemos que en el caso del nombre de usuario la memoria que necesita para contener cada caso se incrementa, si cada carácter UNICODE se codifica en 16 bits o 2 Bytes, la primer asignación (usarioN1 = "Juan"; ) se almacena "Juan" que posee los siguientes caracteres 'J', 'u', 'a'  'n' este requiere 4*2 Bytes, es decir 8 bytes de memoria , mientras que  "Juan David Salazar Ortiz" ocupa 24 bytes, incluyendo el carácter espacio, por lo tanto usarioN1 requiere almacenamiento dinámico, es decir que crezca o disminuya la cantidad de espacio en memoria requerida al redefinir el contenido de la variable en la ejecución del programa

2.2: ALMACENAMINETO ESTATICO

El caso contrario es que el  contenido final del ID varié, en este caso en JAVA ocupa el mismo tamaño de memoria veamos

en el ejemplo de arriba la sentencia x = 2*(3 + 1);

también pude cambiar de contenido de 8 a 20mil
x = 2*(3 + 1);
x = 10000*2;

aparentemente se requiere mas memoria para contener 20000 que 8, pero No es así y esto también depende del tipo de lenguaje, pero antes de explicar el porque ocupan el mismo tamaño 20,000 que 8 veamos el siguiente punto

3: INTRODUCCION A LOS TIPOS de DATOS

la siguiente sentencia, usarioN1 contiene un String, ahora se desea almacenar un tipo de dato diferente

usarioN1 = 10000*2;

no es posible en muchos lenguajes porque en un principio usarioN1 contenía una cadena de caracteres, luego transmuto a un numero entero, para evitar esta ambigüedad de contenido las variables o identificadores requieren una ayuda para evitarla, la ayuda es una palabra clave como prefijo o antes del nombre ID, este prefijo se denomina TIPO de dato

ejemplo

String usarioN1 = "Juan David Salazar Ortiz";
int x = 10000*2;
usarioN1 = 10000*2;

ahora usarioN1 le dice al compilador y revisor del programa en tiempo real que  « usarioN1 » solo acepta CADENAS o STRINGs de caracteres y no otra cosa, al igual que  « x » solo acepta números enteros, entonces el compilador cuando llega a la expresión usarioN1 = 10000*2; se detiene y genera un error de compilación, "dato invalido"

4: RANGO DE algunos TIPOS DE DATOS en JAVA

Para mejorar la eficacia de un programa se ideo la forma de limitar el contenido de ciertos tipos de datos, por ejemplo en JAVA, el tipo de dato int (entero por defecto en JAVA, usa 4 Bytes (32 bits) de memoria)

Recordemos que la minima cantidad de dígitos para conformar números son dos (base binaria), podemos hacer algebra y aritmética y esta fue desarrollada por GEORGE BOOLE de ahi su nombre, algebra de Boole, una forma didáctica de crear números en base 2 es pensar todos los números que tienen 1s y 0s de la base 10, se inicia con el 0, luego 1, luego 10, luego 11, 100, 101, 110, 111, 1000, 1001, 1010, 1011, 1100, 1101, 1110, 1111, ... etc

0   0
1   1
10 2
11 3
100 4
101 5
110 6
111 7
1000 8
1001 9
1010 10
1011 11
1100 12
1101 13
1110 14
1111 15
10000 16
...

de la lista anterior podemos observar que

Con 1 dígitos o bits se pueden conformar 2^1 = 2 números, 0 y 1
Con 2 dígitos o bits  se pueden conformar 2^2 = 4 números, 00, 01, 10, 11
Con 3 dígitos o bits se pueden conformar 2^3 = 8 números, 000, 001, 010, 011, 100, 101, 110, 111

en forma general con N bits se pueden representar 2^(#bits) números

como 1 Byte son 8 bits entonces para un « int » se tiene que 2^(4*8 ) = 4,294,967,296, es decir el rango contiene mas de 4,200 millones de números, pero como hay que repartirlos (partirlos por la mitad) en negativos y positivos, mas el numero 0, entonces el menor numero se define por la expresión  2^(#bits-1) y el mayor como 2^(#bits-1)-1

solo permite contener números entre -2^31 que es igual a -2,147,483,648 y (2^31)-1 que a su ves es 2,147,483,647,  paso a paso evaluado el rango, note que si disminuimos el exponente en 1 se divide el valor en 2

[ -2^(#bits-1), .... , 0 , ... ,  2^(#bits-1)-1 ] =
[ -2^((4*8 )-1), .... , 0 , ... , 2^((4*8 )-1)-1 ] = [ -2^(32-1), ..... , 0 , ... , 2^(32-1)-1 ] =
[ -2^31, ..... , 0 , ... , 2^(31)-1 ] =
El rango de « int » es[ -2,147,483,648, .... , 0 , ... ,  2,147,483,647 ]

si sumamos los valores absolutos extremos tenemos |-2,147,483,648 |+|2,147,483,647 | +1 (del cero) se comprueba el total de valores 4,294,967,296

Ejemplo practico

las siguientes sentencias son validas, por estar dentro del rango permitido

int x = -2147483648;
int x = 0;
int x = 10000*2;
int x = 2147483647;

y las siguientes sentencias NO son validas por desbordarse en solo 1 unidad

int x = -2147483648-1;
int x = 2147483647+1;

o su resultado equivalente

int x = -2147483649;
int x = -2147483649;
int x = 2147483648;

si se sabe que el ID puede contener un numero entero mas grande, existe el tipo de dato « long » (entero largo que en java usa 8 Bytes de memoria)
si se redefine el tipo de dato las sentencias anteriores son validas

long x = -2147483648-1;
long x = 2147483647+1;

entonces si se conoce que la variable no superara  el rango entre [ -2,147,483,648, .... , 0 , ... ,  2,147,483,647 ] se debe definir como « int » ya que solo ocuparía 4 bytes, no tiene sentido definirla como « long », que ocuparía 4 Bytes mas, el doble por cada sentencia

En resumen las 4 sentencias siguientes, ocupan el mismo tamaño en memoria (4 Bytes), no depende del contenido de la misma y esto responde la inquietud pendiente de arriba

int x = -2147483648;
int x = 0;
int x = 10000*2;
int x = 2147483647;

el máximo numero que puede procesar JAVA es un REAL cuyo tipo de dato es  (double) y valor máximo 1.8*10^308
que se codifica como coma o punto flotante.

int r = 1.8E308D;

IMPORTANCIA DEL OBJETO STRING

ahora se preguntan si la lógica del programa requiere operar un numero mas grande que 1.8*10^308, por ejemplo algoritmo que calcule distancias astronómicas (nave espacial que va hasta pluton y mas allá), ¿que podemos hacer? una manera es operar un numero como cadenas de caracteres STRINGs, existen códigos en java creados por terceros para este fin.

En la lógica de un programa requiere manipular no solo números, si no también cadenas de caracteres, los lenguajes comunes no tienen funciones para operar cadenas, por esta razón JAVA interpreta una cadena de caracteres como OBJETO y como un objeto es una clase especializada, esta contiene varias funciones que ayudan a codificar rápidamente sin la necesidad de crear bibliotecas de usuario para la manipulación de strings,

algunas funciones de la clase String, son: convertir numero entero como cadena en numero de tipo entero (función de cadena a numero) y viceversa (función de numero a cadena), convertir cadena a mayúsculas o minúsculas, hallar la posición de un carácter dentro de la cadena y muchas otras mas.

Próximamente se incluirá un ejemplo


Como buena practica de programación se recomienda adherir un prefijo al nombre del identificador o variable, por ejemplo str para String, int para int, lng para Long etc

String strCadena1 = "Hello World Again";
int intContador1 = 256;

5: TIPOS DE IDENTIFICADORES O VARIABLES

Existen dos tipos de identificadores, Identificador o variable primitiva y Identificador de variable referencia

El identificador que hace referencia a un objeto primitivo como « int intContador1 = 256; » se denomina Id primitivo o variable primitiva

El identificador que hace referencia a un objeto como « String strCadena1 = "Hello World Again"; » se denomina ID referencia o variable referencia

Las variables primitivas y variables referencia también pueden contener ARREGLOS o conjunto de datos, se dice Arreglos de variable primitiva o Arreglos variable referencia, se requiere un postfijo después del nombre de ID o en el tipo de dato el cual es un contenedor tipo paréntesis angular o comúnmente conocido como corchete de apertura y cierre « [ ] » para diferenciar ID que contiene un solo dato o ID que permite almacenar un conjunto de datos

Ejemplos

« int intContador1[] = {256, 257, 258} ; »
« String strCadena1[] = { "Hello", "World", "Again" } ; »

es equivalente a

« int[] intContador1 = {256, 257, 258}; »
« String[] strCadena1 = { "Hello", "World", "Again" } ; »

6: TIPOS DE DATOS PRIMITIVOS o BASICOS en JAVA

como dijimos anteriormente son datos básicos del lenguaje, JAVA opera con números ENTEROS y REALES de forma básica y también los mismo pero visto como objetos, primero estudiaremos los BASICOS

6.1: TIPOS DE DATOS PRIMITIVOS ENTEROS

Son 4 tipos de datos primitivos « byte, short, int, long », se diferencian por que cada uno puede contener un rango diferente de números, esto depende del numero de BYTES de uso de cada tipo

el tipo con menor rango es el que usa un 1 byte (8 bits) ya que es el mínimo elemento de memoria direccionable de algunas maquina computacional

con los ejemplos de arriba de la introducción de tipos de datos, podemos construir las formulas para cada tipo primitivo entero

menor numero del rango: valor mínimo = -2^(#bits-1)
mayor numero del rango: valor máximo = (2^(#bits-1))-1
La cantidad de números del rango del tipo de dato: rango = 2^(#bits)
rango = |valor mínimo | + |valor máximo| + 1

tenemos para 8 bits o 1 Byte

rango = 2^(#bits) = 2^8 = 256 valores
valor mínimo = -2^(8-1) = 2^7 = -128
valor máximo = (2^(8-1))-1 = (2^7)-1 = 127
prueba del rango |-128| + |127| +1 = 256 valores

Entonces podemos definir el tipo de dato « byte » rango = [-128, ..., 0, ..., 127], usado en plataformas básicas de 8 bits  similarmente se define para los demas

Resumen de NUMEROS ENTEROS EN JAVA

Con 8 bits (1 byte) se pueden conformar 2^8 = 256 números, tipo en JAVA « byte »
Con 16 bits (2 byte) se pueden conformar 2^16 = 65536 números, tipo en JAVA « short » ENTERO CORTO
Con 32 bits (4 byte) se pueden conformar 2^36 = 4294967296 números, tipo en JAVA « int » ENTERO (valor por defecto)
Con 64 bits (8 byte) se pueden conformar 2^64 = 4294967296 números, tipo en JAVA « long » ENTERO LARGO

RESUMEN de los RANGOS de NUMEROS ENTEROS

byte = [ -128, ..., 0, ..., 127 ] = [ -2^7, +(2^7)-1]
short = [ -32,768, ..., 0, ..., 32,767 ] = [ -2^15, +(2^15)-1]
int = [ -2,147,483,648, ..., 0, ..., 2,147,483,647 ] = [ -2^31, +(2^31)-1]
long = [ -9,223,372,036,854,775,808, ..., 0, ..., 9,223,372,036,854,775,807] = [ -2^63, +(2^63)-1]

Ejemplo practico
Código: Java
  1. public class clAprendiendoJava {
  2.  
  3.     public static void main(String[] args) {
  4.  
  5.         byte byte_minimoEntero;
  6.         short shr_enteroCorto;
  7.         int int_enteroPorDefecto;
  8.         long int_enteroLargo;
  9.  
  10.         byte_minimoEntero = (byte) 127;
  11.         shr_enteroCorto = 32767;
  12.         int_enteroPorDefecto = 2147483647;
  13.         int_enteroLargo = 9223372036854775807L;
  14.  
  15.         printConsole("Minimo Entero: " + byte_minimoEntero);
  16.         printConsole("Entero Corto: " + shr_enteroCorto);
  17.         printConsole("Entero por Defecto: " + int_enteroPorDefecto);
  18.         printConsole("Entero largo: " + int_enteroLargo);
  19.     }
  20.  
  21.     public static void printConsole(String str) {
  22.         System.out.println(str);
  23.     }
  24.  
  25. }

6.2: TIPOS DE DATOS PRIMITIVOS REALES

en redacción  ...

6.3: TIPOS DE DATOS PRIMITIVOS BOOLEAN (LÓGICAS): Este tipo de datos solo permiten almacenar 2 valores contantes « true » verdadero y « false » falso, otros lenguajes usan el numero 0 como valor falso y el resto de números enteros como verdadero

6.4: TIPOS DE DATOS PRIMITIVOS CHARACTER (CARÁCTER): Este tipo de datos solo permiten almacenar caracteres de la tabla UNICODE en formato de 16 bits, implica 2^16 = 65,536 caracteres , en contraposición de los 127 de ASCII usados en otros lenguajes, un carater como se dijo anteriormente requiere un contenedor  « ' ' » para almacenar un solo caracter o numero hexadecimal de 4 digitos en formato « ' \uxxxx' »

Código: Java
  1. char chrLetra_A = 'A';
  2.         char chrLetra_a = 'a';
  3.         char chrLetra_0 = '0';
  4.         char chrLetra_9 = '9';
  5.         char chrSimbolo_plus = '+';
  6.         char chrSimbolo_derivada = '∂';
  7.         char chrSimbolo_e = '∃';
  8.         char chrSimbolo_integral = '∫';
  9.         char chrSimbolo_integralDoble = '∬';
  10.         char chrSimbolo_diferente = '≠';
  11.         // en formato numérico hexadecimal
  12.         char chrLetra_A_ = '\u0041';
  13.         char chrLetra_a_ = '\u0061';
  14.         char chrLetra_0_ = '\u0030';
  15.         char chrLetra_9_ = '\u0039';
  16.         char chrSimbolo_plus_ = '\u002B';
  17.  
  18.         printConsole("chars: " + chrLetra_A + " " + chrLetra_a + " " + chrLetra_0 + " " + chrLetra_9 + " " + chrSimbolo_plus);
  19.         printConsole("chars: " + chrSimbolo_e + " " + chrSimbolo_derivada + " " + chrSimbolo_integral + " " + chrSimbolo_integralDoble + " " + chrSimbolo_diferente);
  20.         printConsole("chars: " + chrLetra_A_ + " " + chrLetra_a_ + " " + chrLetra_0_ + " " + chrLetra_9_ + " " + chrSimbolo_plus_);

salida

chars: A a 0 9 +
chars: ∃ ∂ ∫ ∬ ≠
chars: A a 0 9 +

Hay algunos caracteres que no son visibles en UNICODE y ASCII como LINEA SIGUIENTE, TABULADOR y otros caracteres que son parte del lenguaje como « ' » « " » , no se puede definir los siguiente

        char chrSimbolo_comilla simple_ = ' ' ';

por que un par de comillas es un contenedor, al introducir una comilla simple dentro del contenedor, JAVA lo interpreta como contendor desbalanceado por que hace falta un contenedor par igualar el par

se ideo que el carácter barra inclinada hacia la izquierda indica que le próximo carácter  es valido dentro de un contenedor de comillas simples

\' indica carácter de comilla simple
\" indica carácter de comilla doble

y para especificar la misma barra inclinada hacia la izquierda

\\ indica carácter de barra inclinada hacia la izquierda

\uXXXX indica carácter de l código unicode en formato Hexadecimal, máximo 16 bits

otros caracteres No  visibles o accesibles por teclado

\0 indica el 1er carácter del código UNICODE
\t indica carácter tabulación
\n indica carácter nueva línea

7: TIPOS EVOLVENTES o TIPOS BASICOS como OBJETOS

La programación orientada a objetos introdujo un nuevo tipo de datos, tipos no como simples datos primitivos o básicos, sino tipos de datos de referencia a objetos, algunos tipos de datos primitivos en JAVA son  int, long float, double, mientras tipos de datos de referencia a objetos son Integer, Long, Float, Double, String se diferencia a simple vista de los tipos primitivos por que inician en carácter o letra Mayúscula y son palabras completas « int  » versus « Integer »,  « float  » versus « Float » , para cadenas de caracteres no hay tipo de básico o primitivo, solo tipos de datos de referencia a objeto CADENA, llamado « String »

Próximamente e incluirá un ejemplo

redactando ...


Título: Re:Tutorial JAVA con GUI e IDE NetBeans 8.x
Publicado por: CompSystems en 29 de Enero de 2016, 10:06:17
Ahora un nuevo componente o CONTROL: CAJA DE CHEQUEO [✔]  (CheckBox)

Un vídeo de un amigo forero de todoPIC LUIS VARGAS, donde muestra el uso de este control


Componente/Controlador: CAJA DE CHEQUEO [✔]
Nomenclatura: CHECK BOX, interno JCheckBox#
Prefijo para el identificador/atributo/variable: chkB (inicia en minúscula)
Uso: Proporciona una salida boleano para ser usada como una bandera (Flag)
Entrada: clic sobre el campo
Salida: cada ves que se da [clic] sobre el campo de selección se almacena en el ID de programación un valor booleano TRUE O FALSE, true si se selecciono, lo contrario false

Pasos
PASO #0: Creamos un nuevo proyecto de nombre por ejemplo "CajaDeChequeo" pero sin seleccionar clase principal ya que usaremos un JframeForm como clase principal

PASO #1: Creamos un nuevo paquete de nombre "tutorialJava.usoDeControladores.diseño.asistido" "¿por que un nombre tan largo", desde que inicie el otro hilo sobre creación de GUIs desde teclado, quiero diferenciar y organizar mejor los ejemplos en subdirectorios o paquetes

Los que son CON diseño asistido terminan en (.asistido) implica en su mayoría arrastrar y pegar controles desde la paleta o catalogo de controles (Unos lo llaman PROGRAMACIÓN A GOLPE DE RATÓN)

Los que son SIN diseño asistido terminan en (.teclado) implica codificar la GUI desde teclado, (Unos lo llaman PROGRAMACIÓN A GOLPE DE TECLA)

PASO #2: Creamos una Java FROM Class de nombre "FrmCajaDeChequeo",  el código fuente que genera automáticamente el IDE es:

Código: Java
  1. //File: FrmCajaDeChequeo.java
  2. package tutorialJava.usoDeControladores.diseño.asistido;
  3.  
  4. public class FrmCajaDeChequeo extends javax.swing.JFrame {
  5.  
  6.     public FrmCajaDeChequeo() {
  7.         initComponents();
  8.     }
  9.  
  10.     private void initComponents() { ... }                        
  11.  
  12.     public static void main(String args[]) {
  13.  
  14.         java.awt.EventQueue.invokeLater(new Runnable() {
  15.             public void run() {
  16.                 new FrmCajaDeChequeo().setVisible(true)
  17.             }
  18.         });
  19.     }
  20.  
  21.     // DECLARACIÓN DE LOS CONTROLES DE LA GUI
  22.     // Variables declaration - do not modify
  23.  
  24.     // End of variables declaration                  
  25. }

PASO #3: optimizar la presentación de la ventana, en la función MAIN, el código fuente que genera automáticamente el IDE es:

Código: Java
  1. public static void main(String args[]) {
  2.  
  3.         java.awt.EventQueue.invokeLater(new Runnable() {
  4.             public void run() {
  5.                 new FrmCajaDeChequeo().setVisible(true);
  6.                }
  7.         });
  8.     }

reemplazamos la sentencia new FrmCajaDeChequeo().setVisible(true); con sentencias escritas desde teclado para colocar titulo y centrar la ventana con el objetivo de mejorar su presentación

La porción de código modificada es:
Código: Java
  1. public static void main(String args[]) {
  2.  
  3.         java.awt.EventQueue.invokeLater(new Runnable() {
  4.             public void run() {
  5.                 //new FrmCajaDeChequeo().setVisible(true)
  6.                 // Crea un objeto de nombre "win1_obj" apartir de la clase FORM: FrmCajaDeChequeo
  7.                 FrmCajaDeChequeo win1_obj = new FrmCajaDeChequeo();
  8.                 // Coloca el titulo en la barra de títulos de la ventana del objeto "win1_obj"
  9.                 win1_obj.setTitle("Uso del control CAJA DE CHEQUEO [✔]");
  10.                 // Sentencia para centrar la ventana "win1_obj"
  11.                 win1_obj.setLocationRelativeTo(win1_obj);
  12.                 // Permanece visible la ventana
  13.                 win1_obj.setVisible(true);
  14.             }
  15.         });
  16.     }

PASO #4: Agregamos el componente JCheckBox, y Editamos o renombramos  la etiqueta del JCheckBox  de "JCheckBox1" a "Do you like programming", también Editamos o renombramos el ID de programacion a "chkBCajaDeSeleccion1" lo primero que se observa es que se agrego al código anterior la declaración del JCheckBox y el texto de la etiqueta del mismo

Código: Java
  1. private void initComponents() {
  2. chkBCajaDeSeleccion1.setText("Do you like programming");
  3. ...
  4. }
  5.  
  6. // DECLARACIÓN DE LOS CONTROLES DE LA GUI
  7.     // Variables declaration - do not modify                    
  8.     private javax.swing.JCheckBox chkBCajaDeSeleccion1;
  9.     // End of variables declaration

PASO #5: Desde la pestaña DESING, damos doble clic sobre el JCheckBox, para que el IDE genere la ISR RUTINA DE SERVICIO DE INTERRUPCIÓN

el código fuente que genera automáticamente el IDE es:
Código: Java
  1. private void chkBCajaDeSeleccion1ActionPerformed(java.awt.event.ActionEvent evt) {                                                    
  2.        
  3.    }

PASO #5: Agregamos el código del ISR que se ejecutara solo dar clic sobre la caja de chequeo [✔] cuando el programa este corriendo

Código: Java
  1. private void chkBCajaDeSeleccion1ActionPerformed(java.awt.event.ActionEvent evt) {                                                    
  2.         if (chkBCajaDeSeleccion1.isSelected() == true) {
  3.             JOptionPane.showMessageDialog(null, "like programming =)");
  4.         } else {
  5.             JOptionPane.showMessageDialog(null, "I do not like programming =( ");
  6.         }

Listo, al chequear se muestra un mensaje "like programming =)" y al deseleccionarlo  "I do not like programming =( "

En el vídeo (minuto 3.07) se muestra otra forma alternativa de controlar a JCheckBox1, por medio de las propiedades del mismo
Título: Re:Tutorial JAVA con GUI e IDE NetBeans 8.x
Publicado por: CompSystems en 29 de Enero de 2016, 14:56:04
Preparando resumen del próximo vídeo

Vídeo sobre el controlador RADIO_BUTTOM  (Botón radial), opera similar a CheckBox