Tutoriales JAVA

Tutoriales JAVA
Java Básico - Consola.
Palabras reservadas en Java.

Existe una serie de palabras reservadas las cuales tienen un significado especial para Java y por lo tanto no se pueden utilizar como nombres de variables.
 package
 abstract  default  if
 private
 boolean  do  implements  this
 protected
 break  double  import  throw
 public
 byte  else  instanceof  throws
 return
 case  extends  int  transient
 short
 catch  final  interface  try
 static
 char  finally  long  void
 super
 class  float  native  volatile
 switch
 const  for  new  while

 continue  goto  null
synchronized
Java. Tipos Primitivos de Variables.

Se llaman tipos primitivos de variables de Java a aquellas variables sencillas que contienen los tipos de información más habituales: valores boolean, caracteres y valores
numéricos enteros o de punto flotante.
Tipo de variable Descripción
Boolean 1 byte. Valores true y false
Char 2 bytes. Unicode. Comprende el código ASCII
Byte 1 byte. Valor entero entre -128 y 127
Int 4 bytes. Valor entero entre -2.147.483.648 y 2.147.483.647
Long 8 bytes. Valor entre -9.223.372.036.854.775.808 y 9.223.372.036.854.775.807
Float 4 bytes (entre 6 y 7 cifras decimales equivalentes). De -3.402823E38 a -1.401298E-45 y de 1.401298E-45 a 3.402823E38
8 bytes (unas 15 cifras decimales equivalentes). De -1.79769313486232E308 a

Double
-4.94065645841247E-324 y de 4.94065645841247E-324 a 1.79769313486232E308
Primer programa en JAVA. Mostrar una línea de texto.
Una aplicación java es un programa de computadora que se ejecuta cuando se utiliza el comando java para iniciar la máquina virtual Java (JVM).
package com.java.basic;
//Opcional: Creamos un paquete con el nombre com.java.basic.
/**
*
* @author Ariel
*/
public class Bienvenido {
//Inicio del método main que ejecuta la aplicación

public static void main(String[] arg){
System.out.println("¡Bienvenido a la programación en JAVA!");
}
//Fin del método main
}
//Fin de la clase Bienvenido
Utilizando variable.
/**
*
* @author Ariel
*/
public class Bienvenido2 {
//Utilizanco objeto String
String bienvenido = "¡Bienvenido a la programación en JAVA!" ;
//Operación de salida con System.out.println
//Solo llamamos a la variable que contiene el valor...
System.out.println(bienvenido);
}
}
//Fin de la clase Bienvenido2
Utilizando JOptionPane.
//Importando JOptionPane
import javax.swing.JOptionPane;
/**
*
* @author Ariel
*/
public class Bienvenido3 {
//Utilizanco objeto String
String bienvenido = "¡Bienvenido a la programación en JAVA!" ;
//Operación de salida con JOptionPane
//Solo llamamos a la variable que contiene el valor...
JOptionPane.showMessageDialog(null, bienvenido);
}
}
//Fin de la clase Bienvenido3
Aplicación básica en Java. Suma de enteros.
Aplicación en la cual utilizamos el objeto Scanner para obtener datos del teclado y realizar una suma con ellas.
import java.util.Scanner;
/**
*
* @author Ariel
*/
public class Suma {

//Creamos un abjeto Scanner para obtener datos
Scanner num = new Scanner(System.in);
//Creamos tres variables enteros
int numUno;
int numDos;
int suma;
System.out.print("Ingresa el primer número: ");

numUno = num.nextInt();//Lee el primer número
System.out.print("Ingresa el segundo número: ");

numDos = num.nextInt();//Lee el segundo número
suma = (numUno + numDos);//realiza la suma
System.out.println("La Suma es: " + suma);//imprime el resultado
}
Java. Utilización de operadores de igualdad y relacionales.
Operador estándar Operador de Ejemplo
algebraico de igualdad o de Signifi cado de la
igualdad relacional de condición condición en Java
o relacional Java en Java
Operadores de igualdad
= == x ==y x es igual a y
≠ != x != y x es diferente a y
Operadores relacionales
> > x>y x es mayor que y
< < x<y x es menor que y
≥ ≥ x >= y x es mayor o igual que y
≤ ≤ x <= y x es menor o igual que y
/**
*
* @author Ariel
*/
public class Comparar {
// crea objeto Scanner para obtener la entrada de la ventana de comandos
Scanner entrada = new Scanner( System.in );
//Declara variables
int numUno; // primer número a sumar
int numDos; // segundo número a sumar
System.out.print( "Escriba el primer entero: " ); // indicador

numUno = entrada.nextInt(); // lee el primer número del usuario
System.out.print( "Escriba el segundo entero: " ); // indicador

numDos = entrada.nextInt(); // lee el segundo número del usuario
if ( numUno == numDos ){
System.out.println(numUno + " == " + numDos);
}
if ( numUno != numDos ){
System.out.println(numUno + " != " + numDos);
}
if ( numUno < numDos ){

System.out.println(numUno + " < " + numDos);
}
if ( numUno > numDos ){

System.out.println(numUno + " > " + numDos);
}
if ( numUno <= numDos ){

System.out.println(numUno + " <= " + numDos);
}
if ( numUno >= numDos ){

System.out.println(numUno + " >= " + numDos);
}
Java básico 001. Condicional if-else.

Utilización del condicional if-else.
/**
*
* @author Ariel
*/
public class CondicionalIF {

Scanner dato = new Scanner(System.in);
System.out.print("Ingresa el número del mes: ");
int mes = dato.nextInt();
if(mes == 1){
System.out.println("El mes : " + mes + " es enero.");
}
if(mes == 2){
System.out.println("El mes : " + mes + " es febrero.");
}
if(mes == 3){
System.out.println("El mes : " + mes + " es marzo.");
}
if(mes == 4){
System.out.println("El mes : " + mes + " es abril.");
}
if(mes == 5){
System.out.println("El mes : " + mes + " es mayo.");
}
if(mes == 6){
System.out.println("El mes : " + mes + " es junio.");
}
if(mes == 7){
System.out.println("El mes : " + mes + " es julio.");
}
if(mes == 8){
System.out.println("El mes : " + mes + " es agosto.");
}
if(mes == 9){
System.out.println("El mes : " + mes + " es septiembre.");
}
if(mes == 10){
System.out.println("El mes : " + mes + " es octubre.");
}
if(mes == 11){
System.out.println("El mes : " + mes + " es noviembre.");
}
if(mes == 12){
System.out.println("El mes : " + mes + " es diciembre.");
}
else{
System.out.println("Has introducido -" + mes + "- que no representa ningún mes.");
}
Java básico 002. Uso de Scanner(System.in)

Mostrar su nombre, sexo, edad y estado civil, que son ingresados por teclado.
/**
*
* @author Ariel
*/
public class DatoPersonal {

String nombre = "";
String sexo = "";
int edad=0;
String estadoCivil="";
System.out.print("Ingrese el nombre: ");

nombre = dato.nextLine();
System.out.print("Ingrese el sexo (Másculino - Femenino): ");

sexo = dato.nextLine();
System.out.print("Ingrese Estado Civil: ");
estadoCivil = dato.nextLine();
System.out.print("Ingrese edad: ");

edad = dato.nextInt();
System.out.println("* Nombre: " + nombre);

System.out.println("* Sexo: " + sexo);
System.out.println("* Estado Civil: " + estadoCivil);
System.out.println("* Edad: " + edad);
Java básico 003. Uso de Scanner(System.in), condicional “if”.

Ingresar por teclado el nombre y la edad de cualquier persona e imprima, solo si la persona es mayor de edad, el nombre de la persona.
/**
*
* @author Ariel
*/
public class Adulto {

String nombre = "";
int edad = 0;
System.out.print("Ingrese el Nombre: ");

System.out.print("Ingrese la Edad: ");
if(edad >= 18){
System.out.println("El nombre es: " + nombre + " (Mayor de Edad)");
}
}
Java básico 004. Uso de Scanner(System.in) condicional “if-else”.

Ingresar por teclado el nombre y la edad de cualquier persona e imprima solo si la persona es mayor de edad, el nombre de la persona, de lo contrario, imprima un mensaje
que diga : “no puede votar”.
/**
*
* @author Ariel
*/
public class Adulto {

String nombre = "";
int edad = 0;
System.out.print("Ingrese el Nombre: ");

System.out.print("Ingrese la Edad: ");
if(edad >= 18){

System.out.println("El nombre es: " + nombre + " (Mayor de Edad)");
}
else{
System.out.println("El nombre es: " + nombre + " (Menor de Edad) !No puede votar¡");
}
}
}
Java básico 005. Uso de Scanner(System.in), condicional “if-else”, Math.sqrt().

Ingrese un número y calcule e imprima su raíz cuadrada. Si el número es negativo imprima el número y un mensaje que diga “tiene raíz imaginaria”.
/**
*
* @author Ariel
*/
public class RaizCuadrada {
public static void main (String[] arg){

int num;
double raiz;
Scanner numero = new Scanner(System.in);

System.out.print("Ingresar un número: ");
num = numero.nextInt();
if(num >=0){
raiz = Math.sqrt(num);
System.out.println("La raiz cuadrada de (" +num + ") es ("+raiz+")");
}
else{
System.out.println("La raiz cuadradade de: " + num + " es imaginaria.");
}
Java básico 006. Uso de Scanner(System.in), condicional “if”.

Ejercicio: Ingrese dos números desde el teclado e imprima solo los positivos.
/**
*
* @author Ariel
*/
public class Positivos {

float numUno, numDos;
System.out.print("Ingrese el primer número: ");

numUno = num.nextFloat();
System.out.print("Ingrese el segundo número: ");

numDos = num.nextFloat();
if(numUno >= 0){

System.out.println("Primer número (" + numUno + ")");
}
if(numDos >=0){
System.out.println("Segundo número (" + numDos + ")");
}
Java básico 007. Uso de Scanner(System.in), condicional “if”, operador “&&”.

 '&&': devuelve true si ambos operando son true.
Ejercicio: Ingrese dos números desde el teclado e imprima ambos números sólo si son positivos.
/**
*
* @author Ariel
*/



if(numUno >= 0 && numDos >= 0){

}
Java básico 008. Uso de Scanner(System.in), condicional “if”, operador “||” y “!=”.
 '||' : devuelve true si alguno de los operandos son true.
 '!=' : Niega el operando que se le pasa. Diferente de...
Ejercicio: Ingrese dos números desde el teclado e imprima ambos números sólo si son positivos.
/**
*
* @author Ariel
*/



if(numUno >= 0 || numDos >= 0){

}
Ejercicio: Ingrese dos números desde el teclado e imprima ambos números solo si son de diferente signo y distintos de cero.
/**
*
* @author Ariel
*/

int numUno, numDos;

numUno = num.nextInt();

numDos = num.nextInt();
if((numUno != numDos) && (numDos != 0)){

if(((numUno > 0) && (numDos <0)) || (numUno < 0) && (numDos > 0)){
}
}
Java básico 009. Uso de Scanner(System.in), condicional “if-else”.

Ejercicio: Lea dos números y calcule el cociente de dividir el primero por el segundo. Imprima el cociente. Si el segundo número es cero no ejecute el cálculo e imprima un
mensaje que diga: “la división no es posible”.
/**
*
* @author Ariel
*/
public class Cociente {

int numUno, numDos;
float div;


if((numDos > 0) && (numUno > 0)){

div = numUno / numDos;
System.out.println("La división da: " + div);
}
else{
System.out.println("La división no es posible");
}
}
Java básico 010. Uso de Scanner(System.in).

Ejercicio: Leer el nombre de un empleado, su salario básico por hora y el número de horas trabajadas en el mes. Calcular su salario mensual e imprimir tanto el nombre
como su salario mensual.
/**
*
* @author Ariel
*/
public class Salario {
public static void main(String [] arg){

String nombre;
int horasMes;
long horaSalario;
long salarioMes;

System.out.print("Ingrese el nombre del empleado: ");
System.out.print("Ingrese las horas trabajas en el mes: ");

horasMes = dato.nextInt();
System.out.print("Ingrese el salario por cada hora trabajada: ");

horaSalario = dato.nextLong();
salarioMes = horasMes * horaSalario;
System.out.println(nombre + " El saladio del mes es: " + salarioMes + "$");
Java básico 011. Uso buble for.

Ejercicio: Obtenga los 100 primeros números naturales.
/**
*
* @author Ariel
*/
public class CienNum {

for (int i = 1; i <= 100; i++) {
System.out.println("- " + i);
}
}
}
Ejercicio: Obtener los números pares comprendidos entre 1 y 1000.
/**
*
* @author Ariel
*/
public class NumPar {

for (int i = 2; i <= 1000; i+=2) {
}
}
Java básico 013. Uso buble for, condicional "if".

Ejercicio: Leer un número entero positivo y obtener los múltiplos de 3 comprendidos entre 1 y el número leído.
/**
*
* @author Ariel
*/
public class Mult3 {

int num;
int mod;
System.out.print("Ingresa un numero: ");

if(num > 0){

for (int i = 1; i < num; i++) {
mod = i % 3;
if(mod == 0){
System.out.println(" -" + i);
}
}
}
}

Ejercicio: Calcule la suma de los 100 primeros números naturales.
/**
*
* @author Ariel
*/
public class SumaNatural {

int sum=0;
for (int i = 1; i <= 100; i++) {

sum += i;
}
System.out.println("La suma es: " + sum);
}
}
Ejercicio: Obtener la suma de los números pares comprendidos entre 1 y 100.
/**
*
* @author Ariel
*/
public class SumaPar {
int sum=0;
for (int i = 2; i <= 100; i+=2) {

sum += i;
}
System.out.println("La suma es: " + sum);
}
Java básico 016. Uso buble do-while.

Ejercicio: Leer una serie de números. Obtener el cuadrado y el cubo de cada número e imprimir tanto los números como sus cuadrados y sus cubos.
/**
*
* @author Ariel
*/
public class Potencia {
String salir = null;
int numero;
int cubo;
int cuadrado;
Scanner scan = new Scanner(System.in);
do {
System.out.println("Presiona \"s\" para salir o \"n\" para seguir...");
salir = scan.next();
if(salir.equals("s")){
break;
}
System.out.println("Ingrese número: ");
numero = scan.nextInt();
cuadrado = numero * numero;
cubo = numero * numero * numero;
System.out.println("El cuadrado de: " + numero + " es -" + cuadrado);
System.out.println("El cubo de: " + numero + " es -" + cubo);
} while (true);
}

Ejercicio: Escribir un programa en Java que lea un número entero desde teclado y realiza la suma de los 100 número siguientes, mostrando el resultado en pantalla.
/**
*
* @author Ariel
*/
public class SumaDos {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
int num = 0;
System.out.print("Ingrese el número: ");
for (int i = num + 1 ; i < num + 101; i++) {
}
}
}
Java básico 018. Control de excepciones, Scanner(System.in).

Ejercicio: Escribir un programa en Java que calcule el área de un rectángulo del cual se le proporcionará por el teclado su altura y base.
/**
*
* @author Ariel
*/
public class Rectangulo {
/**
*/
int base = 0;
int altura = 0;
int area = 0;
System.out.println("Calcular el Área de un Rectángulo.");
try {
System.out.print("Ingrese la base del Rectángulo: ");
base = num.nextInt();
System.out.print("Ingrese la altura del Rectángulo: ");
altura = num.nextInt();
area = base * altura;
System.out.println("Resultado.");
System.out.println("El Área resultante es: " + area);
} catch (Exception e) {
System.out.print("ERROR de datos...");
}
}
}
Java básico 019. Arrays, Arrays.sort().

Almacenar información con el uso de Arrays. Uso de Arrays.sort().
import java.util.Arrays;
/**
*
* @author Ariel
*/
public class ArrayNum {
/**
*/
int num[] = new int[10];
Scanner numT = new Scanner(System.in);
for (int i = 0; i < num.length; i++) {
System.out.print("Ingrese número. Indice: " + i + ": ");
num[i]=numT.nextInt();
}
System.out.println("Imprimiendo datos.");
System.out.println("Dato - Indice " + i + ": " + num[i]);
}
System.out.println("Ordenando.");
Arrays.sort(num);
int j = num[i];
System.out.println("Dato - Indice " + i + ": " + j);
}
}
}
Java básico 020. Arrays - String, Arrays.sort().

Almacenar información con el uso de Arrays. Uso de Arrays.sort() para realizar ordenamiento.
/**
*
* @author Ariel
*/
public class ArrayString {
/**
*/
String nombre[] ={"Carlos","Luís","Anibal","Lourdes","Sonia","Marcela"
,"Miriam","Pedro","Víctor","Daniel","Elias"};
Arrays.sort(nombre);//Ordenamos el array.
for (int i = 0; i < nombre.length; i++) {
String string = nombre[i];
System.out.println(" - " + string);
}
}
}
Java básico 021. Ordenamiento por inserción.

Ordenamiento de un “Array” de enteros utilizando el método de ordenamiento por inserción.
public class OrdenamientoInsercion {
/**
*/
OrdenamientoInsercion orden = new OrdenamientoInsercion();
int[] nums = {1,4,9,59,23,26,20,1,23,56,7};
int[] ordenarInsercion = orden.ordenarInsercion(nums);
for (int i = 0; i < ordenarInsercion.length; i++) {
System.out.println(ordenarInsercion[i]);
}
}
public int[] ordenarInsercion(int[] array){
int aux;
for (int i = 1; i < array.length; i++) {
aux = array[i];
for (int j = i-1; j >=0 && array[j]>aux; j--) {
array[j+1]=array[j];
array[j]=aux;
}
}
return array;
}
}
Java básico 022. Utilización de “SimpleDateFormat”, Calendar, formato de fecha y hora.
Métodos para obtener fecha, hora y poder convertir al formato “día-mes-año”, “hora-minuto-segundo”. Conversión de objeto Calendar a String, como de String a objeto
Calendar.
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
/**
*
* @author Ariel
*/
public class TesFechaHora {
/**
*/
TesFechaHora test = new TesFechaHora();
Calendar fecha = Calendar.getInstance();
String retornarString = test.retornarString(fecha);
String retornarStringHora = test.retornarStringHora(fecha);
System.out.println("La fecha es: " +retornarString + " " + "La Hora es: " +retornarStringHora);
}
public String retornarString(Calendar fecha){

String retorno=null;
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
if (fecha != null) {
retorno = sdf.format(fecha.getTime());
}
return retorno;
}
public Calendar retornarCalendar(String fecha){

Calendar cal = Calendar.getInstance();
try {
cal.setTime(sdf.parse(fecha));
} catch (ParseException ex) {
JOptionPane.showMessageDialog(null, "Error; compruebe formato de fecha: " + ex);
}
return cal;
}
public String retornarStringHora(Calendar fecha){
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
}
return retorno;
}
Java básico 023. Ordenamiento por Burbuja.

Ordenamiento de un “Array” de enteros utilizando el método de ordenamiento por Burbuja.
public class OrdenamientoBurbuja {
/**
*/
OrdenamientoBurbuja ordenar = new OrdenamientoBurbuja();
int num[] = {12,48,59,28,36,78,59,48,63,24,11,20,83,16};
ordenar.ordenar(num);
int j = num[i];
System.out.println(" - " + j);
}
}
public void ordenar(int[] array){

int aux;
boolean cambio = false;
while (true) {
cambio = false;
for (int i = 1; i < array.length; i++) {
if(array[i]<array[i-1]){
aux = array[i];
array[i]=array[i-1];
array[i-1]=aux;
cambio = true;
}
}
if(cambio==false){
break;
}
}
}
}
Java básico 024. Área de un Círculo.

Ejercicio: Pedir el radio de un círculo y calcular su área. A=PI*r^2.
/**
*
* @author Ariel
*/
public class AreaCiculo {
/**
*/
double area, radio;
try {
System.out.print("Introduce el radio de un Círculo: ");
radio = num.nextDouble();
area = Math.PI*(radio*radio);
System.out.println("El área del Círculo resultante es: " + area);
System.out.println("Error: " + e);
}
}
}
Java básico 025. Determinar múltiplo entre dos número.

Ejercicio: Pedir dos números y decir si uno es múltiplo del otro.
/**
*
* @author Ariel
*/
public class Multiplo {
/**
*/
int num1, num2;
try {
System.out.print("Ingresa el primer número: ");
num1 = num.nextInt();
System.out.print("Ingresa el segundo número: ");
num2 = num.nextInt();
if(num1%num2==0){
System.out.println("El " + num2 + " es multiplo de " + num1);
}
else{
System.out.println("El " + num2 + " no es multiplo de " + num1);
}
System.out.println("Error: " + e);
}
}
}
Java básico 026. Conversión de números a letras.

Métodos para convertir números a letras y su utilización.
Referencia: jc-mouse
import java.util.regex.Pattern;
/**
*
* @author Ariel
*/
public class LetraNum {
/**
*/
LetraNum letraNum = new LetraNum();
String monto;
try {
monto = num.nextLine();
String Convertir = letraNum.Convertir(monto, true);
System.out.println(Convertir);
System.out.print(e);
}
}
private final String[] UNIDADES = {"", "un ", "dos ", "tres ", "cuatro ", "cinco ", "seis ", "siete ", "ocho ", "nueve "};
private final String[] DECENAS = {"diez ", "once ", "doce ", "trece ", "catorce ", "quince ", "dieciseis ",
"diecisiete ", "dieciocho ", "diecinueve", "veinte ", "treinta ", "cuarenta ",
"cincuenta ", "sesenta ", "setenta ", "ochenta ", "noventa "};
private final String[] CENTENAS = {"", "ciento ", "doscientos ", "trecientos ", "cuatrocientos ", "quinientos ",
"seiscientos ",
"setecientos ", "ochocientos ", "novecientos "};
public String Convertir(String numero, boolean mayusculas) {

String literal = "";
String parte_decimal;
//si el numero utiliza (.) en lugar de (,) -> se reemplaza
numero = numero.replace(".", ",");
//si el numero no tiene parte decimal, se le agrega ,00
if(numero.indexOf(",")==-1){
numero = numero + ",00";
}
//se valida formato de entrada -> 0,00 y 999 999 999,00
if (Pattern.matches("\\d{1,9},\\d{1,2}", numero)) {
//se divide el numero 0000000,00 -> entero y decimal
String Num[] = numero.split(",");
//de da formato al numero decimal
parte_decimal = Num[1] + "...";
//se convierte el numero a literal
if (Integer.parseInt(Num[0]) == 0) {//si el valor es cero
literal = "cero ";
} else if (Integer.parseInt(Num[0]) > 999999) {//si es millon
literal = getMillones(Num[0]);
} else if (Integer.parseInt(Num[0]) > 999) {//si es miles
literal = getMiles(Num[0]);
} else if (Integer.parseInt(Num[0]) > 99) {//si es centena
literal = getCentenas(Num[0]);
} else if (Integer.parseInt(Num[0]) > 9) {//si es decena
literal = getDecenas(Num[0]);
} else {//sino unidades -> 9
literal = getUnidades(Num[0]);
}
//devuelve el resultado en mayusculas o minusculas
if (mayusculas) {
return (literal + parte_decimal).toUpperCase();
} else {
return (literal + parte_decimal);
}
} else {//error, no se puede convertir
return literal = null;
}
}
/* funciones para convertir los numeros a literales */
private String getUnidades(String numero) {// 1 - 9

//si tuviera algun 0 antes se lo quita -> 09 = 9 o 009=9
String num = numero.substring(numero.length() - 1);
return UNIDADES[Integer.parseInt(num)];
}
private String getDecenas(String num) {// 99

int n = Integer.parseInt(num);
if (n < 10) {//para casos como -> 01 - 09
return getUnidades(num);
} else if (n > 19) {//para 20...99
String u = getUnidades(num);
if (u.equals("")) { //para 20,30,40,50,60,70,80,90
return DECENAS[Integer.parseInt(num.substring(0, 1)) + 8];
} else {
return DECENAS[Integer.parseInt(num.substring(0, 1)) + 8] + "y " + u;
}
} else {//numeros entre 11 y 19
return DECENAS[n - 10];
}
}
private String getCentenas(String num) {// 999 o 099

if( Integer.parseInt(num)>99 ){//es centena
if (Integer.parseInt(num) == 100) {//caso especial
return " cien ";
} else {
return CENTENAS[Integer.parseInt(num.substring(0, 1))] + getDecenas(num.substring(1));
}
}else{//por Ej. 099
//se quita el 0 antes de convertir a decenas
return getDecenas(Integer.parseInt(num)+"");
}
}
private String getMiles(String numero) {// 999 999

//obtiene las centenas
String c = numero.substring(numero.length() - 3);
//obtiene los miles
String m = numero.substring(0, numero.length() - 3);
String n="";
//se comprueba que miles tenga valor entero
if (Integer.parseInt(m) > 0) {
n = getCentenas(m);
return n + "mil " + getCentenas(c);
} else {
return "" + getCentenas(c);
}
private String getMillones(String numero) { //000 000 000

//se obtiene los miles
String miles = numero.substring(numero.length() - 6);
//se obtiene los millones
String millon = numero.substring(0, numero.length() - 6);
String n = "";
if(millon.length()>1){
n = getCentenas(millon) + "millones ";
}else{
n = getUnidades(millon) + "millon ";
}
return n + getMiles(miles);
}
}
Java básico 027. Utilizando “do-while”.

Ejercicio: Pedir números hasta que se teclee un 0, mostrar la suma de todos los números introducidos.
/**
*
* @author Ariel
*/
public class SumaDo {
/**
*/
int num, suma=0;
do {
System.out.print("Ingrese un número: ");
suma+=num;
} while (num != 0);
System.out.println("La suma total da: " + suma);
//Se sale del bucle a ingresas 0.
}
}
Java básico 028. Factorial de un número.

Ejercicio: Pedir un número y calcular su factorial.
/**
*
* @author Ariel
*/
public class FactorialNumero {
/**
*/
//Ej.: El factorial de 5 es: 5*4*3*2*1
long factorial=1;
int num;
System.out.print("Introduce un número: ");
for (int i = num; i > 0; i--) {
factorial = factorial * i;
}
System.out.println("El factorial de " + num + " es: " + factorial);
}
}
Java básico 029. Encontrar múltiplos de 3.

Ejercicio: Pedir 5 números e indicar si alguno es múltiplo de 3.
/**
*
* @author Ariel
*/
public class MultiploTres {
/**
*/
int num;
boolean multiploTres = false;
for (int i = 0; i < 5; i++) {
if(num % 3 == 0){
//Hay múltiplo de tres...
multiploTres = true;
}
}
if(multiploTres==false){
System.out.println("No se introdujeron múltiplos de (3).");
}
else{
System.out.println("Hay al menos un múltiplo de (3).");
}
}
}
Java básico 030. Tabla de multiplicar de un número entre 0 y 10.
Ejercicio: Pide un número (que debe estar entre 0 y 10) y mostrar la tabla de multiplicar de dicho número.
/**
*
* @author Ariel
*/
public class TablaMultiplicar {
/**
*/
int num;
do {
System.out.print("Ingresa un número (del 0 al 10): ");
} while ( 0 <= num && num >= 10);
for (int i = 1; i <= 10; i++) {

System.out.println(num + " X " + i + " = " + num*i);
}
}
}
Java básico 031. Tabla de multiplicar del 1 al 10. Utilizando bucles anidados.
Ejercicio: Diseña una aplicación que muestre las tablas de multiplicar del 1 al 10.
public class TablaMultiplicarDos {
/**
*/
//Utilizando Bucles anidados.
for (int i = 1; i <= 10; i++) {
System.out.println("Tabla de multiplicar del " + i);
for (int j = 1; j <= 10; j++) {
System.out.println(i + " X " + j + " =" + i*j);
}
}
}
Java básico 032. Imprimiendo Arrays orden inverso.

Ejercicio: Leer 5 números y mostrarlos en orden inverso al introducido.
/**
*
* @author Ariel
*/
public class NumArray {
/**
*/
int num[] = new int[5];
num[i]=numero.nextInt();
}
System.out.println("Imprimiendo orden inverso.");
for (int i = num.length - 1; i >= 0 ; i--) {
System.out.println("Indice " + i + " =" + num[i]);
}
}
}
Java básico 033. Arrays bidimensionales.

Ejercicio: Crear una tabla bidimensional de tamaño 5x5 y rellenarla de la siguiente forma: la posición T[n,m] debe contener n+m. Después se debe mostrar su contenido.
public class Bidimensional {
/**
*/
int[][] num = new int[5][5];
for (int i = 0; i < num.length; i++) {//Dimensión Uno.
for (int j = 0; j < num.length; j++) {//Dimensión Dos.
num[i][j]=i+j;
}
}
System.out.println("Imprimiendo Tabla.");
System.out.println();
for (int j = 0; j < num.length; j++) {
System.out.print(num[i][j] + " ");
}
}
}
}
Java básico 034. Arrays bidimensionales. Suma de Filas y Columnas.

Ejercicio: Crear y cargar una tabla de tamaño 3x3, mostrar la suma de cada fila y de cada columna.
/**
*
* @author Ariel
*/
/**
*/
System.out.println("Ingrese los números.");
num[i][j]=numero.nextInt();
}
}
}
}
System.out.println("\nSuma Fila.");
int suma=0;
suma += num[i][j];
}
System.out.println("Fila " + i + " =" + suma);
suma=0;
}
System.out.println("\nSuma Columna");
suma += num[j][i];
}
System.out.println("Columna " + i + " =" + suma);
suma=0;
}
}
}
Java básico 034. Arrays bidimensionales. Suma de Filas y Columnas.

Ejercicio: Crear y cargar una tabla de tamaño 3x3, mostrar la suma de cada fila y de cada columna.
/**
*
* @author Ariel
*/
/**
*/
}
}
}
}
System.out.println("\nSuma Fila.");
int suma=0;
suma += num[i][j];
}
System.out.println("Fila " + i + " =" + suma);
suma=0;
}
System.out.println("\nSuma Columna");
suma += num[j][i];
}
System.out.println("Columna " + i + " =" + suma);
suma=0;
}
}
}
Java básico 035. Arrays bidimensionales. Comprobando Simetría.

Ejercicio: crear y cargar una tabla de tamaño 4x4 y decir si es simétrica o no, es decir si se obtiene la misma tabla al cambiar las filas por columnas.
/**
*
* @author Ariel
*/
public class BidimensionArrays {
boolean simetrico;
System.out.print("["+i+"]"+"["+j+"]"+"=");
}
}
}
}
System.out.println("\nComprobando Simetria.");
simetrico = true;
int control = num.length -1;
int i=0;
while (i < control && simetrico == true) {
int j=0;
while (j < control && simetrico == true) {
if(num[i][j] != num[j][i]){
simetrico = false;
}
j++;
}
i++;
}
if(simetrico){
System.out.println("La tabla resulta Simétrica.");
}
else{
System.out.println("La tabla no es Simétrica.");
}
}
}
Java básico 036. Arrays bidimensionales. Suma de tablas.

Ejercicio: Crear y cargar dos matrices de tamaño 3x3, sumarlas y mostrar su suma.
/**
*
* @author Ariel
*/
public class BidimensionSuma {
int[][] numUno = new int[3][3];
int[][] numDos = new int[3][3];
System.out.println("Cargando Tabla Uno.");
for (int i = 0; i < numUno.length; i++) {//Dimensión Uno.
for (int j = 0; j < numUno.length; j++) {//Dimensión Dos.
numUno[i][j]=numero.nextInt();
}
}
System.out.println("Cargando Tabla Dos.");
for (int i = 0; i < numDos.length; i++) {//Dimensión Uno.
for (int j = 0; j < numDos.length; j++) {//Dimensión Dos.
numDos[i][j]=numero.nextInt();
}
}
System.out.println("Imprimiendo Tabla Uno.");
for (int i = 0; i < numUno.length; i++) {
for (int j = 0; j < numUno.length; j++) {
System.out.print(numUno[i][j] + " ");
}
}
System.out.println("\nImprimiendo Tabla Dos.");
for (int i = 0; i < numDos.length; i++) {
for (int j = 0; j < numDos.length; j++) {
System.out.print(numDos[i][j] + " ");
}
}
int[][] suma = new int[3][3];
System.out.println("\nSumando las dos Tablas.");
for (int i = 0; i < suma.length; i++) {
for (int j = 0; j < suma.length; j++) {
suma[i][j]= numUno[i][j] + numDos[i][j];
}
}
System.out.println("\nImprimiendo Suma.");
for (int i = 0; i < suma.length; i++) {
for (int j = 0; j < suma.length; j++) {
System.out.print(suma[i][j] + " ");
}
}
}
}
Java básico 037. Arrays bidimensionales. Transponer elementos deTabla.

Ejercicio: Crear y cargar una tabla de tamaño 3x3, trasponerla y mostrarla.
/**
*
* @author Ariel
*/
public class BidimensionTransponer {
}
}
System.out.println("Imprimiendo Tabla Original.");
}
}
//Solo se transpone los elementos por debajo de la diagonal principal.
//Caso contrario la matriz queda igual.
//Esta se hace inicializando "i" en 1.
System.out.println("\nTransponiendo Tabla.");
int aux;
aux = num[i][j];
num[i][j] = num[j][i];
num[j][i] = aux;
}
}
System.out.println("Mostrando Tabla transpuesta.");
}
}
}
}
Java básico 038. Función, un parámetro.

Ejercicio: Realizar una función, a la que se le pase como parámetro un número N, y muestre por pantalla N veces, el mensaje: “Función Ejecutada.”
/**
*
* @author Ariel
*/
public class FuncionUno {
/**
*/
int num;
System.out.print("Ingresa el parametro entero: ");
mostrar(num);
}
static void mostrar(int num){
for (int i = 0; i < num; i++) {
System.out.println("Función Ejecutada " + (i + 1));
}
}
}
Java básico 039. Función, dos parámetros y retorno.

Ejercicio: Diseñar una función que tenga como parámetros dos números, y que calcule el máximo.
/**
*
* @author Ariel
*/
public class FuncionDos {
/**
*/
int max, numUno, numDos;
System.out.print("Ingresa el primer parámetro: ");
System.out.print("Ingresa el segundo parámetro: ");
max = maximo(numUno, numDos);
System.out.println("El máximo es : " + max);
}
static int maximo(int a, int b){

//Se espera que los dos números sean distintos.
int max;
if(a > b){
max = a;
}
else{
max = b;
}
return max;
}
}
Java básico 040. Función, tres parámetros y retorno.

Ejercicio: Desarrolla una función que calcule el máximo de 3 números.
/**
*
* @author Ariel
*/
public class FuncionDos {
/**
*/
int max, numUno, numDos,numTres;
System.out.print("Ingresa el primer parámetro: ");
System.out.print("Ingresa el segundo parámetro: ");
System.out.print("Ingresa el tercer parámetro: ");
numTres = num.nextInt();
//Utilizamos la función pasandole los tres parámetros.
//Guardamos el resulado en una variable entera,
//ya que el retorno es de tipo entoro.
max = maximo(numUno, numDos, numTres);
System.out.println("El máximo es : " + max);
}
static int maximo(int a, int b, int c){

//Se espera que los tres números sean distintos.
int max;
if(a > b && a > c){
max = a;
}
else{
if(b > a && b > c){
max = b;
}
else{
max = c;
}
}
return max;
}
}
Java básico 041. Función de Arrays como parámetro más retorno.

Ejercicio: Desarrolla una función que calcule el máximo de una tabla (Arrays) de n elementos.
/**
*
* @author Ariel
*/
public class FuncionArray {
/**
*/
int numero[] = new int[20];
int max;
//Llenamos la tabla con elementos aleatorios.
for (int i = 0; i < numero.length; i++) {
numero[i] = (int)(Math.random() * 100 + 1);
}
//Imprimimos la tabla con los valores generados.
int j = numero[i];
System.out.print(j + " ");
}
//Buscamos el mayor de los valores generados.
max = maximo(numero);
//Imprimimos el resultado.
System.out.println("\nEl mayor resultante es: " + max);
//Ordenamos los elementos utilizando "sort" para comprobar.
Arrays.sort(numero);
//Impriminos ardenado.
int j = numero[i];
}
}
static int maximo(int[] num){
int max = num[0];
int j = num[i];
if(j > max){
max = j;
}
}
return max;
}
}
Java básico 042. Función de Arrays como parámetro, control de duplicación más retorno.
Ejercicio: Desarrolla una función que calcule el máximo de una tabla (Arrays) de n elementos. Agregar una función que permite controlar que los números generados
aleatoriamente no se repitan dentro del Arrays.
/**
*
* @author Ariel
*/
public class FuncionArray {
/**
*/
int numero[] = new int[25];
int max;
//Llenamos la tabla con elementos aleatorios.
int k = (int)(Math.random() * 100 + 1);
//Llamamos a la función control.
//Permite que los datos duplicados no se almacenen en la tabla.
boolean control = control(numero, k);
if(control==false){
numero[i] = k;
}
else{
i--;
}
}
//Imprimimos la tabla con los valores generados.
int j = numero[i];
}
//Buscamos el mayor de los valores generados.
max = maximo(numero);
System.out.println("\nEl mayor resultante es: " + max);
//Ordenamos los elementos utilizando "sort" para comprobar.
Arrays.sort(numero);
//Impriminos ardenado.
int j = numero[i];
}
}
//Función para encontrar el máximo.
static int maximo(int[] num){
int max = num[0];
int j = num[i];
if(j > max){
max = j;
}
}
return max;
}
//Función para controlar que no se repitan los valores-
//-generados de forma aleatoria.
static boolean control(int[] num, int k){
boolean control = false;
if(num[j] == k){
control = true;
}
}
return control;
}
}
Java básico 043. Ejercicio utilizando Función más retorno.

Ejercicio: Función a la que se le pasan dos enteros y muestra todos los números comprendidos entre ellos, inclusive.
/**
*
* @author Ariel
*/
public class MayorNN {
/**
*/
int numA, numB;
System.out.print("Ingresa el primer valor: ");
numA = num.nextInt();
System.out.print("Ingresa el segundo Valor: ");
numB = num.nextInt();
System.out.println("Imprimiendo valores.");
numeros(numA, numB);
}
static void numeros(int a, int b){
int mayor = 0, menor = 0;
if(a == b){
System.out.println("Datos iguales.");
}
else{
if(a > b){
mayor = a;
menor = b;
}
else{
mayor = b;
menor = a;
}
}
for (int i = menor; i <= mayor; i++) {
System.out.print(i + " ");
}
}
}
Java básico 044. Ejercicio utilizando Función más retorno. Potencia de a exp n.
Ejercicio: Desarrolla una función que permite calcular “a” elevado a “n” potencia.
/**
*
* @author Ariel
*/
public class PotenciaN {
/**
*/
int numA , numB;
System.out.print("Ingresa la base: ");
numA = num.nextInt();
System.out.print("Ingresa el exponente: ");
numB = num.nextInt();
System.out.println("Calculando potencia de " + numA + " exp " + numB);
long potencia = potencia(numA, numB);
System.out.println(numA + " elevado a " + numB + " = " + potencia );
}
static long potencia(int a, int n){
long res = 0;
if(a == 0 && n == 0){
System.out.println("No hay valor para mostrar.");
}
else{
if(n == 0){
res = 1;
}
else{
res = 1;
for (int i = 1; i <= n; i++) {
res= res * a;
}
}
}
return res;
}
}
Java básico 045. Función conversión a binario.

Ejercicio: Desarrolla una función que muestre en binario un número entre 0 y 255.
/**
*
* @author Ariel
*/
public class BinarioNum {
/**
*/
int num;
System.out.print("Ingresa un número entre 0 y 255: ");
try {
int[] binario = binario(num);
System.out.print("El binario de " + num + " es: " );
for (int i = binario.length - 1; i >= 0; i--) {
int j = binario[i];
System.out.print(j);
}
System.out.println("ERROR: Número fuera de rango.");
}
}
static int[] binario(int a){
int binario[];
if(a > 0 && a <= 255){
int cont = 0;
int var = a;
while (var != 0) {
var = var/2;
cont ++;
}
binario = new int[cont];
int t =0;
while (a != 0) {
binario[t] = a%2;
a = a/2;
t++;
}
return binario;
}
return null;
}
}
Java básico 046. Función, calculando seno, coseno y tangente.

Ejercicio: Dado el valor de un ángulo, sería interesante saber su seno, coseno y tangente. Escribir una función que muestre en pantalla los datos anteriores.
/**
*
* @author Ariel
*/
public class FuncionSCT {
/**
*/
double a;
try {
System.out.print("Introduce un ángulo de (0...360°): ");
a = num.nextDouble();
anguloCal(a);
System.out.println("ERROR: Datos incorrectos.");
}
}
static void anguloCal(double a){
//Primer punto, pasa "a" a radianes.
double b = Math.toRadians(a);
System.out.println("Seno de " + a + " es: " + Math.sin(b) );
System.out.println("Coseno de " + a + " es: " + Math.cos(b) );
System.out.println("Tangente de " + a + " es: " + Math.tan(b) );
}
}
Java básico 047. Función, potencia de (a^n) utilizando recursividad.

Ejercicio: Desarrolla una función recursiva que calcule (a^n).
/**
*
* @author Ariel
*/
public class RecurPotencia {
/**
*/
int result, a, n;
System.out.print("Ingresa la base (a): ");
a = num.nextInt();
System.out.print("Ingresa la potencia (n): ");
n = num.nextInt();
result = potencia(a, n);
System.out.println("El resultado de " + a + " exp " + n + " = " + result);
}
static int potencia(int a, int n){
int result;
if(n == 0){
result = 1;
}
else{
// caso recursivo: a^n = a *a^n-1
result = a * potencia(a, n - 1);
}
return result;
}
}
Java básico 048. Función, factorial de “n” utilizando recursividad.

Ejercicio: Calcular el factorial de “n” recursivamente.
/**
*
* @author Ariel
*/
public class FactorialRec {
/**
*/
int n, factor;
System.out.print("Ingresa un número para calcular el factorial: ");
n = num.nextInt();
factor = factorial(n);
System.out.println("El factorial de " + n + " es " + factor);
}
static int factorial(int n){
int factor;
if(n == 0){
factor = 1;
}
else{
factor = n * factorial(n - 1);
}
return factor;
}
}
Java básico 049. Función, obtener el máximo de un “Array” utilizando recursividad.

Ejercicio: Desarrollar una función que calcule el valor máximo de una tabla (array) de forma recursiva.
/**
*
* @author Ariel
*/
public class TablaMax {
/**
*/
//Creamos un array con 10 elementos.
int t[] = new int[10];
//Cargamos el array con números generados de forma aleatoria.
for (int i = 0; i < t.length; i++) {
t[i] = (int) (Math.random() * 1000 + 1);
}
//Imprimimos los datos del array
System.out.println("Imprimiendo tabla.");
for (int i = 0; i < t.length; i++) {
int j = t[i];
System.out.print("[" + j + "]");
}
System.out.println("\nObteniendo el máximo.");
//Usamos la segunda función que retorna el valor del primero.
int maximo = maximo(t);
System.out.println("El máximo de la tabla es: " + "[" + maximo + "]");
}
static int maximo(int t[], int pos){
//A la función le pasamos 2 argumentos. El array y la posición inicial del índice.
int res;
//Si llegamos al final del array significa que el último es el máximo.
if(pos == t.length - 1){
res = t[pos];
}
else{
//Vamos iterando el array utilizando recursividad.
int k = maximo(t, pos + 1);
if (t[pos] > k){
res = t[pos];
}
else{
res = k;
}
}
return res;
}
//Sobrecargamos la primera función, a esta solo le pasamos un argumento,
//que es el array. La función retorna un entero que será el maximo llamando
//la primera función.
static int maximo(int t[]){
return maximo(t, 0);
}
}
Java básico 050. Función, obtener semanas, días y HH:mm:ss de cierta cantidad de segundos.
Ejercicio: Desarrollar una función que lea de teclado una cierta cantidad de segundos y muestre su equivalente en semanas, días, horas, minutos y segundos.
Ejemplo: 2178585 segundos equivalen a [3] semanas, 4 días, 05:09:45.
/**
*
* @author Ariel
*/
public class FuncionSeg {
/**
*/
//Obtenemos los segundos con la función.
int segundos = segundos();
//Obtenemos el resultado.
String calculos = calculos(segundos);
System.out.println(calculos);
}
static String calculos(int s){
//Declaramos constantes enteros, representan valores absolutos.
final int segMin = 60;
final int minHora = 60;
final int horaDia = 24;
final int diaSemana = 7;
final int segHora = segMin * minHora;
final int segDia = segHora * horaDia;
final int segSemana = segDia * diaSemana;
//Especificamos el valor de cada variable.
int semana = s / segSemana;
//Con el resto seguimos el proceso descendiente.
int resto = s % segSemana;
int dia = resto / segDia;
resto = resto % segDia;
int hora = resto / segHora;
String horaS = hora + "";
//Un pequeño arreglo para mostrar formato HH:mm:ss.
if(hora < 10)horaS = "0" + horaS;
resto = resto % segHora;
int minuto = resto / segMin;
String minutoS = minuto + "";
if(minuto < 10)minutoS = "0" + minutoS;
int segundo = resto % segMin;
String segundoS = segundo + "";
if(segundo < 10)segundoS = "0" + segundoS;
//Almacenamos todo el resultado en un String usando concatenación.
String res = (s + " segundos representan " + "[" + semana + "]" + " semanas "
+ "[" + dia + "]" + " días y " + horaS +":" + minutoS + ":" + segundoS );
//Retornamos ese valor.
return res;
}
//Utilizamos una función para capturar los segundos del usuario.
static int segundos(){
int segundos;
Scanner seg = new Scanner(System.in);
//Utilizamos un try para comprobar que los datos sean enteros.
try {
System.out.print("Ingresa los segundo para comprobar: ");
segundos = seg.nextInt();
//En caso que no sea entero volvemos a lanzar la función.
System.out.println("ERROR: Ingresar datos numéricos entero.");
segundos = segundos();
}
return segundos;
}
}
Java básico 051. Función, imprimir un cuadrado hueco utilizando asteriscos “*”.
Ejercicio: Desarrollar una función que lea un número entero de teclado y escriba un cuadrado (hueco) con tantos asteriscos (*) de lado como indique el número leído. Por
ejemplo, para un número leído con valor 5, escribirá:
*****
* *
* *
* *
*****
/**
*
* @author Ariel
*/
public class FuncionDibuj {
/**
*/
//Declaramos un entero, cantidad de elementos.
int n;
//Utilizamos Scanner para capturar datos del teclado.
//El try sirve para capturar las excepciones de entrada de datos.
try {
System.out.print("Ingresa una cantidad entera.");
//Forma de capturar datos de teclado con Scanner.
n = num.nextInt();
//Llamamos la función pasando el entero capturado como argumento.
asterisco(n);
//En caso que el dato ingresado no sea de tipo entero, se indica el error.
System.out.println("ERROR: se espera dato entero.");
}
}
//Creamos la función al cual le pasamos un entero como argumento.
static void asterisco(int n){
//Creamos una variable tipo constante para utilizarla.
final char simbolo = '*';
//Creamos el primer for.
//Se hace con un preincremento ++j.
for (int i = 0; i < n; ++i) {
//Cada primer for, se hace un salto de línea.
//Anidamos otro for con el mismo proceso.
for (int j = 0; j < n; ++j) {
//Establecemos una condición para que se imprima el "*".
if((i == 0) || (i == n-1) || (j == 0) || (j == n - 1)){
System.out.print(simbolo);
}
else{
System.out.print(" ");
}
}
}
}
}
Java básico 052. Función, obtener cociente y resto sin utilizar operaciones de división.
Ejercicio: Diseñe un programa que lea del teclado dos números enteros y escriba en pantalla el cociente y resto de la división de ambos números, teniendo en cuenta que
no se permite utilizar las operaciones de división y resto (/, %), por lo que se deberá realizar mediante restas sucesivas.
Ejemplo: 7 / 2 = (7 -2 = 5; 5 -2 = 3 ; 3 -2 = 1 =) Cociente = 3 ; Resto = 1.
/**
*
* @author Ariel
*/
public class JavaCal {
/**
*/
//Declaramos dos variables enteras.
int dividendo;
int divisor;
//Utilizamos Scanner para capturar valores desde el teclado.
//Utilizamos "try" para controlar posibles errores de entrada de datos.
try {
//Procedemos a capturar los valores.
System.out.print("Ingresa el dividendo: ");
dividendo = num.nextInt();
System.out.print("Ingresa el divisor: ");
divisor = num.nextInt();
//Después de obtener los datos llamamos nuestra función.
calculo(dividendo, divisor);
System.out.println("Error de datos: " + e);
}
}
//Creamos nuestra función sin retorno.
//La función requerirá 2 parámetros.
static void calculo(int dividendo, int divisor){
int resto;
int cociente = 0;
//Condición en caso que número sea negativo o cero.
if(divisor <= 0){
System.out.println("No se puede realizar operación.");
}
else{
//Arreglos para mejorar el formato de impresión.
int y = dividendo - divisor;
System.out.println("(" + dividendo + "/" + divisor + ")" );
System.out.print("(" + dividendo + "-" + divisor + "=" + y + ")" );
resto = dividendo;
//Un bucle para realizar los cálculos necesarios.
while (resto >= divisor) {
resto -= divisor;
int var = resto - divisor;
++cociente;
//Por cada ciclo imprimimos los valores intermedios.
if(resto > divisor){
System.out.print("("+ resto + "-" + divisor + "=" + var + ")");
}
}
//Al termina el ciclo nos retorna los valores finales.
System.out.println("\nCociente: " + cociente + " ; " + "Resto: " + resto);
}
}
}
Java básico 053. Función, obtener multiplicación de (m * n) utilizando ciclo.

Ejercicio: Desarrollar una función que lea del teclado dos números enteros y escriba en pantalla el resultado de multiplicar ambos números, teniendo en cuenta que no se
permite utilizar la operación de multiplicar (*), por lo que se deberá realizar mediante sumas sucesivas. Por ejemplo, 2 x 3 = 2 + 2 + 2.
/**
*
* @author Ariel
*/
public class MultiFor {
/**
*/
//Declaramos dos variables tipo entero.
int m, n;
//Solicitamos los datos.
System.out.println("Introduce dos número enteros (m*n).");
System.out.print("Introduce m: ");
m = num.nextInt();
System.out.print("Introduce n: ");
n = num.nextInt();
//Llamamos a la función que creamos, pasandole los dos parámetros.
int multi = multi(m, n);
//Imprimimos datos.
System.out.println("La multiplicación ("+m+"*"+n+")= "+multi);
}
//Creamos la función con retorno tipo entero y dos parámetros.
static int multi(int m, int n){
int mul = 0;
//Establecemos condición de que (m y n) no sean cero.
if((m != 0) && (n != 0)){
//Utilizamos un for para ejecutar el ciclo de sumas.
for (int i = 0; i < n; i++) {
// += representa (mul = mul + m), solo acorta lo anterior.
mul += m;
}
}
//Retornamos el resultado.
//Si m o n es cero, retornará cero.
return mul;
}
}
Java básico 054. Función, cálculo de x^y utilizando multiplicación sucesiva.
Ejercicio: Diseñe un programa que lea de teclado dos números enteros (x e y) y escriba en pantalla el resultado de calcular la potencia de x elevado a y (x^y), mediante
multiplicaciones sucesivas. Por ejemplo, 2^3 = 2x2x2.
/**
*
* @author Ariel
*/
public class MultiSuce {
/**
*/
//Declaramos dos variable enteras.
int x, y;
//Utilizamos Scanner para capturar datos.
//Solicitamos los datos necesarios.
System.out.println("Ingresa la base y el exponenete.");
System.out.print("Base: ");
x = num.nextInt();
System.out.print("Exponente: ");
y = num.nextInt();
//Ejecutamos la función pasándole los argumentos necesarios.
long multSus = multSuc(x, y);
System.out.println("Resultado " + x + "^" + y + " = " + multSus);
}
//Creamos una función con retorno tipo long y dos argumentos tipo enteros.
static long multSuc(int x, int y){
long exp = 1;
//Comprobamos que los datos ingresados no sean ceros.
if(x != 0 && y != 0){
//Utilizamos un bucle for para la multiplicación sucesiva.
//Se hará la multiplicación tantas veces como el exponente ingresado.
for (int i = 1; i <= y; i++) {
//Esto representa exp = exp * x;
exp *= x;
}
}
//Retornamos el resultado.
return exp;
}
}
Java básico 055. Función, imprimir un cuadrado lleno utilizando asteriscos “*”.
Ejercicio: Diseñe una función que lea un número entero del teclado y escriba un cuadrado (relleno) con tantos asteriscos (*) de lado como indique el número leído. Por
ejemplo, para un número leído con valor 5, escribirá:
*****
*****
*****
*****
*****
/**
*
* @author Ariel
*/
public class FuncionDibujDos {
/**
*/
int n;
try {
n = num.nextInt();
asterisco(n);
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
}
}
}
}
Java básico 056. Función, imprimir un triángulo rectángulo lleno utilizando asteriscos “*”.
Ejercicio: Diseñe una función que lea un número entero del teclado y escriba un triángulo rectángulo (relleno) con tantos asteriscos (*) de base y altura como indique el
número leído.
Por ejemplo, para un número leído con valor 5, escribirá:

*
**
***
****
*****
/**
*
* @author Ariel
*/
public class FuncionDibujTres {
/**
*/
int n;
try {
n = num.nextInt();
asterisco(n);
}
}
//Se hace con un preincremento ++i al igual que ++j.
for (int i = 0; i < n; ++i) {
//Mientra "j" sea menor o igual a "i" se imprime, esto dará forma al
//Triángulo Rectángulo..
for (int j = 0; j <= i; ++j) {
}
}
}
}
Java básico 057. Función, imprimir un triángulo rectángulo hueco utilizando asteriscos “*”.
Ejercicio: Diseñe una función que lea un numero entero del teclado y escriba un triángulo rectángulo (hueco) con tantos asteriscos (*) de base y altura como indique el
número leído.

*
**
* *
* *
*****
/**
*
* @author Ariel
*/
public class FuncionDibujCuatro {
/**
*/
int n;
try {
System.out.print("Ingresa una cantidad entera: ");
n = num.nextInt();
asterisco(n);
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j <= i; ++j) {
//Establecemos una condición para que se imprima el "*".
if(((i==0)||(i==n-1)||(j==0)||(j==i))){
}
else{
}
}
}
}
}
Java básico 058. Función, imprimir un triángulo relleno utilizando asteriscos “*”.
Ejercicio: Diseñe una función que lea un número entero del teclado y escriba un triángulo (relleno) con tantos asteriscos (*) de altura como indique el número leído.

*
***
*****
*******
*********
/**
*
* @author Ariel
*/
public class FuncionDibujCinco {
/**
*/
int n;
try {
n = num.nextInt();
asterisco(n);
}
}
for (int i = 0; i < n; ++i) {
//Utilizamos dos for para lograr la forma.
for (int j = 0; j < n-i-1; ++j) {
}
for (int j = 0; j < 2*i+1; ++j){
}
}
}
}
Java básico 059. Función, imprimir un triángulo hueco utilizando asteriscos “*”.
Ejercicio: Diseñe una función que lea un número entero del teclado y escriba un triángulo (hueco) con tantos asteriscos (*) de altura como indique el número leído.

*
* *
* *
* *
*********
/**
*
* @author Ariel
*/
public class FuncionDibujSeis {
/**
*/
int n;
try {
n = num.nextInt();
asterisco(n);
}
}
for (int i = 0; i < n; ++i) {
//Utilizamos dos for para lograr la forma.
for (int j = 0; j < n-i-1; ++j) {
}
for (int j = 0; j < 2*i+1; ++j){
//Condición para imprimir solo los bordes.
if ((i==0)||(i==n-1)||(j==0)||(j==2*i)) {
}
else{
}
}
}
}
}
Java básico 060. Función, imprimir un rombo relleno utilizando asteriscos “*”.
Ejercicio: Diseñe una función que lea un número entero del teclado y escriba un rombo (relleno) con asteriscos (*), según el siguiente ejemplo para un número leído con
valor 5:
*
***
*****
*******
*********
*******
*****
***
*
/**
*
* @author Ariel
*/
public class FuncionDibujSiete {
/**
*/
int n;
try {
n = num.nextInt();
asterisco(n);
}
}
for (int i = 0; i < n; ++i) {
//Utilizamos dos "for" para lograr la forma.
for (int j = 0; j < n-i-1; ++j) {
}
for (int j = 0; j < 2*i+1; ++j){
}
}
//Se utiliza otro grupo de for para lograr la forma de "rombo"
for (int j = n-2; j >= 0; --j) {
for (int i = 0; i < n-j-1; ++i) {
}
for (int i = 0; i < 2*j+1; ++i) {
}
}
}
}
Java básico 061. Función, imprimir un rombo hueco utilizando asteriscos “*”.
Ejercicio: Diseñe una función que lea un número entero del teclado y escriba un rombo (hueco) con asteriscos (*), según el siguiente ejemplo para un número leído con
valor 5:
*
* *
* *
* *
* *
* *
* *
* *
*
/**
*
* @author Ariel
*/
public class FuncionDibujOcho {
/**
*/
int n;
try {
n = num.nextInt();
asterisco(n);
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n-i-1; ++j) {
}
for (int j = 0; j < 2*i+1; ++j){
if ((i==0)||(j==0)||(j==2*i)) {
} else {
}
}
}
//Se utiliza otro grupo de for para lograr la forma de "rombo"
for (int j = n-2; j >= 0; --j) {
for (int i = 0; i < n-j-1; ++i) {
}
for (int i = 0; i < 2*j+1; ++i) {
if ((j==0)||(i==0)||(i==2*j)) {
} else {
}
}
}
}
}
Java básico 062. Función, utilizando StringTokenizer.

Ejercicio: Desarrollar una función aplicando el objeto StringTokenizer.
import java.util.StringTokenizer;
/**
*
* @author Ariel
*/
public class TokenUso {
/**
*/
//Creamos una variable tipo String, la declaramos de forma que,
//cada sección este dividida por un caracter especial.
String cuentas="1@ACTIVO.*1$no#"+
"11@ACTIVO CORRIENTE.*1$no#"+
"111@EFECTIVO Y OTROS MEDIOS LÍQUIDOS.*1$no#"+
"1111@Disponibles.*1$no#"+
"111101@Caja.*1$si#"+
"111102@Fondo Fijo.*1$si#"+
"111103@Caja moneda extranjera.*1$si#"+
"111104@Valores por depositar.*1$si#"+
"1112@Bancos.*1$no#"+
"111201@Banco Regional Cta. Cte.*1$si#"+
"111202@Banco Regional Caja de ahorro.*1$si#"+
"111203@Banco Fomento Cta. Cte.*1$si#"+
"111204@Banco Fomento Caja de ahorro.*1$si#"+
"111205@Banco Continental Cta. Cte.*1$si#"+
"111206@Banco Continental Caja de ahorro.*1$si#"+
"111207@Banco Itapúa Cta. Cte.*1$si#"+
"111208@Banco Itapúa Caja de ahorro.*1$si#"+
"1113@Otros equivalentes al efectivo.*1$no#"+
"111301@Banco Regional plazo fijo.*1$si#"+
"111302@Banco Regional certificado de depósito de ahorro.*1$si#"+
"111303@Banco Fomento plazo fijo.*1$si#"+
"111304@Banco Fomento certificado de depósito de ahorro.*1$si#";
//Llamamos a nuestra función y le pasamos nuestra variable como argumento.
usoToken(cuentas);
}
static void usoToken(String info){

//Creamos un objeto tipo StringTokenizer, como primer argumento le pasamos
//una variable tipo String especialmente creada, el segundo argumento entre comillas
//corresponde a los caracteres que servirán para indicar cada token,
//en este caso utilizamos "@*$#", lo cual indica que tendremos cuatro tokens.
StringTokenizer token = new StringTokenizer(info,"@*$#");
//Utilizamos un "while" para recorrer el String, y extraer los tokens
while (token.hasMoreTokens()) {
//Cada variable String almacena un token.
String cuenta = token.nextToken();
String nombre = token.nextToken();
String grupo = token.nextToken();
String imputable = token.nextToken();
//Podemos imprimir el resultado o almacenar en una lista.
System.out.println(cuenta + " - " + nombre + " - " + grupo + " - " + imputable );
}
//Todo esto es útil para crear plantillas.
}
}
Java básico 063. Función, calcular área de un triángulo utilizando fórmula de Herón
Ejercicio: Calcular área de un triángulo utilizando fórmula de Herón.
public class AreaTriangulo{

public static void main( String[] args ){
/*
Calcular área de un triángulo utilizando fórmula de Herón
Lados a, b y c.
Semiperímetro fórmula: s = ((a+b+c)/2);
El Area: area = raiz(s * ((s-a)*(s-b)*(s-c)))
*/
double a;
a = area(5, 4, 4);
System.out.println("El área de un triangulo con los lados 5,4,4 es: " + a);
a = area(4, 4, 4);
System.out.println("El área de un triangulo con los lados 4,4,4 es: " + a);
a = area(5, 3, 4);
System.out.println("El área de un triangulo con los lados 5,3,4 es: " + a );
a = area(3, 3, 3);
System.out.println("El área de un triangulo con los lados 3,3,3 es: " + a );
}
public static double area( double a, double b, double c ){
double s = ((a+b+c)/2);
double area = (Math.sqrt(s * ((s-a)*(s-b)*(s-c))));
return area;
}
}
Java básico 064. Función, calculando números primos.

Ejercicio: Realizar una función que permita calcular números primos en un rango específico.
Con esta primera clase calculamos si el número ingresado por el usuario es primo o no.
/**
*
* @author ECS
*/
public class NumerosPrimos {
/**
*/
//Scanner para obtener datos de la consola.
Scanner s = new Scanner(System.in);
System.out.print("Ingresa un número para ver si es primo: ");
//Guardamos en una variable el número ingresado
int n = s.nextInt();
//ejecutamos nuestra función
boolean esPrimo = esPrimo(n);
//Si devuelve True no es primo, por tanto ! negamos para ajustar al código
if(!esPrimo){
System.out.println("El número " + n + " es Primo.");
}
else{
System.out.println("El número " + n + " no es Primo.");
}
}
//La función recibe un entero como argumento
static boolean esPrimo(int n){
//inicializamos una variable boolean
boolean b = false;
//Los número negativo no entran como primos
if(n < 0){
b = true;
}
//El 1,2,3,5 son primos conocidos por tanto las obviamos
else if(n != 1 && n != 2 && n != 3 && n != 5){
//Con un for recorremos los números intermedios en 1 y n
//Comprobamos que el módulo con alguno de ellos de 0-cero
for (int i = 2; i < n; i++) {
//Si b es true, demuestra que n no es primo
if(b){
break;
}
b = (n%i == 0);
}
}
//Si n es 1,2,3 o 5 se false, que es primo.
else{
b = false;
}
return b;
}
Con la segunda clase podremos especificar un rango de números, en esta caso listamos los numero primos del 1 al 1000. Abajo anexamos una imagen con los primos del 1
al 1000; sirve para comprobar la funcionalidad del código.
/**
*
* @author ECS
*/
public class NumerosPrimosDos {
/**
*/
//Utilizamos un for para comprobar los números primos del 1 al 1000
int total = 0;
for (int i = 0; i < 1000; i++) {
boolean esPrimo = esPrimo(i);
if(!esPrimo){
total++;
}
}
System.out.println("Hay un total de " + total + " números primos.");
}
//La función recibe un entero como argumento
static boolean esPrimo(int n){
boolean b = false;
//Los números negativos no entran como primos, el 1-uno tampoco
if(n <= 0 || n == 1){
b = true;
}
//El 2,3,5 son primos conocidos por tanto las obviamos
else if(n != 2 && n != 3 && n != 5){
for (int i = 2; i < n; i++) {
//Si b es true, demuestra que n no es primo y salimos del bucle
if(b){
break;
}
b = (n%i == 0);
}
}
//2,3 y 5 son los primeros primos conocidos
else{
b = false;
}
return b;
}
Java Básico con Swing. Modo Diseño con NetBeans.

ava + Swing 001. Modo diseño en NetBeans. Hola Mundo.
Diseño del formulario utilizando JFrame.
Como elementos utilizamos una “Etiqueta”, “Botón” y “Campo de Texto”.
Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho y “Cambiar nombre de variable…”. Se puede usar la que se ajuste al código de más abajo.
Creamos el método siguiente en modo “Fuente”.
public void holaMundo(){

String holaMundo = this.hola.getText();
JOptionPane.showMessageDialog(null, holaMundo);
}
Utilizamos el método “ActionPerformed” para llamar el método anterior desde el botón. Para utilizar un “Evento” hacemos clic derecho sobre el objeto y seleccionamos
“Eventos” de la lista utilizamos la que podamos aplicar al objeto.
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {

this.holaMundo();
}
En la imagen como queda al ejecutar el JFrame.

Java + Swing 002. Modo diseño en NetBeans. Cálculos Básicos.
Como elementos utilizamos “Etiquetas”, “Botón” y “Campos de Texto”. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho y “Cambiar nombre
de variable…”. Se puede usar la que se ajuste al código de más abajo. Los campos de texto para resultados se puede indicar como deshabilitado, desmarcando “enabled”
en “Properties o Propiedades” de modo diseña.
Creamos el método siguiente en modo “Fuente”. Este método utiliza conversiones de tipos de datos y controles de excepciones para controlar lo mejor posible el resultado.
public void calcular(){

int numUno = 0;
int numDos = 0;
int sumaC = 0;
int restaC = 0;
float divC = 0;
int multC = 0;
try {
numUno = Integer.parseInt(this.nUno.getText());
numDos = Integer.parseInt(this.nDos.getText());
JOptionPane.showMessageDialog(null, "Requiere datos numéricos...");
}
sumaC= numUno + numDos;
this.suma.setText(String.valueOf(sumaC));
restaC = numUno - numDos;
this.resta.setText(String.valueOf(restaC));
if(numUno == 0 || numDos ==0){
this.multi.setText("Multiplicación nulo...");
}
else{
multC = numUno * numDos;
this.multi.setText(String.valueOf(multC));
}
if(numUno == 0 || numDos ==0){

this.div.setText("No se puede dividir por cero...");
}
else{
divC = numUno / numDos;
this.div.setText(String.valueOf(divC));
}
Utilizamos el método “ActionPerformed” para llamar el método anterior desde el botón "Calcular". Para utilizar un “Evento” hacemos clic derecho sobre el objeto y
seleccionamos “Eventos” de la lista utilizamos la que podamos aplicar al objeto.

this.calcular();
}

Java + Swing 003. Modo diseño en NetBeans. Uso básico de Métodos, Eventos, Control de
Excepciones, Conversión de tipo de datos, Condicionales y JOptionPane.
como su salario mensual
Como elementos utilizamos “Etiquetas”, “Botón” y “Campos de Texto”.
Los campos de texto para resultados se puede indicar como deshabilitado, desmarcando “enabled” en “Properties o Propiedades” de modo diseña.
Creamos el método siguiente en modo “Fuente”. Este método utiliza conversiones de tipos de datos, controles de excepciones y demás para controlar lo mejor posible el
resultado.
public void calcularSalarioMes(){

String nom = null;
long salBasico = 0;
int horaTrab = 0;
long salMes = 0;
try {
salBasico = Long.parseLong(this.salarioHora.getText());
horaTrab = Integer.parseInt(this.horaTrabajada.getText());
nom = this.nombre.getText();
JOptionPane.showMessageDialog(null, "Se esperan datos numéricos...");
}
if(salBasico == 0 || horaTrab == 0 || nom == null){
JOptionPane.showMessageDialog(null, "No hay datos para mostrar");
}
else{
salMes = salBasico * horaTrab;
String salida = nom + ", El salario mensual es: " + String.valueOf(salMes)+ "$$";
this.salarioMes.setText(String.valueOf(salMes));
JOptionPane.showMessageDialog(null, salida);
}
}
Utilizamos el método “ActionPerformed” para llamar el método anterior desde el botón “Calcular”. Para utilizar un “Evento” hacemos clic derecho sobre el objeto y
private void calcularActionPerformed(java.awt.event.ActionEvent evt) {

this.calcularSalarioMes();
}

Excepciones, Conversión de tipo de datos, Condicionales y Tabla (jTable).
como su salario mensual. Para mostrar los datos utilizaremos una tabla.
Como elementos utilizamos “Etiquetas”, “Botón” y “Campos de Texto”. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho y “Cambiar nombre
de variable…”. Se puede usar la que se ajuste al código de más abajo. Los campos de texto para resultados se puede indicar como deshabilitado, desmarcando “enabled”
en “Properties o Propiedades” de modo diseña.
Observación: Tomar en cuenta que hay que utilizar las importaciones “import”, básico para utilizar ciertos métodos y objetos. El “setLocationRelativeTo(null)” sirve para
centrar el formulario. La declaración “DefaultTableModel model;” nos permite crear una variable de clase para utilizar en cualquier método.
Creamos los métodos siguientes en el apartado “Fuente”. Estos métodos utilizan conversiones de tipos de datos, controles de excepciones y demás para controlar lo mejor
posible el resultado.
public void calcularSalarioMes(){

tableModel();//Se puede llamar aquí o después del método initComponents()
String nom = null;
long salBasico = 0;
int horaTrab = 0;
long salMes = 0;
try {
salBasico = Long.parseLong(this.salarioHora.getText());
JOptionPane.showMessageDialog(null, "Se esperan datos numéricos...");
}
if(salBasico == 0 || horaTrab == 0 || nom == null){
JOptionPane.showMessageDialog(null, "No hay datos para mostrar");
}
else{
salMes = salBasico * horaTrab;
this.salarioMes.setText(String.valueOf(salMes));
//Utilizamos el metodo addRow del DefaultTableModel
model.addRow(new Object[]{
nom,salMes
});
}
}
public void tableModel(){
this.jTable1.getColumnModel().getColumn(0).setPreferredWidth(200);
model = (DefaultTableModel)this.jTable1.getModel();
model.setNumRows(0);
}
public void limpiar(){
this.tableModel();
this.nombre.setText(null);
this.salarioHora.setText(null);
this.salarioMes.setText(null);
this.horaTrabajada.setText(null);
}
Utilizamos el evento “ActionPerformed” para llamar los métodos desde los botones en este caso “Calcular” y “Limpiar”. Para utilizar un “Evento” hacemos clic derecho sobre
el objeto y seleccionamos “Eventos” de la lista utilizamos la que podamos aplicar al objeto.

this.calcularSalarioMes();
}
private void limpiarActionPerformed(java.awt.event.ActionEvent evt) {

this.limpiar();
}

Excepciones, Conversión de tipo de datos, Condicionales y JOptionPane.
Ejercicio: Leer un monto y calcular el 5% del monto leído. Obtener tanto el monto como el porcentaje calculado. El resultado se muestra en un JOptionPane.
Los campos de texto para resultados se puede indicar como deshabilitado, desmarcando “enabled” en “Properties o Propiedades” de modo diseño.
centrar el formulario.
public void calcularPorciento(){

double montoNum = 0;
double finalMonto = 0;
try {
montoNum = Long.parseLong(this.monto.getText());
JOptionPane.showMessageDialog(null, "Se espera dato numérico...");
}
if(montoNum == 0){
JOptionPane.showMessageDialog(null, "No hay dato para mostrar...");
}
else{
finalMonto = ((5*montoNum)/100);
String salida = "El 5% de: " + montoNum + " es " + finalMonto;
JOptionPane.showMessageDialog(null, salida);
}
}
Utilizamos el evento “ActionPerformed” para llamar los métodos desde los botones en este caso “Calcular”. Para utilizar un “Evento” hacemos clic derecho sobre el objeto y

this.calcularPorciento();
}
Excepciones, Conversión de tipo de datos y Tabla (jTable).
Ejercicio: Leer el nombre de un empleado, su salario básico por hora, el número de horas trabajadas en el período y el porcentaje de retención en la fuente. Calcular el
salario bruto, el valor de la retención y su salario neto.

centrar el formulario. La declaración “DefaultTableModel model;” nos permite crear una variable de clase para utilizar en cualquier método. Los método llamados en el
Constructor se ejecutan al arrancar el formulario, como “setLocationRelativeTo(null)” y “tableModel()”.
public void calcularSalario(){

String nom;
long salarioBruto = 0;
long salarioNeto = 0;
long retencionSalario = 0;
long salHora = 0;
int retencionPorcentaje = 0;
int horaTrab = 0;
try {
salHora = Long.parseLong(this.salarioHora.getText());
retencionPorcentaje = Integer.parseInt(this.retencion.getText());
salarioBruto = salHora * horaTrab;
retencionSalario = (salarioBruto * retencionPorcentaje)/100;
salarioNeto = salarioBruto - retencionSalario;
nom,salarioBruto,retencionSalario,salarioNeto
});
JOptionPane.showMessageDialog(null, "ERROR: Verifique datos ingresados...");
}
}
}
tableModel();
this.retencion.setText(null);
}

calcularSalario();//Método para botón Calcular...
}

limpiar();//Método para botón Limpiar...
}
El ejercicio es similar a la presentada en el número “006”, con la diferencia del agregado de condiciones específicas.
Ejercicio: Para un salario bruto hasta de $1.500, no hay retención. Para un salario bruto de $1500 a $ 3.000 el porcentaje de retención es de 5%. Para un salario bruto
mayor de $3000 el porcentaje de retención es 8%. Obtener el nombre del empleado, el salario bruto, el valor de la retención y el salario neto.
Como elementos utilizamos “Etiquetas”, “Botón”, “Tabla” y “Campos de Texto”.
public void calcularSalario(){

String nom;
long salarioBruto = 0;
long salarioNeto = 0;
long retencionSalario = 0;
long salHora = 0;
int retencionPorcentaje = 0;
int horaTrab = 0;
try {
salHora = Long.parseLong(this.salarioHora.getText());
salarioBruto = salHora * horaTrab;
if(salarioBruto < 1500){

retencionSalario = 0;
salarioNeto = salarioBruto;
}
else{
if(salarioBruto >= 1500 && salarioBruto < 3000 ){
retencionPorcentaje = 5;
}
else{
retencionPorcentaje = 8;
}
}
this.retencion.setText(String.valueOf(retencionPorcentaje));
nom,salarioBruto,retencionSalario,salarioNeto
});
JOptionPane.showMessageDialog(null, "ERROR: Verifique datos ingresados...");
}
}
}
tableModel();
this.retencion.setText(null);
}

calcularSalario();//Método para botón Calcular...
}

limpiar();//Método para botón Limpiar...
}
Ejercicio: Obtener nombre, apellido, edad, sexo de varias personas; almacenar en una tabla y procesar los datos y para obtener edad promedio, cantidad de masculinos y
femeninos.
En el diseño vemos con numeración en rojo el objeto y la referencia del nombre de variable que le damos para adaptarse a los método que utilizaremos.
Como elementos utilizamos “Etiquetas”, “Botón”, “combo”, “Tabla” y “Campos de Texto”.
Los campos de texto para resultados se puede indicar como deshabilitado, desmarcando “enabled” en “Properties o Propiedades” de modo diseño. Para añadir valores al
combo o “JComboBox” en propiedades “Model” agregamos cada valor separado por comas, estos valores serán estáticos.

}
tableModel();
this.nom.setText(null);
this.edad.setText(null);
this.sexo.setSelectedIndex(-1);
this.promedioEdad.setText(null);
this.totalF.setText(null);
this.totalM.setText(null);
}
public void agregar(){
if( this.nom.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Indique Nombre y Apellido...");
}
else{
if(this.edad.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Indique la edad...");
}
else{
if(this.sexo.getSelectedIndex() == -1){
JOptionPane.showMessageDialog(null, "Seleccione sexo...");
}
else{
try {
int edadNum = Integer.parseInt(this.edad.getText());
Object selectedItem = this.sexo.getSelectedItem();
String sexoN = selectedItem.toString();
this.nom.getText(),edadNum,sexoN
});
limpiarAgregar();
procesarDatos();
JOptionPane.showMessageDialog(null, "ERROR: Verifique datos ingresados..." + e);
}
}
}
}
}
public void limpiarAgregar(){
this.edad.setText(null);
this.sexo.setSelectedIndex(-1);
}
public void procesarDatos(){
if(this.jTable1.getRowCount()> 0){
int edadPromedio = 0;
int edadSuma = 0;
int numMasculino = 0;
int numFemenino = 0;
for (int i = 0; i < this.jTable1.getRowCount(); i++) {
Object valueAt = model.getValueAt(i, 1);
int edadT = Integer.parseInt(valueAt.toString());
edadSuma += edadT;
Object valueAt1 = model.getValueAt(i, 2);
if (valueAt1.toString().equals("Masculino")) {
numMasculino += 1;
}
else{
numFemenino += 1;
}
}
edadPromedio = edadSuma / this.jTable1.getRowCount();
this.promedioEdad.setText(String.valueOf(edadPromedio));
this.totalF.setText(String.valueOf(numFemenino));
this.totalM.setText(String.valueOf(numMasculino));
}
}
public void obtenerFila(){
selectedRow = this.jTable1.getSelectedRow();
}
public void eliminarFila(){
if(selectedRow >= 0){
model.removeRow(selectedRow);
procesarDatos();
selectedRow = -1;
}
Utilizamos el evento “ActionPerformed” para llamar los métodos desde los botones en este caso “Agregar”, “Eliminar” y “Limpiar”. Para la tabla utilizaremos el evento
“Mouse” específicamente “MouseClicked”, que nos permite obtener el número de fina al hacer clic sobre ella y poder utilizar el botón eliminar. Para utilizar un “Evento”
hacemos clic derecho sobre el objeto y seleccionamos “Eventos” de la lista utilizamos la que podamos aplicar al objeto. En la lista de evento vemos los comentarios
especificando a que objetos se aplican.
private void agregarActionPerformed(java.awt.event.ActionEvent evt) {

agregar();// Evento para botón agregar
}

limpiar();// Evento para botón limpiar
}
private void eliminarActionPerformed(java.awt.event.ActionEvent evt) {

eliminarFila();// Evento para botón eliminar
}
private void jTable1MouseClicked(java.awt.event.MouseEvent evt) {

obtenerFila();// Evento tipo "MouseClicked" para la JTable1
}
Excepciones, Conversión de tipo de datos y jCheckBox.
Ejercicio: Realizar un pequeño programa que permite la conversión de temperatura entre Fahrenheit y Celsius.
En el diseño vemos con numeración en rojo el objeto y la referencia del nombre de variable que le damos para adaptarse a los métodos que utilizaremos.
Como elementos utilizamos “Etiquetas”, “Botón”, “jCheckBox” y “Campos de Texto”.
public void celsiusFahrenheit(){

if (this.jCheckBox1.isSelected()) {
this.jCheckBox2.setEnabled(false);
this.fahrenheit.setEnabled(false);
this.fahrenheit.setText(null);
}
else{
this.jCheckBox2.setEnabled(true);
this.fahrenheit.setEnabled(true);
}
public void fahrenheitCelsius(){

if (this.jCheckBox2.isSelected()) {
this.jCheckBox1.setEnabled(false);
this.celsius.setEnabled(false);
this.celsius.setText(null);
}
else{
this.celsius.setEnabled(true);
}
}
if(this.jCheckBox1.isSelected()){
if (this.celsius.getText().isEmpty()) {
JOptionPane.showMessageDialog(null, "No hay datos...");
}
else{
try {
float celsiusNum = Float.parseFloat(this.celsius.getText());
float fahrenheitNum = ((celsiusNum * 9) / 5) + 32;
this.resultado.setText(String.valueOf(fahrenheitNum + " °F"));
}
}
}
if (this.jCheckBox2.isSelected()){
if (this.fahrenheit.getText().isEmpty()) {
JOptionPane.showMessageDialog(null, "No hay datos...");
}
else{
try {
float fahrenheitNum = Float.parseFloat(this.fahrenheit.getText());
float celsiusNum = ((fahrenheitNum - 32) * 5) / 9;
this.resultado.setText(String.valueOf(celsiusNum + " °C"));
}
}
}
}

this.jCheckBox1.setSelected(false);
this.jCheckBox2.setSelected(false);
this.resultado.setText(null);
this.celsius.setText(null);
this.fahrenheit.setText(null);
this.fahrenheit.setEnabled(true);
this.celsius.setEnabled(true);
}
Utilizamos el evento “ActionPerformed” para llamar los métodos desde los botones en este caso “Calcular” y “Limpiar”. Para los jCheckBox también utilizamos el evento
“ActionPerformed”. Para utilizar un “Evento” hacemos clic derecho sobre el objeto y seleccionamos “Eventos” de la lista utilizamos la que podamos aplicar al objeto. En la
lista de evento vemos los comentarios especificando a que objetos se aplican.
private void jCheckBox1ActionPerformed(java.awt.event.ActionEvent evt) {

celsiusFahrenheit();//Evento ActionPerformed para jCheckBox1
}
private void jCheckBox2ActionPerformed(java.awt.event.ActionEvent evt) {

fahrenheitCelsius();//Evento ActionPerformed para jCheckBox2
}

calcular();//Evento ActionPerformed para botón calcular
}

limpiar();//Evento ActionPerformed para botón limpiar
}
Excepciones, Conversión de tipo de datos y Tablas.
Ejercicio: Se tiene un conjunto de registros de los empleados de una compañía, cada registro contiene los siguientes datos: número del empleado, nombre del empleado,
salario básico por hora, horas trabajadas en el mes, deducciones, Se requiere leer los registros e imprimir un listado con la siguiente información por empleado: número del
empleado, nombre del empleado, salario básico por hora, horas trabajadas, deducciones, salario mensual. También se debe calcular e imprimir al final del listado, el total de
salarios pagados a todos los empleados y el promedio salarial por empleado.

}
tableModel();
this.num.setText(null);
this.horaMes.setText(null);
this.totalSalarioMes.setText(null);
this.totalSalarioPagados.setText(null);
this.promedioSalarios.setText(null);
this.deduccion.setText(null);
}
public void limpiarNuevo(){
this.horaMes.setText(null);
this.totalSalarioMes.setText(null);
this.deduccion.setText(null);
}
public void nuevo(){
int rowCount = this.jTable1.getRowCount();
this.num.setText(String.valueOf(rowCount + 1));
}
if(this.num.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Seleccione botón nuevo.");
}
else{
if(this.nombre.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Indique un nombre.");
}
else{
if(this.salarioHora.getText().isEmpty() && this.horaMes.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Complete datos faltantes.");
}
else{
try {
long salarioHoraT = Long.parseLong(this.salarioHora.getText());
long horaMesT = Long.parseLong(this.horaMes.getText());
long deduccionT;
if(this.deduccion.getText().isEmpty()){
deduccionT = 0;
}
else{
deduccionT = Long.parseLong(this.deduccion.getText());
}
long totalSalarioMesT = (salarioHoraT * horaMesT) - deduccionT;
this.num.getText(),this.nombre.getText(),salarioHoraT,horaMesT,deduccionT,totalSalarioMesT
});
procesarTabla();
limpiarNuevo();
JOptionPane.showMessageDialog(null, "Error: datos incorrectos.");
}
}
}
}
}
public void procesarTabla(){
long totalSalarioP = 0, promedioSalario = 0;
long parseLong = Long.parseLong(valueAt.toString());
totalSalarioP += parseLong;
}
promedioSalario = totalSalarioP / this.jTable1.getRowCount();
this.totalSalarioPagados.setText(String.valueOf(totalSalarioP));
this.promedioSalarios.setText(String.valueOf(promedioSalario));
}
public void obtenerSeleccion(){
try {
selected = this.jTable1.getSelectedRow();
}
}
public void eliminar(){
try {
model.removeRow(selected);
selected = -1;
procesarTabla();
JOptionPane.showMessageDialog(null, "Error: seleccione una fila.");
}
}
Utilizamos el evento “ActionPerformed” para llamar los métodos desde los botones en este caso “Nuevo”, “Eliminar”, “Agregar” y “Limpiar”. Para el jTable utilizamos el evento
“MouseClicked”. Para utilizar un “Evento” hacemos clic derecho sobre el objeto y seleccionamos “Eventos” de la lista utilizamos la que podamos aplicar al objeto. En la lista
de evento vemos los comentarios especificando a que objetos se aplican.
private void nuevoActionPerformed(java.awt.event.ActionEvent evt) {

nuevo();//Evento ActionPerformed para botón Nuevo
}
agregar();//Evento ActionPerformed para botón Agregar
}

limpiar();//Evento ActionPerformed para botón Limpiar
}

eliminar();//Evento ActionPerformed para botón Eliminar
}

obtenerSeleccion();//Evento MouseClicked para el JTable.
//Este método permite obtener la fila seleccionada.
}
Excepciones, Conversión de tipo de datos, Thread y Random.
Ejercicio: Crear una aplicación que genere números aleatorios utilizado Random y Thread.

posible el resultado. También se crea un objeto “Thread” y se implementa sus métodos.
public void iniciar(){

cont = true;
Thread t = new Thread( new Runnable() {
@Override
public void run() {
Random ran = new Random();
while(cont){
int nextInt = (int)(ran.nextDouble()*100);
text.setText(String.valueOf(nextInt));
try {
Thread.sleep(100);
} catch (InterruptedException ex) {
Logger.getLogger(PanelRand.class.getName()).log(Level.SEVERE, null, ex);
}
if(cont==false){
break;
}
}
}
});
t.start();
public void control(){

cont = false;
}
Utilizamos el evento “ActionPerformed” para llamar los métodos desde los botones en este caso “Iniciar”, “Parar”. Para utilizar un “Evento” hacemos clic derecho sobre el
objeto y seleccionamos “Eventos” de la lista utilizamos la que podamos aplicar al objeto. En la lista de evento vemos los comentarios especificando a que objetos se aplican.
private void iniciarActionPerformed(java.awt.event.ActionEvent evt) {

iniciar();//Evento ActionPerformed botón iniciar.
}
private void pararActionPerformed(java.awt.event.ActionEvent evt) {

control();//Evento ActionPerformed botón parar.
}

Java + Swing 012. Modo diseño en NetBeans. Juego de números aleatorios utilizando Thread y
Random.
Ejercicio: Realizar un juego para adivinar un número. Para ello generar un número de forma aleatoria utilizando Thread y Random. El proceso termina cuando el usuario
acierta o cancela el juego.
En el diseño vemos la descripción en rojo del nombre de variables que le asignamos a cada objeto, es importante para entender mejor el funcionamiento de los métodos.
centrar el formulario. Los métodos llamados en el constructor de la clase se inician al ejecutar el formulario.
posible el resultado. También se crea un objeto “Thread” y se implementa sus métodos.

this.num.setEnabled(false);
this.result.setText(null);
this.nuevo.setEnabled(true);
this.nuevo.setText("Nuevo");
this.jugar.setEnabled(false);
this.comprobar.setEnabled(false);
contador=0;
}
if(this.nuevo.getText().equals("Nuevo")){
this.nuevo.setText("Cancelar");
this.jugar.setEnabled(true);
salir = true;
Thread t = new Thread(new Runnable() {
@Override
public void run() {
while (salir) {
int nextInt = (int)(ran.nextDouble()*100);
result.setText(String.valueOf(nextInt));
numAleatorio = nextInt;
try {
//Se puede ampliar o reducir el tiempo de espera.
Thread.sleep(100);
} catch (InterruptedException ex) {
Logger.getLogger(JuegoNum.class.getName()).log(Level.SEVERE, null, ex);
}
if(salir==false){
break;
}
}
}
});
t.start();
}
else{
iniciar();
}
}
public void jugar(){
this.num.setEnabled(true);
salir = false;
this.jugar.setEnabled(false);
this.comprobar.setEnabled(true);
this.result.setText("**");
}
public void comprobar(){
int numUser;
try {
numUser = Integer.parseInt(this.num.getText());
contador++;
if(numUser==numAleatorio){
JOptionPane.showMessageDialog(null, "Perfecto: Acertaste después de " + contador + " intentos. "+"(" +
numUser+"="+numAleatorio+")");
iniciar();
}
else{
JOptionPane.showMessageDialog(null, "Fallaste: Intenta de nuevo. " + "Van : " + contador + " intentos.");
}
JOptionPane.showMessageDialog(null, "Requiere dato numérico.");
}
}
Utilizamos el evento “ActionPerformed” para llamar los métodos desde los botones. Para utilizar un “Evento” hacemos clic derecho sobre el objeto y seleccionamos “Eventos”
de la lista utilizamos la que podamos aplicar al objeto. En la lista de evento vemos los comentarios especificando a que objetos se aplican.

nuevo();//Evento ActionPerformed para botón Nuevo.
}
private void jugarActionPerformed(java.awt.event.ActionEvent evt) {

jugar();//Evento ActionPerformed para botón Jugar.
}
private void comprobarActionPerformed(java.awt.event.ActionEvent evt) {

comprobar();//Evento ActionPerformed para botón Comprobar.
}
En la imagen el formulario en ejecución.
Java + Swing 013. Modo diseño en NetBeans. Trabajando con tabla.

Ejercicio: Realizar una pequeña aplicación que nos permite agregar, recuperar, modifica y eliminar datos de una tabla.
centrar el formulario. Los métodos llamados en el constructor de la clase se inician al ejecutar el formulario.
posible el resultado. Se insertan algunos comentarios para tratar de explicar el funcionamiento de cada método.

//Método que se carga al inicio del formulario,
//Esto lo hacemos llamandolo desde el contructor.
//Principalmente consiste en Limpiar campos y Deshabilitarlas.
this.id.setText(null);
this.id.setEnabled(false);
this.nom.setEnabled(false);
this.dir.setText(null);
this.dir.setEnabled(false);
this.correo.setText(null);
this.correo.setEnabled(false);
this.agregar.setEnabled(false);
this.actualizar.setEnabled(false);
this.editar.setEnabled(false);
this.eliminar.setEnabled(false);
this.jTable1.setEnabled(true);
fila = 0;
}
//Método que se carga al inicio del formulario,
//Esto lo hacemos llamandolo desde el contructor.
/*Utilizamos el siguiente procedimiento para indicar el tamaño
* del cada columna, el índice inicia de 0.
*/
//Indicamos que la variable model se aplica al jTable1.
//Indicamos la cantidad de filas que tendrá la tabla al inicio.
}
public void cancelar(){
//Método que se ejecuta al precionar el botón "Cancelar".
iniciar();
}
//Método que se ejecuta al precionar el botón "Nuevo".
iniciar();
//Utilizamos este procedimiento para generar el id.
this.id.setText(String.valueOf(this.jTable1.getRowCount() + 1));
//Activamos campos y bóton.
this.nom.setEnabled(true);
this.dir.setEnabled(true);
this.correo.setEnabled(true);
this.agregar.setEnabled(true);
}
//Comprobamos que los campos no esten vacios.
if(nom.getText().isEmpty() || dir.getText().isEmpty() || correo.getText().isEmpty() ){
JOptionPane.showMessageDialog(null, "Rellena todos los campos.");
}
else{
//Agregamos datos a la tabla utilizando Object.
//Cada getText() entre comas significa una columna.
id.getText(),nom.getText(),dir.getText(),correo.getText()
});
iniciar();
}
}
public void seleccionarFila(){
//Utilizamos este método para obtener que fila se ha seleccionado.
//Habilitamos botones y campos.
//Rellenamos campos.
if(jTable1.getRowCount() > 0 || agregar.isEnabled()== false){
//Utilizamos getValueAt del model para obtener datos de la tabla.
fila = jTable1.getSelectedRow();
id.setText(String.valueOf(model.getValueAt(fila, 0)));
nom.setText(String.valueOf(model.getValueAt(fila, 1)));
dir.setText(String.valueOf(model.getValueAt(fila, 2)));
correo.setText(String.valueOf(model.getValueAt(fila, 3)));
nuevo.setEnabled(false);
editar.setEnabled(true);
eliminar.setEnabled(true);
}
}
public void editar(){
//Al precionar el botón editar se activan algunos campos
// y otros se desactivan. Lo mismo con los botones.
jTable1.setEnabled(false);
eliminar.setEnabled(false);
actualizar.setEnabled(true);
nom.setEnabled(true);
dir.setEnabled(true);
correo.setEnabled(true);
}
public void actualizar(){
if(nom.getText().isEmpty() || dir.getText().isEmpty() || correo.getText().isEmpty() ){
JOptionPane.showMessageDialog(null, "Rellena todos los campos.");
}
else{
//Utilizamos setValueAt para modificar datos en tabla.
//Por orden se indica "Datos a cargar", fila y columna.
model.setValueAt(nom.getText(), fila, 1);
model.setValueAt(dir.getText(), fila, 2);
model.setValueAt(correo.getText(), fila, 3);
iniciar();
}
}
//Utilizamos showConfirmDialog para el botón eliminar.
int showConfirmDialog = JOptionPane.showConfirmDialog(null, "Desea eliminar esta fila.", "Mensaje del Sistema.",
JOptionPane.YES_NO_OPTION);
if (showConfirmDialog == 0) {
model.removeRow(fila);
reiniciar();
iniciar();
}
}
public void reiniciar(){
//Reordenamos el id para evitar que se dupliquen.
for (int i = 0; i < jTable1.getRowCount(); i++) {
model.setValueAt(i+1, i, 0);
}
}
de la lista utilizamos la que podamos aplicar al objeto. Para la tabla utilizamos el evento “MouseClicked”.
private void cancelarActionPerformed(java.awt.event.ActionEvent evt) {

cancelar();
}

nuevo();
}

agregar();
}

seleccionarFila();
}
private void editarActionPerformed(java.awt.event.ActionEvent evt) {

editar();
}
private void actualizarActionPerformed(java.awt.event.ActionEvent evt) {
actualizar();
}

eliminar();
}
En la imagen, el formulario en ejecución.
Java + Swing 014. Modo diseño en NetBeans. Rellenar tabla utilizando ArrayList.
Ejercicio: Realizar una pequeña aplicación que nos permite rellenar una tabla con datos almacenados en una lista.
Creando clase “Persona”.
La clase “Persona” nos servirá de base para crear la lista y poder acceder a sus datos de forma sencilla. La clase cuenta con variables de clase privadas, un método
constructor y los Setters & Getters para tener acceso a los datos. A esta aplicación solo servirán los Getters para obtener los datos.
/**
*
* @author Ariel
*/
public class Persona {
//Creamos variables de clase.
private int id;
private String nombreApellido;
private String dir;
private String telef;
//Creamos el constructor de la clase
public Persona(int id, String nombreApellido, String dir, String telef) {
this.id = id;
this.nombreApellido = nombreApellido;
this.dir = dir;
this.telef = telef;
}
//Creamos los Setters & Getters. Llamados métodos accesores.
public String getDir() {
return dir;
}
public void setDir(String dir) {

this.dir = dir;
}
public int getId() {

return id;
}
public void setId(int id) {

this.id = id;
}
public String getNombreApellido() {

return nombreApellido;
}
public void setNombreApellido(String nombreApellido) {

this.nombreApellido = nombreApellido;
}
public String getTelef() {

return telef;
}
public void setTelef(String telef) {

this.telef = telef;
}
Lo siguiente es crear un formulario utilizando un JFrame.
Como elementos utilizamos “Botón”, y “Tabla”.
Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho y “Cambiar nombre de variable…”. Se puede usar la que se ajuste a los métodos creados.
centrar el formulario. Los métodos llamados en el constructor de la clase se inician al ejecutar el formulario. Si la Clase “Persona” en este caso está en el mismo paquete que
la aplicación, no es necesaria realizar la importación.

}
public void cargarPersona(){
//Utilizamos la variable lista como ArrayList().
lista = new ArrayList();
lista.clear();
//Cargamos 10 elementos a la lista utilizando el método siguiente.
//La lista puede contener datos obtenidos desde una base de datos.
for (int i = 0; i < 10; i++) {
lista.add(new Persona((i+1), "Persona " +(i+1), "Dirección " +(i+1), "Teléfono " +(i+1)));
}
}
public void cargarTabla(){
//Limpiamos la tabla para no duplicar datos...
//Llamamos el método ccargarPersona().
cargarPersona();
//Utilizamos "Iterator" para navegar por la lista.
for (Iterator it = lista.iterator(); it.hasNext();) {
//Hacemos una conversión de la lista en clase Persona
//Esto nos permite obtener los datos con el get.
Persona p = (Persona) it.next();
p.getId(),p.getNombreApellido(),p.getDir(),p.getTelef()
});
}
}
public void limpiarTabla(){
}
de la lista utilizamos la que podamos aplicar al objeto.
private void cargarActionPerformed(java.awt.event.ActionEvent evt) {

cargarTabla();
}

limpiarTabla();
}
En la imagen, el formulario en ejecución.
Enlace para descarga del Formulario: http://goo.gl/GgZvVY

Son dos archivos más la clase persona, copiar los tres dentro de la carpeta de tu proyecto, tomar en cuenta que hay que cambia la línea de código siguiente: (package
com.java.swing;) que indica el paquete de origen por el paquete en el que se ubicarán estos archivos.
Java + Swing 015. Modo diseño en NetBeans. Fecha y Hora con objeto Calendar.
Ejercicio: Desarrollar un formulario con jFrame que permite el manejo de fecha y horas.
Para diseñar el formulario utilizamos un jFrame. Como se ve en la imagen siguiente, es la forma como debe quedar el formulario después de agregar todos los objetos
correspondientes. Se indica con marcadores en “rojo” la referencia del objeto con nombre de variable y tipo de objeto. Esto es importante para que coincidan con los
métodos que crearemos.
Los objetos que utilizamos en el diseño son: JFormattedTextField, JTextField, JTextArea, JLabel, JButton y el JScrollPane que se agrega de forma automática en caso
necesario.
Observación: el indicador (dd/MM/yyyy) significa fecha en formato día/mes/año.
En la imagen siguiente vemos la forma de configurar el “JFormattedTextField”, que es el objeto que se utiliza para controlar la entrada de datos en un formato específico, en
este caso “fecha”.
La serie de pasos es la siguiente: (1) seleccionar objeto. (2) acceder a Propiedades o “Properties”. (3) seleccionamos “AbstractFormatterFactory”. (4) indicamos “mascara”.
(5) tipo “personal”. (6) marcamos el formato que deberá respetarse. (##/##/####) -- (09/07/2013). (7) Aceptamos los cambios. Esto se aplica solo al objeto
“JFormattedTextField”.
private String fechaString(Calendar fecha){

//A este método le pasamos un objeto Calendar y la convierte en un String de fecha.
String retorno = null;
//Utilizamos SimpleDateFormat para establecer el formato de la fecha.
//Si fecha está vacío retornará null.
if(fecha != null){
//Este proceso permite convertir el Objeto Calendar en un formato de fecha útil.
}
return retorno;
}
private String horaString(Calendar fecha){
//A este método le pasamos un objeto Calendar y la convierte en un String de hora.
String retorno = null;
//Utilizamos SimpleDateFormat para establecer el formato de la hora.
if(fecha != null){
//Este proceso permite convertir el Objeto Calendar en un formato de hora útil.
}
return retorno;
}
private Calendar fechaCalendar(String fecha){
//A este método le pasamo como parámetro un String con formato fecha específico
//y la convierte en objeto Calendar.
//Obtenemos una instancia del objeto Calendar.
//Utilizamos un try para controlar entrada de datos erroneos.
try {
//Hacemos la conversión con este procedimiento.
JOptionPane.showMessageDialog(null, "Error de formato de fecha: " + e);
}
return cal;
}
private void obtenerFechaUser(){
//Utilizamos este método para obtener la fecha que haya introducido el usuario.
//En este caso desde el JTextField "fechaUser".
String fecha = fechaUser.getText();
//Comprobamos que no este vacío.
if(fecha != null){
//Llamamos a nuestros métodos de más arriba.
Calendar fechaCalendar = fechaCalendar(fecha);
fechaTestD.setText(fechaCalendar.toString());
String fechaString = fechaString(fechaCalendar);
fechaTest.setText(fechaString);
}
}
private void obtenerFechaSistema(){
//Este método permite obtener una instancia del Objeto Calendar, procesarla
//y obtner la fecha y la hora actual.
String fechaString = fechaString(cal);
fechaObtenido.setText(fechaString);
String horaString = horaString(cal);
horaObtenido.setText(horaString);
}
Lo siguiente será agregar los eventos que harán funcionar a nuestro programa. Utilizamos el evento “ActionPerformed” para llamar los métodos desde los botones. Para
utilizar un “Evento” hacemos clic derecho sobre el objeto y seleccionamos “Eventos” de la lista utilizamos la que podamos aplicar al objeto. En la imagen vemos como se
indica (1)” setLocationRelativeTo(null);” que nos permitirá centrar el formulario llamándola desde el constructor del jFrame. (2) nos indica el evento que se llama desde el
botón “probar”. (3) llamamos al método “obtenerFechaUser();” que habíamos creado. Este método se ejecutará al hacer clic sobre el botón “probar”.
La última imagen nos muestra el jFrame en ejecución. Obs.: En el “JTextArea” imprimimos el Objeto calendar sin procesar, por tanto trae todo lo que incluye el objeto.
Java + Swing 016. Modo diseño en NetBeans. Trabajando con JComboBox y jTable.
Ejercicio: Realizar una pequeña aplicación que nos muestre la forma de agregar ítems a un JComboBox y jTable.
Diseño de formulario con JFrame.
En la imagen podemos ver el diseño y a un costado los nombres de variables de cada objeto, es importante para que se ajuste a los métodos que se crean. Se puede
cambiar el “Nombre de variable” de cada objeto haciendo clic derecho y “Cambiar nombre de variable…”. Es fácil distinguir cual corresponde a cada objeto, va de izquierda a
derecha e el diseño.
Diseño del formulario utilizando JFrame. Como elementos utilizamos “JComboBox”, “Botón”, y “Tabla”.
centrar el formulario. Los métodos llamados en el constructor de la clase se inician al ejecutar el formulario. Las variables de clase se pueden llamar desde cualquier método,
por tanto se utiliza para objetos que se necesitan utilizar en varias ubicaciones.
posible el resultado. Se agregan comentarios para tratar de facilitar el entendimiento del funcionamiento de cada código.
private void comboUno(){

//Este método nos permite cargar el comboUno.
//Utilizamos el DefaultComboBoxModel para cargar los datos, es una de las
//tantas formas.
jComboBox1.setModel(new DefaultComboBoxModel(new Object[]{
"Monitores","Impresoras","Teclados","CPU","Memoria RAM"
}));
}
private void tableModel(){
//Este metodo configura el DefaultTableModel, nos permite dar forma a la tabla.
jTable1.getColumnModel().getColumn(0).setPreferredWidth(10);
model = (DefaultTableModel)jTable1.getModel();
}
private void agregarTabla(){
//Con este método agregamos datos a la tabla.
if(nombre.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "No hay datos.");
}
else{
//El id de cada fila lo generamos. Es Opcional.
int id = jTable1.getRowCount() + 1;
//Utilizamos el model de la tabla que configuramos en tableModel().
id,nombre.getText()
});
nombre.setText(null);
}
}
private void arrayTabla(){
//Los datos de la tabla lo pasamos a un Array con este método.
int rowCount = jTable1.getRowCount();
if( rowCount != 0){
//Utilizamos jTable1.getRowCount() para obtener la cantidad de filas
//que será la cantidad de elementos del Array.
String[] nombres = new String[jTable1.getRowCount()];
//Cargamos el Array con los datos de la tabla.
for (int i = 0; i < nombres.length; i++) {
//Utilizamos el getValueAt del model para obtener los datos de la tabla.
//El primer parámetro es la fila, el segundo la columna.
//Las columnas se cuentan desde cero.
nombres[i]= model.getValueAt(i, 1).toString();
}
//Cada vez que ejecutemos el método también limpiamos el ComboBox con removeAllItems().
//De esta forma no se duplican los datos con cada ejecusión.
jComboBox2.removeAllItems();
//Con un for recorremos el Array de String.
for (int i = 0; i < nombres.length; i++) {
String string = nombres[i];
//Utilizamos addItem, para agregar cada ítem del combo.
jComboBox2.addItem(string);
}
}
}
private void eliminarTable(){
//Metodo para remover datos de la tabla.
try {
int selectedRow = jTable1.getSelectedRow();
if(jTable1.getRowCount() > 0){
model.removeRow(selectedRow);
}
JOptionPane.showMessageDialog(null, "No seleccionado para eliminar.");
}
}
private void arrayLista(){
//Metodo similar a la anterior, utilizando Array literal.
String[] dias = {"Lunes","Martes","Miércoles","Jueves","Viernes","Sábado","Domingo"};
jComboBox3.removeAllItems();
for (int i = 0; i < dias.length; i++) {
String string = dias[i];
}
}
de la lista utilizamos la que podamos aplicar al objeto. En la mayoría de los casos se utiliza el “ActionPerformed”. Se agregan comentarios para tratar de facilitar el
entendimiento.
private void cargarUnoActionPerformed(java.awt.event.ActionEvent evt) {

//Evento botón cargarUno.
comboUno();
}
private void agregarTablaActionPerformed(java.awt.event.ActionEvent evt) {

//Evento botón agregarTabla.
agregarTabla();
}
private void cargarDosActionPerformed(java.awt.event.ActionEvent evt) {

//Evento botón cargarDos.
arrayTabla();
}
private void cargarTresActionPerformed(java.awt.event.ActionEvent evt) {

//Evento botón cargarTres.
arrayLista();
}
private void jComboBox1ActionPerformed(java.awt.event.ActionEvent evt) {

//Evento jComboBox1 para obtener datos seleccionados y pasar a un JTextField.
//El try para capturar posibles excepciones.
try {
comboUno.setText(jComboBox1.getSelectedItem().toString());
}
}

try {
comboDos.setText(jComboBox2.getSelectedItem().toString());
}

try {
comboTres.setText(jComboBox3.getSelectedItem().toString());
}
private void eliminarFilaActionPerformed(java.awt.event.ActionEvent evt) {

//Evento botón eliminarFila.
eliminarTable();
}
Por último tenemos el formulario en ejecución.

Java + Swing 017. Modo diseño en NetBeans. Juego; números aleatorios. Utilizando Thread y
Random.
Ejercicio: Realizar una pequeña aplicación que pueda generar siete números aleatorio y mostrarla. Los números no podrán repetirse.
En la imagen podemos ver el diseño y a un costado los nombres de variables de cada objeto, es importante para que se ajuste a los métodos que se crean. Se puede
cambiar el “Nombre de variable” de cada objeto haciendo clic derecho y “Cambiar nombre de variable…”. Es fácil distinguir cual corresponde a cada objeto, va de izquierda a
derecha e el diseño. Todos los campos de texto están deshabilitados, esto se hace cambiando la propiedad “enabled”.
private void limpiar(){

//Método para limpiar campos y activar objetos.
//Se carga en el contructor del JFrame y el boton reiniciar.
contador.setText(null);
numUno.setText(null);
numDos.setText(null);
numTres.setText(null);
numCuatro.setText(null);
numCinco.setText(null);
numSeis.setText(null);
numSiete.setText(null);
num.setText(null);
jugar.setEnabled(true);
iniciar.setEnabled(true);
jLabelFinal.setVisible(false);
}
private void iniciar(){
//Variable de clase tipo boolean, para controlar la ejecusión del Thread.
control = true;
//Forma de declarar un Thread.
//El modificador final para mejor control.
final Thread t = new Thread( new Runnable() {
@Override
//Implementamos el método que trae.
public void run() {
//Para generar los números aleatorios utilizamos Random.
//while para mostrar los números generados.
while (control) {
//Los número generados van del 1 al 20.
//Indicamos 20 + 1 pués los números generados van desde el cero.
int next = (int)(ran.nextDouble() * 20 + 1);
//Los números generados se muestran en "num" un JTextField
num.setText(String.valueOf(next));
try {
Thread.sleep(100);
}
//Al cambiar el valor de la variable control se sale del bucle y el Thread.
if (control==false) {
break;
}
}
}
});
//Método que iniciar la ejecusión del Thread.
t.start();
}
private void jugar(){

//Método que se ejcutan con el botón jugar.
control = false;
//La lista de if anidados es para controlar los números repetidos.
try {
if(!"".equals(num.getText())){
if(numUno.getText().isEmpty()){
numUno.setText(num.getText());
contador.setText("1");
}
else{
if(num.getText().equals(numUno.getText())){
iniciar();
jugar();
}
else{
if(numDos.getText().isEmpty()){
numDos.setText(num.getText());
}
else{
if(num.getText().equals(numDos.getText())){
iniciar();
jugar();
}
else{
if(numTres.getText().isEmpty()){
numTres.setText(num.getText());
}
else{
if(num.getText().equals(numTres.getText())){
iniciar();
jugar();
}
else{
if(numCuatro.getText().isEmpty()){
numCuatro.setText(num.getText());
}
else{
if(num.getText().equals(numCuatro.getText())){
iniciar();
jugar();
}
else{
if(numCinco.getText().isEmpty()){
numCinco.setText(num.getText());
}
else{
if(num.getText().equals(numCinco.getText())){
iniciar();
jugar();
}
else{
if(numSeis.getText().isEmpty()){
numSeis.setText(num.getText());
}
else{
if(num.getText().equals(numSeis.getText())){
iniciar();
jugar();
}
else{
if(numSiete.getText().isEmpty()){
numSiete.setText(num.getText());
iniciar.setEnabled(false);
jugar.setEnabled(false);
control = false;
num.setText(null);
jLabelFinal.setVisible(true);
jLabelFinal.setForeground(Color.red);
}
}
}
}
}
}
}
}
}
}
}
}
}
}
else{
iniciar();
jugar();
}
System.out.println("Metodo jugar " + e);
}
entendimiento.

//Método para crear el Thread y llamar sus métodos.
iniciar();
}
private void reiniciarActionPerformed(java.awt.event.ActionEvent evt) {
//Método para limpiar campos y activar objetos.
limpiar();
}
private void jugarActionPerformed(java.awt.event.ActionEvent evt) {

//Método para obtener el número generado y mostrar.
jugar();
}
Observación: Los métodos y el diseño son meramente para práctica y ejemplo, no tienen aplicación funcional y pueden contener errores.
Java + Swing 018. Modo diseño en NetBeans. Agregar JComboBox y JCheckBox a un jTable.
Ejercicio: Realizar una pequeña aplicación que permita agregar JComboBox y JCheckBox a una tabla, dentro de una columna específica. La aplicación debe permitir
eliminar, mover y editar cada fila de la tabla.
En la imagen podemos ver el diseño y los nombres de variables de cada objeto, es importante para que se ajuste a los métodos que se crean. Se puede cambiar el “Nombre
de variable” de cada objeto haciendo clic derecho y “Cambiar nombre de variable…”. Es fácil distinguir cual corresponde a cada objeto, los nombre de variables son iguales a
la etiqueta asignada al objeto.

//Metodo para configurar el DefaultTableModel.
//Se llama desde el constructor del JFrame para que la tabla arranque con el
//formato deseado.
//Indicamos el tamaño de las columnas.
//Asigamos a la variable model el objeto jTable1.
//Esto permite utilizar la variable model para trabajar con la tabla.
model = (DefaultTableModel)jTable1.getModel();
//Indicamos que al principio tendrá cero filas.
}
private void arranque(){
//Desactivamos estos botones al arranque.
subir.setEnabled(false);
bajar.setEnabled(false);
}
//Permite poner a cero las filas del jTable1
arranque();
}
private void agregar(){
//Método par agregar filas al jTable1.
//Cada fila tendrá también un JComboBox y un JCheckBox.
//Declaramos un nuevo objeto JComboBox.
JComboBox combo = new JComboBox();
//Le asiganamos dos valores.
combo.setModel(new DefaultComboBoxModel(new Object[]{
"Masculino","Femenino"
}));
//Indicamos que vaya seleccionado por defecto el primer valor, para esto
//utilizando el setSelectedIndex y como parémetro el índice del valor.
//El índice empieza de cero, por tanto le corresponde al primer valor.
combo.setSelectedIndex(0);
//Obtenemos el valor seleccionado como String.
String toString = combo.getSelectedItem().toString();
//Creamos un objeto JCheckBox.
JCheckBox check = new JCheckBox();
//Forma en la que daremos valor a la columna id.
int id = jTable1.getRowCount() + 1;
//Utilizamos el model para agregar la fila, el valor de la columna que corresponde
//al JCheckBox debe ser de tipo boolean, el del JComboBox tipo String.
id,"","",toString,"", false});
//Utilizamos el CellEditor para agregar el JComboBox y el JCheckBox.
//Para el JCheckBox también utilizamos el CellRenderer que nos permitirar tener dibujado el objeto.
jTable1.getColumnModel().getColumn(3).setCellEditor(new DefaultCellEditor(combo));
jTable1.getColumnModel().getColumn(5).setCellEditor(new DefaultCellEditor(check));
//Como parámetro para el CellRenderer le pasamos una clase que se crea más adelante.
//Es una clase predefinida con métodos predefinidos.
jTable1.getColumnModel().getColumn(5).setCellRenderer(new Render_CheckBox());
jTable1.repaint();
}
public void seleccion(){
//Método para activar y desactivar los botones "subir" y "bajar" según corresponda.
int selectedRow = jTable1.getSelectedRow() + 1;
int inferior = 1;
int superior = 1;
superior = i + 1;
}
if(inferior == jTable1.getRowCount()){
}
else{
if(selectedRow == inferior){
subir.setEnabled(true);
}
else{
if(selectedRow == superior){
bajar.setEnabled(true);
}
else{
subir.setEnabled(true);
bajar.setEnabled(true);
}
}
}
}
}
private void removerSelec(){
//Este método nos permitiré eliminar una o varias filas que tengan el JCheckBox
//en true o seleccionado.
try {
//Forma de obtener el valor boolean de la columna indicada.
boolean res = Boolean.valueOf(model.getValueAt(i, 5).toString());
while (res) {
model.removeRow(i);
res = false;
orden();
}
}
}
//El try es para controlar posibles errores, en caso de darse alguno el programa no
//realiza ninguna acción.
}
public void moverArriba(){
//Método asignado al botón subir.
//Nos permitira mover una fila arriba utilizando moveRow
//El primer parámetro indica desde, el segundo hasta y tercero donde.
try {
int selc = jTable1.getSelectedRow();
int mov = jTable1.getSelectedRow() + 1;
model.moveRow(selc, selc, mov);
//Abajo como se explica en la documentación.
//public void moveRow(int start, int end, int to)
//start - the starting row index to be moved
//end - the ending row index to be moved
//to - the destination of the rows to be moved
//El método orden nos permitirá reescribir el orden del id.
orden();
seleccion();
jTable1.repaint();
jTable1.repaint();
}
}
public void moverAbajo(){
//Método asignado al botón bajar.
//Similar el funcionamiento al método moverArriba().
try {
int selc = jTable1.getSelectedRow();
int mov = jTable1.getSelectedRow() - 1;
model.moveRow(selc, selc, mov);
orden();
seleccion();
jTable1.repaint();
jTable1.repaint();
}
}
public void orden(){
//Método para reescribir el orden del id.
model.setValueAt(i + 1, i, 0);
}
}
//Clase predefinida que hereda de un JCheckBox e implementa el TableCellRenderer.
//La clase está predefinida. Copia del blog de jc-mouse.
class Render_CheckBox extends JCheckBox implements TableCellRenderer {
//
private JComponent component = new JCheckBox();
/** Constructor de clase */

public Render_CheckBox() {
setOpaque(true);
}
@Override
public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row,
int column) {
//Color de fondo de la celda
( (JCheckBox) component).setBackground( new Color(98,138,183) );
//obtiene valor boolean y coloca valor en el JCheckBox
boolean b = ((Boolean) value).booleanValue();
( (JCheckBox) component).setSelected( b );
return ( (JCheckBox) component);
}
}
Utilizamos el evento “ActionPerformed” para llamar los métodos desde los botones. Se utiliza el evento “MouseClicked” para el jTable. Para utilizar un “Evento” hacemos clic
derecho sobre el objeto y seleccionamos “Eventos” de la lista utilizamos la que podamos aplicar al objeto. En la mayoría de los casos se utiliza el “ActionPerformed”. Se
agregan comentarios para tratar de facilitar el entendimiento.

//Método botón agregar.
agregar();
}

//Método botón limpiar.
limpiar();
}

//Método para el jTable 1, obtener fila seleccionada.
seleccion();
}

//Método botón eliminar.
removerSelec();
}
private void subirActionPerformed(java.awt.event.ActionEvent evt) {

//Método botón subir.
moverArriba();
}
private void bajarActionPerformed(java.awt.event.ActionEvent evt) {

//Método botón bajar.
moverAbajo();
}

Java + Swing 019. Modo diseño en NetBeans. Utilizando la clase Comparator con Collections.sort()
para ordenar “List”.
Ejercicio: Realizar una pequeña aplicación que permita ordenar una lista de elementos utilizando la clase Comparator.
Diseñamos el formulario utilizando un JFrame. El nombre para el jFrame es a criterio de cada uno, lo importante es el diseño de la misma. En la imagen podemos ver el
diseño y los nombres de variables de cada objeto (etiquetas en rojo para los nombres de variable), esto es muy importante ya que cada método utiliza el nombre de variable
correspondiente para referenciar al objeto en específico. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar
nombre de variable…”. Para el “jComboBox” debemos de modificar la propiedad “model” agregando (Masculino, Femenino), que serán los datos desplegados.
Se puede descargar el formulario en el siguiente enlace:--> Archivos: *.FORM y *.JAVA
centrar el formulario. Los métodos llamados en el constructor de la clase se inician al ejecutar el formulario. En este caso particular llamamos al método “arranque()” desde el
constructor del jFrame, (comprobar imagen más abajo) es de vital importancia ya que configura los campos y especifica valores para cada una de las tablas. Las variables
de clase se pueden llamar desde cualquier método, por tanto se utiliza para objetos que se necesitan utilizar en varias ubicaciones.
Lista de importaciones necesarias.
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import javax.swing.table.DefaultTableModel;
Antes de crear los métodos que utilizaremos, debemos de crear la clase “PersonaC”. Esta clase servirá para trabajar con “List” y poder realizar los procesos de
ordenamiento. Si utilizamos paquetes, esta clase debe ir en la misma que nuestro jFrame. Esta quedará de la siguiente forma.
/**
*
* @author Ariel
*/
public class PersonaC {
private int id;
private String nomApe;
private String ciudad;
private int edad;
private String sexo;
public PersonaC(int id, String nomApe, String ciudad, int edad, String sexo) {
this.id = id;
this.nomApe = nomApe;
this.ciudad = ciudad;
this.edad = edad;
this.sexo = sexo;
}
public String getCiudad() {

return ciudad;
}
public void setCiudad(String ciudad) {

this.ciudad = ciudad;
}
public int getEdad() {

return edad;
}
public void setEdad(int edad) {

this.edad = edad;
}

return id;
}

this.id = id;
}
public String getNomApe() {

return nomApe;
}
public void setNomApe(String nomApe) {

this.nomApe = nomApe;
}
public String getSexo() {

return sexo;
}
public void setSexo(String sexo) {

this.sexo = sexo;
}
Creamos los métodos siguientes en el apartado “Fuente”. Normalmente estos métodos los podemos agregar debajo del constructor del jFrame o al final de la declaración de
variables. Estos métodos utilizan conversiones de tipos de datos, controles de excepciones y demás para controlar lo mejor posible el resultado. Se agregan comentarios
para tratar de facilitar el entendimiento del funcionamiento de cada código.
private void modelTable1(){

//Configuramos la primera tabla utilizando el DefaultTableModel,
//La tabla posee cinco columnas, el índice inicia de "0" cero.
jTableUno.getColumnModel().getColumn(0).setPreferredWidth(10);
//La variable "modelT1" es de tipo "DefaultTableModel", declarado más arriba
modelT1 = (DefaultTableModel)jTableUno.getModel();
//setNumRows(0) indica el número de filas que tendra la tabla de inicio.
modelT1.setNumRows(0);
}
private void modelTable2(){
//Configuramos la segunda tabla, el procedimiento es igual a la anterior.
jTableDos.getColumnModel().getColumn(0).setPreferredWidth(10);
//En este caso la variable es "modelT2"
modelT2 = (DefaultTableModel)jTableDos.getModel();
}
//Limpiamos campos y llamamos a los dos métodos creados más arriba para configurar las tablas.
modelTable1();
modelTable2();
nom.setText(null);
ciudad.setText(null);
edad.setText(null);
sexo.setSelectedIndex(-1);
}
private void limpiarCampos(){
//Utilizado para limpiar campos después de agregar datos a la tabla uno.
nom.setText(null);
ciudad.setText(null);
edad.setText(null);
sexo.setSelectedIndex(-1);
}
//Antes de agregar datos a la table comprobamos que los campos no esten vacios. Si almenos una de ellas esta vacia, dara
una mensaje al usuario.
if(nom.getText().isEmpty() || ciudad.getText().isEmpty() || edad.getText().isEmpty() || sexo.getSelectedIndex() == -1){
JOptionPane.showMessageDialog(null, "Es necesario rellenar todos los campos.");
}
else{
//Si los campos estan correctos, se agrega el dato a la tabla uno utilizando la variable "modelT1".
int id = jTableUno.getRowCount() + 1;
modelT1.addRow(new Object[]{
id,nom.getText(),ciudad.getText(),edad.getText(),sexo.getSelectedItem().toString()
});
}
}
private void eliminar(){
//Método para eliminar datos de la tabla.
if(jTableUno.getRowCount() > 0){
try {
int sel = jTableUno.getSelectedRow();
modelT1.removeRow(sel);
JOptionPane.showMessageDialog(null, "Seleccione una fila.");
}
}
}
private void cargarLista(){
//Método para llenar la variable "lista" tipo List que creamos más arriba.
//La lista se llenará con los datos de la tabla uno utilizando la clase "PersonaC" que creamos.
if(jTableUno.getRowCount() > 0){
//Inicializamos la variable como ArrayList(), esto es esencial.
lista = new ArrayList();
//Utilizamos "try" para controlar la excepciones.
//La misma se puede dar si no se llena de forma correcta cada campo.
try {
//Recorremos cada fila de la tabla utilizando "for"
for (int i = 0; i < jTableUno.getRowCount(); i++) {
int d = Integer.parseInt(modelT1.getValueAt(i, 0).toString());
int ed = Integer.parseInt(modelT1.getValueAt(i, 3).toString());
//Utilizamos "add" y la clase "PersonaC" para llenar la lista.
lista.add(new PersonaC(d, modelT1.getValueAt(i, 1).toString(), modelT1.getValueAt(i, 2).toString(), ed,
modelT1.getValueAt(i, 4).toString()));
}
JOptionPane.showMessageDialog(null, "Error llenando lista, verificar tipo de datos.");
}
}
}
private void ordenarNombre(){
//Método que nos permitirá llamar a nuestra lista y ordenarla según ciertos parámetros especificados.
//Utilizamos "Comparator" para ordenar la lista.
//Hay que castear como "PersonaC" para poder aplicarla a la lista que creamos más arriba.
Comparator<PersonaC> ordenarNombre = new Comparator<PersonaC>() {
@Override
public int compare(PersonaC o1, PersonaC o2) {
PersonaC pc1 = (PersonaC)o1;
//Para dato String se utiliza "compareTo", compara el mismo campos de dos instancias de la misma clase.
return pc1.getNomApe().compareTo(pc2.getNomApe());
}
};
//Llenamos nuestra lista.
cargarLista();
//Solo ejecutamos el método Collections.sort si la lista no esta vacía.
if(!lista.isEmpty()){
//Los parámetros que le pasamos son la lista en si y la clase Comparator que creamos más arriba.
Collections.sort(lista, ordenarNombre);
//Utilizamos un "for" para recorrer la lista y llenar la segunda tabla con los datos ya ordenados.
//Para lista los mejor es utlizar Iterator.
for (Iterator<PersonaC> it = lista.iterator(); it.hasNext();) {
PersonaC ob = it.next();
ob.getId(),ob.getNomApe(),ob.getCiudad(),ob.getEdad(),ob.getSexo()
});
}
}
}
private void ordenarCiudad(){
//El procedimiento para este método es igual a la anterior.
//La diferencia es que utilizamos el campo "ciudad" de la clase "PersonaC" para ordenar la lista.
Comparator<PersonaC> ordenar = new Comparator<PersonaC>() {
@Override
return pc1.getCiudad().compareTo(pc2.getCiudad());
}
};
cargarLista();
Collections.sort(lista, ordenar);
});
}
}
}
private void ordenarEdad(){
//Este método se diferencia de las anteriores en que utilizamos un campos con dato "int" para ordenar los datos de la
lista.
//Específicamente ordenará por edad.
@Override
//El procedimiento no utiliza el compareTo, solo el signo "-" menos.
return pc1.getEdad()- pc2.getEdad();
}
};
cargarLista();
});
}
}
}
private void ordenarSexo(){
//Este método también ordena la lista utilizando un campo "String".
@Override
return pc1.getSexo().compareTo(pc2.getSexo());
}
};
cargarLista();
});
}
}
}
Utilizamos el evento “ActionPerformed” para llamar los métodos desde los botones. Se utiliza el evento “MouseClicked” para el jTable. Para utilizar un “Evento” hacemos clic
derecho sobre el objeto y seleccionamos “Eventos” de la lista utilizamos la que podamos aplicar al objeto. En la mayoría de los casos se utiliza el “ActionPerformed”. Se
agregan comentarios para tratar de facilitar el entendimiento.

agregar();
limpiarCampos();
}

eliminar();
}
private void ordNombreActionPerformed(java.awt.event.ActionEvent evt) {

ordenarNombre();
}
private void ordCiudadActionPerformed(java.awt.event.ActionEvent evt) {

ordenarCiudad();
}
private void ordEdadActionPerformed(java.awt.event.ActionEvent evt) {

ordenarEdad();
}
private void ordSexoActionPerformed(java.awt.event.ActionEvent evt) {

ordenarSexo();
}
arranque();
}
Java + Swing 020. Modo diseño en NetBeans. Llamar un jDialog interno desde un jFrame.
Ejercicio: Realizar una pequeña aplicación que permita ejecutar un formulario jDialog interno desde un jFrame.
Diseñamos el formulario en JFrame. El nombre para el jFrame es a criterio de cada uno, lo importante es el diseño de la misma. En la imagen podemos ver el diseño y los
nombres de variables de cada objeto (etiquetas en rojo para los nombres de variable), esto es muy importante ya que cada método utiliza el nombre de variable
nombre de variable…”.
Diseño del jDialog: a diferencia de en otras situaciones, este jDialog debe ser interno, por tanto se agrega como cualquier otro objeto, tomando de la paleta y soltando sobre
el diseño del jFrame principal como se muestra en la imagen más abajo, lo demás es igual a como se trabaja con un formulario. Se puede alternar con el del jFrame
seleccionado desde el “Inspector” al costado izquierdo. (clic para ampliar imagen)
centrar el formulario. Las variables de clase se pueden llamar desde cualquier método, por tanto se utiliza para objetos que se necesitan utilizar en varias ubicaciones.
Creamos los métodos siguientes en el apartado “Fuente”. Normalmente estos métodos los podemos agregar debajo del constructor del jFrame o al final de la declaración de
variables. Estos métodos utilizan conversiones de tipos de datos, controles de excepciones y demás para controlar lo mejor posible el resultado. Se agregan comentarios
para tratar de facilitar el entendimiento del funcionamiento de cada código.

//Configuramos tamaño de las columnas
jTbl.getColumnModel().getColumn(0).setPreferredWidth(10);
//Utilizamos nuestra variable model para asignar a nuestra tabla el Model
model = (DefaultTableModel)jTbl.getModel();
//Cargamos datos en la tabla si los campos no estan vacios.
//El signo ! sirve para negar. Por tanto decimos "si el campos es diferente de vacío".
if(!nom.getText().isEmpty() || !nac.getText().isEmpty() || !edad.getText().isEmpty()){
for (int i = 0; i < 10; i++) {
i,nom.getText(),nac.getText(),edad.getText()
});
}
}
}
private void llamarJFrame(){
//Llamamos nuestra metodo para manejar la tabla y llenarla
tableModel();
//Centramos nuestro jDialog
jDialog.setLocationRelativeTo(null);
//La hacemos modal
jDialog.setModal(true);
//Establecemos dimensiones.
jDialog.setMaximumSize(new Dimension(800, 600));
jDialog.setMinimumSize(new Dimension(480, 230));
//Establecemos un título para el jDialog
jDialog.setTitle("Lista de Datos.");
//La hacemos visible.
jDialog.setVisible(true);
}
entendimiento.
private void mostrarActionPerformed(java.awt.event.ActionEvent evt) {

//Método para llamar al jDialog
llamarJDialog();
}
Ejecutamos el formulario jFrame y llamamos a nuestro jDialog desde el botón. (clíc para ampliar imagen)
Java + Swing 021. Modo diseño en NetBeans. Llamar un jFrame externo desde un jFrame.
Ejercicio: Realizar una pequeña aplicación que permita ejecutar un formulario jFrame externo desde un jFrame.
Diseñamos el formulario del JFrame. El nombre para el jFrame es a criterio de cada uno, lo importante es el diseño de la misma. En la imagen podemos ver el diseño y los
nombres de variables de cada objeto (etiquetas en rojo para los nombres de variable), esto es muy importante ya que cada método utiliza el nombre de variable
nombre de variable…”. Para los menús solo editamos la etiqueta, no se cambia el nombre de variable, los menús utilizados son de tres niveles de arriba a abajo: Barra de
Menú, Menú y Elementos de Menú. Al igual que otros elementos los menús se arrastran al lugar correspondiente. El jFrame externo será la que se diseño en el tutorial
“020”: Llamar un jDialog interno desde un jFrame. Ambos jFrame deben de estar en el mismo paquete o caso contrario el jFrame externo debe de ser exportado. (clic para
ampliar imagen)
centrar el formulario. No hay muchos elementos de diseño por tanto esta algo desocupada.
private void llamarForm(){

//Creamos una instancia del formulario JFrameUno, creado anteriormente.
JFrameUno v = new JFrameUno();
//Indicamos que se muestren las opciones "minimizar", "maximizar" y "cerrar"
v.setDefaultCloseOperation(HIDE_ON_CLOSE);
//Indicamos el título del formulario, especificamos dos posibles opciones.
//Si el título del formulario no se especifica, se da uno por defecto.
if(!nom.getText().isEmpty()){
v.setTitle(nom.getText());
}
else{
v.setTitle("Formulario Secundario.");
}
v.setVisible(true);
}
entendimiento.
private void ejecutarActionPerformed(java.awt.event.ActionEvent evt) {

//Botón Ejecutar Form
llamarForm();
}
private void jMenuItem2ActionPerformed(java.awt.event.ActionEvent evt) {

//Menú Ejecutar Form
llamarForm();
}
private void jMenu1ActionPerformed(java.awt.event.ActionEvent evt) {

//Menú Salir
System.exit(0);
}
Ejecutamos el formulario jFrame y llamamos a nuestro jFrame Externo. (clic para ampliar imagen)
Java + Swing 022. Modo diseño en NetBeans. Utilizando Barra de Herramientas.

Ejercicio: Realizar una pequeña aplicación para llamar formularios externos utilizando “Barra de Herramientas”.
Diseñamos el formulario del JFrame. El nombre para el jFrame es a criterio de cada uno, lo importante es el diseño de la misma. En este caso particular los nombres de
variables son a criterios también de cada uno, pues no crearemos métodos para ejecutar los formularios, más bien agregaremos los códigos dentro mismo de los eventos.
Los elementos que utilizamos son la “Barra de herramientas” y “Botones” agregados dentro del objeto anterior. El jFrame externo será la que se diseño en el tutorial “020” y
“021” o cualquiera que queramos utilizar, es cuestión de instanciar el formulario elegido, siendo este jFrame. Los jFrame de ser posible deben de estar en el mismo paquete.
(clic para ampliar imagen)
centrar el formulario. No hay muchos elementos de diseño por tanto esta algo desocupada.
A diferencia de otros formularios creados anteriormente, los códigos específicos las agregamos dentro de los eventos como se ve más abajo. Ya que en esencia son
botones, utilizaremos el evento ActionPerformed.

//Salir del formulario...
System.exit(0);
}

try {
//Creamos una instancia del formulario JFrameUno, creado anteriormente.
JFrameUno v = new JFrameUno();
//Indicamos que se muestren las opciones "minimizar", "maximizar" y "cerrar".
//Indicamos el título del formulario.
v.setVisible(true);
JOptionPane.showMessageDialog(null, "Error al ejecutar formulario.");
}
}

try {
//Creamos una instancia del formulario JFramePr, creado anteriormente.
JFramePr v = new JFramePr();
//Indicamos que se muestren las opciones "minimizar", "maximizar" y "cerrar".
//La hacemos visible
v.setVisible(true);
JOptionPane.showMessageDialog(null, "Error al ejecutar formulario.");
}
}
Ejecutamos nuestro formulario, si todo ha ido bien la veremos así.

Java + Swing 023. Modo diseño en NetBeans. Utilizar función autocompletar en JComboBox.
Ejercicio: Realizar una pequeña aplicación que permita utilizar la función de autocompletar en los JComboBox.
nombre de variable…”. En la imagen también se ven las propiedades que debemos tener en cuenta para los tres JComboBox que agregaremos. (clic en la imagen para
ampliar)
centrar el formulario. El método “inicio()” que llamamos en el constructor se ejecutará al lanzar el formulario. Debemos de tener en cuenta también el paquete de nuestro
jFrame.
Antes de crear el único método que utilizaremos, debemos de crear una clase que llamaremos “AutoCompletarComboBox”, el cual manejará la función de autocompletar. Es
una clase creada por terceros y compartida para su uso, está bien optimizada y testeada. Esta clase debemos de tenerla en el mismo paquete que nuestro JFrame, caso
contrario toca hacer un “import”. En el código hay referencia a la web de origen.
package com.java.swing;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusAdapter;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import javax.swing.ComboBoxEditor;
import javax.swing.ComboBoxModel;
import javax.swing.JComboBox;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.JTextComponent;
import javax.swing.text.PlainDocument;
/**
*
* @author Ariel
* Referencia web: http://www.orbital-computer.de/JComboBox/
*/
public final class AutoCompletarComboBox extends PlainDocument {
JComboBox comboBox;
ComboBoxModel model;
JTextComponent editor;
boolean selecting=false;
boolean hidePopupOnFocusLoss;
boolean hitBackspace=false;
boolean hitBackspaceOnSelection;
KeyListener editorKeyListener;
FocusListener editorFocusListener;
public AutoCompletarComboBox(final JComboBox comboBox) {

this.comboBox = comboBox;
model = comboBox.getModel();
comboBox.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
if (!selecting) highlightCompletedText(0);
}
});
comboBox.addPropertyChangeListener(new PropertyChangeListener() {
@Override
public void propertyChange(PropertyChangeEvent e) {
if (e.getPropertyName().equals("editor")) configureEditor((ComboBoxEditor) e.getNewValue());
if (e.getPropertyName().equals("model")) model = (ComboBoxModel) e.getNewValue();
}
});
editorKeyListener = new KeyAdapter() {
@Override
public void keyPressed(KeyEvent e) {
if (comboBox.isDisplayable()) comboBox.setPopupVisible(true);
hitBackspace=false;
switch (e.getKeyCode()) {
case KeyEvent.VK_BACK_SPACE : hitBackspace=true;
hitBackspaceOnSelection=editor.getSelectionStart()!=editor.getSelectionEnd();
break;
case KeyEvent.VK_DELETE : e.consume();
comboBox.getToolkit().beep();
break;
}
}
};
hidePopupOnFocusLoss=System.getProperty("java.version").startsWith("1.5");
editorFocusListener = new FocusAdapter() {
@Override
public void focusGained(FocusEvent e) {
highlightCompletedText(0);
}
@Override
public void focusLost(FocusEvent e) {
if (hidePopupOnFocusLoss) comboBox.setPopupVisible(false);
}
};
configureEditor(comboBox.getEditor());
Object selected = comboBox.getSelectedItem();
if (selected!=null) setText(selected.toString());
highlightCompletedText(0);
}
public static void enable(JComboBox comboBox) {

comboBox.setEditable(true);
new AutoCompletarComboBox(comboBox);
}
void configureEditor(ComboBoxEditor newEditor) {

if (editor != null) {
editor.removeKeyListener(editorKeyListener);
editor.removeFocusListener(editorFocusListener);
}
if (newEditor != null) {
editor = (JTextComponent) newEditor.getEditorComponent();
editor.addKeyListener(editorKeyListener);
editor.addFocusListener(editorFocusListener);
editor.setDocument(this);
}
}
@Override
public void remove(int offs, int len) throws BadLocationException {
if (selecting) return;
if (hitBackspace) {
if (offs>0) {
if (hitBackspaceOnSelection) offs--;
} else {
}
highlightCompletedText(offs);
} else {
super.remove(offs, len);
}
}
@Override
public void insertString(int offs, String str, AttributeSet a) throws BadLocationException {
if (selecting) return;
super.insertString(offs, str, a);
Object item = lookupItem(getText(0, getLength()));
if (item != null) {
setSelectedItem(item);
} else {
item = comboBox.getSelectedItem();
offs = offs-str.length();
}
setText(item.toString());
highlightCompletedText(offs+str.length());
}
private void setText(String text) {

try {
super.remove(0, getLength());
super.insertString(0, text, null);
} catch (BadLocationException e) {
throw new RuntimeException(e.toString());
}
}
private void highlightCompletedText(int start) {

editor.setCaretPosition(getLength());
editor.moveCaretPosition(start);
}
private void setSelectedItem(Object item) {

selecting = true;
model.setSelectedItem(item);
selecting = false;
}
private Object lookupItem(String pattern) {

Object selectedItem = model.getSelectedItem();
if (selectedItem != null && startsWithIgnoreCase(selectedItem.toString(), pattern)) {
return selectedItem;
} else {
for (int i=0, n=model.getSize(); i < n; i++) {
Object currentItem = model.getElementAt(i);
if (currentItem != null && startsWithIgnoreCase(currentItem.toString(), pattern)) {
return currentItem;
}
}
}
return null;
}
private boolean startsWithIgnoreCase(String str1, String str2) {

return str1.toUpperCase().startsWith(str2.toUpperCase());
}
}
Creamos el método “inicio()” el cual llamaremos desde el constructor del jFrame. Normalmente los métodos los podemos agregar debajo del constructor del jFrame o al final
de la declaración de variables. En este proyecto no utilizaremos eventos.
private void inicio(){

//Instanciamos nuestra clase AutoCompletarComboBox pasando como argumento nuestro JComboBox.
AutoCompletarComboBox autoUno = new AutoCompletarComboBox(comboDias);
AutoCompletarComboBox autoDos = new AutoCompletarComboBox(comboMeses);
AutoCompletarComboBox autoTres = new AutoCompletarComboBox(comboNombres);
//La clase es sencilla de implementar, se puede utilizar en cualquier proyecto
}
Ejecutamos nuestro formulario y vemos los resultados.

Java + Swing 024. Modo diseño en NetBeans. Abrir imagen "jpg" y "png" desde aplicación Java.
Ejercicio: Realizar una pequeña aplicación que permita abrir imágenes tipo "jpg" y "png" en Java.
nombre de variable…”. El jPanel donde esta insertado el campo de texto y el botón posee un borde con título, es opcional, en la imagen se ve como es el proceso para
poner el título. El jPanel donde se mostrará la imagen que carguemos se puede establecer un tamaño a criterio de cada uno. (Clic para ampliar la imagen)
centrar el formulario. El método “inicio()” que llamamos en el constructor se ejecutará al lanzar el formulario. Debemos de tener en cuenta también el paquete de nuestro
jFrame.
Lista de Importaciones
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JFileChooser;
import javax.swing.JPanel;
import javax.swing.filechooser.FileNameExtensionFilter;
Declaración de variables de clase.
//Variables de clase
private BufferedImage img;
//FileNameExtensionFilter para especificar tipo de archivos a manejar...
private FileNameExtensionFilter filter = new FileNameExtensionFilter("Archivo de Imagen","jpg","png");
Creamos los métodos siguientes, cada método posee un nombre que especifica de cierta forma su función. Seguido de los método también se agrega una clase (mipanel)
que servirá para manejar la imagen y pintarla en al jPanel de nuestro diseño. Se agregan comentarios que tratan de aclarar la función de cada línea de código.
//Método que retorna un "BufferedImage" pasándole como argumento una "URL"

private BufferedImage cargarImagen(URL url) throws IOException{
//Se vacia la variable de clase tipo "BufferedImage"
img = null;
//Se utiliza contro de excepciones
try {
//Se utiliza ImageIO.read(url) para leer la URL y cargar el "BufferedImage"
img = ImageIO.read(url);
//se retorna el valor.
return img;
} catch (IOException e) {
JOptionPane.showMessageDialog(null, "Error cargando imagen.");
//Si hay algun erro se retorna vacío.
return null;
}
}
//Método para abrir la imagen, se pasa como argumento una jPanel.
//En este caso el argumento será "imgPanel" que es el nombre de nuesto jPanel.
private void abrirImagen(JPanel jp) throws MalformedURLException, IOException{
//Se utiliza JFileChooser para la búsqueda de archivo.
JFileChooser fileChooser = new JFileChooser();
//Especificamos el filtro, utilzando la variable de clase "filter" que creamos.
fileChooser.setFileFilter(filter);
//Utilizamos una condicional para comprobar la apertura del archivo.
int result = fileChooser.showOpenDialog(null);
if(result == JFileChooser.APPROVE_OPTION){
//Limpiamos nuestro jPanel.
imgPanel.removeAll();
//Obtenemos la URL del archivo seleccionado
URL toURL = fileChooser.getSelectedFile().toURI().toURL();
//Agregamos la URL a nuestro campo de texto.
urlText.setText(toURL.getPath());
//Utilizamos nuestro método "cargarImagen(toURL)" pasando el argumento.
BufferedImage cargarImagen = cargarImagen(toURL);
//El jp será el argumento que le pasemos al método.
//"mipanel" es una clase que se crea más abajo.
//El primer argumento un BufferedImage,
//El segundo obtiene al tamaño "Dimension" del jPanel, por tanto la imagen se agusta al mismo.
jp.add(new mipanel(cargarImagen, jp.getSize()));
//La hacemos visible y le hacemos un repaint()
jp.setVisible(true);
jp.repaint();
}
}
//Esta clase se agrega seguido de los métodos de clase, igualmente funciona.
//La clase se crea utilizando de referencia un blog jCmouse.
//Es una clase que extiendo a un JPanel.
public class mipanel extends JPanel{
BufferedImage _image;
//Constructor
public mipanel(){}
//Constructor con dos argumentos.
//El primero será un BufferedImage, el segundo la dimesión.
//Por tanto al crear el jPanel se integra la imagen.
public mipanel( BufferedImage imagen, Dimension d ){
this._image = imagen;
this.setSize(d);
}
//Este método permitirá pintar el jPanel junto con la imagen.

//Es un método heredado del JPanel.
@Override
public void paint(Graphics g){
ImageIcon imagenFondo = new ImageIcon(_image);
g.drawImage(imagenFondo.getImage(),0,0,getWidth(),getHeight(), null);
setOpaque(false);
super.paintComponent(g);
}
}
Utilizamos el evento “ActionPerformed” para llamar nuestro método “abrirImagen(…)” desde el botón buscar. Para utilizar un “Evento” hacemos clic derecho sobre el objeto y
seleccionamos “Eventos” de la lista utilizamos la que podamos aplicar al objeto. En la mayoría de los casos se utiliza el “ActionPerformed”. Se agregan comentarios para
tratar de facilitar el entendimiento.
private void buscarActionPerformed(java.awt.event.ActionEvent evt) {

//Se utiliza control de excepciones para manejar el método utilizado
try {
//Se pasa como parámetro nuestro jPanel del diseño.
abrirImagen(imgPanel);
} catch (MalformedURLException ex) {
Logger.getLogger(JFrameImage.class.getName()).log(Level.SEVERE, null, ex);
} catch (IOException ex) {
Logger.getLogger(JFrameImage.class.getName()).log(Level.SEVERE, null, ex);
}
}
Ejecutamos nuestro formulario y vemos los resultados. El tamaño del jFrame se puede aumentar, en tanto la imagen que carguemos se ajustará a ella. (Clic para ampliar la
imagen)
Java + Swing 025. Modo diseño en NetBeans. Cargar imágenes “jpg” y “png” desde un directorio a
un JTable.
Ejercicio: Realizar una pequeña aplicación que permita cargar imágenes tipo "jpg" y "png" desde un directorio a un JTable.
Gran parte del código que se implementa en esta aplicación es tomada y adaptada de otra fuente: referencia principal jc-mouse (http://goo.gl/uKrT2W).
nombre de variable…”. El jTable posee tres columnas sin nombre, esta se agregará desde al “model”. (clic para ampliar imgen)
centrar el formulario. El método “tableModel()” que llamamos en el constructor se ejecutará al lanzar el formulario. Debemos de tener en cuenta también el paquete de
nuestro jFrame.
Lista de Importaciones necesarias.
import java.awt.Component;
import java.io.File;
import java.io.FileFilter;
import java.util.HashMap;
import java.util.Map;
import javax.swing.JLabel;
import javax.swing.JTable;
import javax.swing.table.DefaultTableCellRenderer;
Lista de Variables de clase.
//Variables de clase.
private MyTableModel modelo = new MyTableModel();
private FileNameExtensionFilter filter = new FileNameExtensionFilter("Archivo de Imagen","jpg","png");
Creamos los métodos y clases siguientes, cada método y clase posee un nombre que especifica de cierta forma su función. Las clases al igual que los métodos pueden ir
dentro del mismo JFrame, es ideal si no se utiliza en otro formulario. En caso de ser necesaria su utilización en otros formularios debe de ir en un archivo independiente y
dentro del mismo paquete si es posible. Se agregan comentarios para indicar en lo posible que función cumple cada línea de código.
//Método para manejar jTable

String[] nombreColumnas = {"Imagen","Imagen","Imagen"};
Object[][] datosFila = { };
modelo.setDataVector(datosFila, nombreColumnas);
tableImg.setModel(modelo);
tableImg.getColumnModel().getColumn(0).setCellRenderer( new ImageRenderer() );
tableImg.setRowHeight(256);
//Método para mostrar una vista previa de la imagen seleccionada del jtable.
tableImg.addMouseListener(new java.awt.event.MouseAdapter() {
@Override
public void mouseClicked(java.awt.event.MouseEvent evt) {
int row = tableImg.rowAtPoint(evt.getPoint());
int col = tableImg.columnAtPoint(evt.getPoint());
if ( row >= 0 && col >= 0 )
{
//si celda contiene imagen
if( modelo.getValueAt(row, col) != null )
{
//obtiene la ruta que corresponde a la celda donde se hizo el clic
File fichero = new File( modelo.getValueAt(row, col).toString() );
//se carga la imagen en un jlabel
JLabel picLabel = new JLabel(new ImageIcon( fichero.getAbsolutePath() ));
//se muestra la imagen en el jdialog
JOptionPane.showMessageDialog(null, picLabel, "Vista Previa", JOptionPane.PLAIN_MESSAGE, null);
}
}
}
});
}
//Permite seleccionar el directorio del cual cargaremos las imagenes.
private void selecDir(){
//JFileChooser como selector de archivos.
JFileChooser fileDir = new JFileChooser();
//Filtro que creamos más arriba como variable de clase. Permite mostra solo imagenes jpg y png
fileDir.setFileFilter(filter);
//Comprobamos que se apruebe la selección
if (fileDir.showOpenDialog(null) == JFileChooser.APPROVE_OPTION) {
//Limpiamos las filas del jtable.
modelo.setRowCount(0);
//ImgFilter es una clase que se crea más abajo para filtrar la imagenes que se cargarán.
//Esto porque el anterior filtro que creamos es para filtrar las que se muestran.
ImgFilter filt = new ImgFilter();
//Cargamos en un array los orchivos de imagen especificando nuestro filtro.
File[] selectedFiles = fileDir.getCurrentDirectory().listFiles(filt);
//Recorremos el array y vamos cargando las imagenes en la tabla.
for (int id = 0; id < selectedFiles.length; id++) {
File selectedFile = selectedFiles[id];
int f = modelo.getRowCount();//cantidad de filas
int c = modelo.getColumnCount();//cantidad de columnas
boolean ok = true;
//recorre todo el TableModel buscando una celda vacia para agregar la imagen
for( int i=0; i<f;i++ )
{
if( ok )
{
for( int j=0; j<c; j++ ){
if( modelo.getValueAt(i, j) == null )

{
this.modelo.setValueAt( selectedFile.getAbsolutePath() , i, j );
tableImg.repaint();
ok=false;
break;
}
}
}
else
{
break;
}
}
if( ok ) //añade nueva fila

{
modelo.setRowCount( modelo.getRowCount() + 1 );
this.modelo.setValueAt( selectedFile.getAbsolutePath() , modelo.getRowCount()-1, 0 );
tableImg.repaint();
}
}
}
}
//Clase que extiende a DefaultTableModel, nos permite trabajar con tablas.

public class MyTableModel extends DefaultTableModel {
@Override
public boolean isCellEditable(int row, int column) {
return false;
}
//------------------------------------class ImageRenderer-------------------------------------------------------------------
----------------------------------
//Clase que extiende a DefaultTableCellRenderer, nos permitira cargar una imagen a una celda seleccionada.
public class ImageRenderer extends DefaultTableCellRenderer{
private JLabel lb = new JLabel();

//imagen que se muestra cuando la celda esta vacia
private ImageIcon icon = new ImageIcon( getClass().getResource("conta.png") );
//para contener las imagenes que se vayan cargando
private Map iconos = new HashMap() ;
@Override
public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,boolean hasFocus, int
row, int column){
lb.setText((String) value);
File fichero;
//
if( value !=null )
{
fichero = new File( value.toString() );
//comprueba que fichero exista
if( fichero.exists() )
{
//busca la imagen en el MAP
if( ya_existe( value.toString() ) )
{
//si ya existe, extrae la imagen del MAP
lb.setIcon( getIcono( value.toString() ) );
}
else //No existe
{
//Agrega la imagen al map
iconos.put(value.toString(), bToIcon(fichero) );
//extrae y muestra
lb.setIcon( getIcono( value.toString() ) );
}
}
else //si no existe, muestra imagen por default
{
lb.setIcon(icon);
}
}
else
{
lb.setIcon(icon);
}
return lb;
}
/**
* Comprueba que una imagen ya exista en memoria
* @param String key identificador
*/
private boolean ya_existe( String key ){
Iterator it = iconos.entrySet().iterator();
while (it.hasNext()) {
Map.Entry e = (Map.Entry)it.next();
if( e.getKey().equals(key) )
return true;
}
return false;
}
/**
* Extrae una imagen del MAP dado su KEY
* @param String key identificador unico
* @return ImageIcon
*/
private ImageIcon getIcono( String key ) {
ImageIcon imageIcon = icon;
Iterator it = iconos.entrySet().iterator();
while (it.hasNext()) {
Map.Entry e = (Map.Entry)it.next();
if( e.getKey().equals(key) )
{
imageIcon = (ImageIcon) e.getValue();
break;
}
}
return imageIcon;
}
/**
* Dado la ruta de un archivo de imagen, carga este en un ImageIcon y retorna
* @param File fichero
*/
private ImageIcon bToIcon( File fichero ){
ImageIcon imageIcon = new ImageIcon( fichero.getAbsolutePath() );
return imageIcon;
}
}
//--------------------------------------------------------------------------------------------------------------------------
---------------
//Clase que permite filtrar tipos de arhivos, extiende a FileFilter.

//Esta clase la utilizaremos para filtrar los archivos de una carpeta selecionada.
public class ImgFilter implements FileFilter{
//Se retorna true o false según corresponda o no al filtro indicado.
@Override
public boolean accept(File f)
{
if (f != null && f.getName().toLowerCase().endsWith(".jpg") ||f.getName().toLowerCase().endsWith(".png") )
{
return true;
}
else
{
return false;
}
}
public String getDescription()

{
return "Filtro para imagenes.";
}
}
Utilizamos el evento “ActionPerformed” para llamar nuestro método “selecDir()” desde el botón “cargar” de nuestro diseño. Para utilizar un “Evento” hacemos clic derecho
sobre el objeto y seleccionamos “Eventos” de la lista utilizamos la que podamos aplicar al objeto. En la mayoría de los casos se utiliza el “ActionPerformed”. Se agregan
comentarios para tratar de facilitar el entendimiento.
private void cargarActionPerformed(java.awt.event.ActionEvent evt) {

//Método para seleccionar una imagen y poder cargar el directorio completo en la que se encuentra.
selecDir();
}
Ejecutamos nuestro formulario y vemos los resultados. El tamaño del jFrame como el de las columnas de la tabla se puede ajustar. (Clic para ampliar la imagen)
Inicio en Java modo diseño. Uso básico de elementos Swing con NetBeans.
Uso básico de elementos Swing con NetBeans – 01 – Uso de JButton con eventos.
JButton es uno de los controles Swing más comunes y más utilizados, en este post veremos algunos de los usos básicos: deshabilitar y habilitar botones, establecer un
botón por defecto que recibe foco al cargar el formulario y utilizar eventos para ejecutar métodos o líneas de códigos al hacer clic en el botón.
Para facilitar el diseño debemos de crear paquetes, una para nuestros formularios y otra para las imágenes que se usan habitualmente, en cuestión de imágenes es
recomendable “png” con una dimensión 32x32. En la imagen del diseño que se expone más abajo se especifican los puntos importantes.
Diseñamos un formulario utilizando un JFrame, este formulario contendrá tres botones como se ve en la imagen más abajo. Es preciso establecer nombre de variable para
cada botón, de esa forma las podremos referenciar y modificar sus propiedades. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la
misma y clic en “Cambiar nombre de variable…”. (clic sobre la imagen para ampliar)
Tras completar el diseño el diseño agregamos dos líneas de código en el constructor del JFrame, esto pasando del modo de diseño al modo fuente, una sirve para centrar el
formulario y la otra es un método que se crea más abajo para establecer propiedades de inicio para los objetos.
setLocationRelativeTo(null);//Centrar formulario...
inicio();//Método que se carga al iniciar el formulario...
Creamos el método “inicio()” en modo fuente, los métodos creados por nosotros las ubicamos al final de la declaración de variables, justo antes de la llave de cierre general.
Como vimos más arriba este método se referencia desde el constructor del JFrame para poder ejecutarla al lanzar el formulario.
//Método único que utilizaremos.

//Se utiliza la propiedad Enabled pasándole "true" para habilitar y
//"false" para deshabilitar.
btUno.setEnabled(true);
btDos.setEnabled(true);
btTres.setEnabled(true);
//Se utiliza DefaultButton para establecer botón por defecto, pasándole como argumento el JButton.
getRootPane().setDefaultButton(btDos);
}
El siguiente paso es establecer los eventos, cada botón deberá implementar uno para que tenga funcionalidad. El evento que normalmente se utiliza para botones es el
ActionPerformed. En la imagen más abajo se ve como es la implementación y seguido el código para los eventos.
//Lista de eventos. Cada botón implementa el ActionPerformed.
private void btUnoActionPerformed(java.awt.event.ActionEvent evt) {
btTres.setEnabled(false);
}
private void btTresActionPerformed(java.awt.event.ActionEvent evt) {
btUno.setEnabled(false);
}
private void btDosActionPerformed(java.awt.event.ActionEvent evt) {

btUno.setEnabled(true);
btTres.setEnabled(true);
}
Al entrar en modo fuente todo deberá quedar de esta forma, la mayor parte son códigos generados automáticamente al crear el JFrame y al agregar los objetos. Lo
importante es donde ubicamos cada línea de código que creamos más arriba.
Al llegar a este punto ejecutamos nuestro formulario y verificamos su funcionalidad. Nos es nada especial pero es un inicio para aprender java en modo de diseño.
Uso básico de elementos Swing con NetBeans – 02 – Uso básico de JButton, JCheckBox y JList con
eventos.
En la guía anterior vimos algunos usos básico del JButton, en este caso solo la utilizaremos con el evento ActionPerformed para ejecutar códigos
sobre JCheckBox y JList. Los JCheckBox son útiles para seleccionar varios elementos de una lista de opciones y los JList pueden almacenar lista de elementos al igual
que recuperarlas de forma sencilla. Para esta guía veremos una lista de opciones con JCheckBox, al seleccionar alguno, la etiqueta del mismo se cargará en la lista que
tenemos a la derecha. Esto nos dará una idea de la forma de recuperar datos de una JCheckBox y saber cuándo esta seleccionado o no utilizando eventos. También
podremos ver como se agregan datos a un JList y como vaciar de elementos utilizando los llamados DefaultModel.
Para facilitar el diseño debemos de crear paquetes, una para nuestros formularios y otra para las imágenes que se usan habitualmente, en cuestión de imágenes para
botones es recomendable “png” con una dimensión 32x32 para los demás usos es a criterio de cada uno. En la imagen del diseño que se expone más abajo se especifican
los puntos importantes.
Diseñamos un formulario utilizando un JFrame, este formulario contendrá varios JCheckBox, JButton, un JList y una imagen que se carga utilizando una etiqueta.
Cada elemento tiene un nombre de variable como se especifica en la imagen, tomar en cuenta este punto ya que es necesario para referenciar los objetos. Se puede
cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. (clic sobre la imagen para ampliar)
Antes de continuar debemos de crear una variable de clase tipo DefaultListModel para agregar elementos a la lista y limpiarla. Esta variable de clase puede ir seguida
del cierre de llave del constructor del JFrame.
DefaultListModel modelo = new DefaultListModel();
Creamos el método “checkBox()” en modo fuente, los métodos creados por nosotros las ubicamos al final de la declaración de variables, justo antes de la llave de cierre
general. Este método no permitirá deseleccionar los JCheckBox y la enlazaremos con un JButton.
private void checkBox(){

jcbUno.setSelected(false);
jcbDos.setSelected(false);
jcbTres.setSelected(false);
jcbCuatro.setSelected(false);
jcbCinco.setSelected(false);
}
El siguiente paso es establecer los eventos, cada botón y JCheckBox deberá implementar uno para que tenga funcionalidad. El evento que normalmente se utiliza para
botones y JCheckBox es el ActionPerformed. En la imagen más abajo se ve como es la implementación y seguido el código para los eventos.
private void jcbUnoActionPerformed(java.awt.event.ActionEvent evt) {
if(jcbUno.isSelected()){
jList.setModel(modelo);
modelo.addElement(jcbUno.getText());
}
}
private void jcbDosActionPerformed(java.awt.event.ActionEvent evt) {

if(jcbDos.isSelected()){
modelo.addElement(jcbDos.getText());
}
}
private void jcbTresActionPerformed(java.awt.event.ActionEvent evt) {

if(jcbTres.isSelected()){
modelo.addElement(jcbTres.getText());
}
}
private void jcbCuatroActionPerformed(java.awt.event.ActionEvent evt) {

if(jcbCuatro.isSelected()){
modelo.addElement(jcbCuatro.getText());
}
}
private void jcbCincoActionPerformed(java.awt.event.ActionEvent evt) {

if(jcbCinco.isSelected()){
modelo.addElement(jcbCinco.getText());
}
}

modelo.clear();
}

checkBox();
}
En este punto ya podremos ejecutar nuestro formulario y comprobar su funcionalidad.
Uso básico de elementos Swing con NetBeans – 03 – Uso básico de JRadioButton con eventos.
En esta guía veremos cómo se agrupa y utiliza un JRadioButton, como se ver en el diseño más abajo serán cinco los JRadioButton que agruparemos
utilizando ButtonGroup, esto permitirá que el usuario solo pueda seleccionar un elemento cada vez. La aplicación es sencilla, cuando el usuario seleccione uno de
los JRadioButton se cargará en el JLabel la imagen que representa. El grupo de cinco imágenes es a griterío de cada uno.
Como indicamos en las guías anteriores, para facilitar el diseño debemos de crear paquetes, una para nuestros formularios y otra para las imágenes que se usan
habitualmente, en cuestión de imágenes para botones es recomendable “png” con una dimensión 32x32 para los demás usos es a criterio de cada uno. En la imagen del
diseño que se expone más abajo se especifican los puntos importantes.
Diseñamos un formulario utilizando un JFrame, este formulario tendrá como vemos en la imagen cinco JRadioButton, un JPanel para agregar nuestro JLabel con imagen y
otro JLabel para el título. Cada elemento tiene un nombre de variable como se especifica en la imagen, tomar en cuenta este punto ya que es necesario para referenciar los
objetos. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. (clic sobre la imagen para
ampliar)
Creamos los métodos siguiente en modo fuente, los métodos creados por nosotros las ubicamos al final de la declaración de variables, justo antes de la llave de cierre
general. Se agregan comentario para aclarar la función de cada línea de código.
//Método que arranca con el constructor del JFrame

//Utilizamos ButtonGroup para agrupar los jRadioButton.
//Agrupar es ideal para permitir que se seleccione solo un elemento a la vez.
ButtonGroup group = new ButtonGroup();
group.add(jRadioButton1);
//Al arrancar indicamos el este seleccionado el primer jRadioButton.
jRadioButton1.setSelected(true);
//Cargamos la imagen indicada al JLabel.
//La URL debe indicar el paquete en el que está la imagen.
//El paquete sería en este caso com.swing.basic.img
imgLabel.setIcon(createImageIcon("/com/swing/basic/img/computer.png"));
}
//Método que nos permitira cargar una imagen como icono pasandole una url
protected static ImageIcon createImageIcon(String path) {
java.net.URL imgURL = UsoJRadioButton.class.getResource(path);
if (imgURL != null) {
return new ImageIcon(imgURL);
} else {
System.err.println("Archivo no encontrado: " + path);
return null;
}
}
Antes de continuar veremos que método se llama desde el constructor y que importaciones son las necesarias. La imagen y más abajo las importaciones necesarias.
//Importaciones necesarias.
import javax.swing.ButtonGroup;
El siguiente paso es establecer los eventos, cada JRadioButton deberá implementar uno para que tenga funcionalidad. El evento que normalmente se utiliza para este tipo
de elementos es el ActionPerformed. En la imagen más abajo se ve como es la implementación y seguido el código para los eventos.
private void jRadioButton1ActionPerformed(java.awt.event.ActionEvent evt) {
//Para que se ejecute el código el jRadioButton deberá estar seleccionado.
if(jRadioButton1.isSelected()){
//Utilamos nuestro método creado para cargar la imagen.
}
}

imgLabel.setIcon(createImageIcon("/com/swing/basic/img/key.png"));
}
}

imgLabel.setIcon(createImageIcon("/com/swing/basic/img/userr.png"));
}
}

imgLabel.setIcon(createImageIcon("/com/swing/basic/img/client2.png"));
}
}

imgLabel.setIcon(createImageIcon("/com/swing/basic/img/note.png"));
}
}
En este punto ya podremos ejecutar nuestro formulario y comprobar su funcionalidad.
Uso básico de elementos Swing con NetBeans – 04 – Uso básico de JComboBox con eventos. Ej. 01.
En esta guía podremos ver el uso básico que se le puede dar a un JComboBox, pudiendo recuperar datos y relacionarla con eventos. Esta aplicación es una variación de la
que vimos en la guía anterior (03), en este caso pondremos los elementos que se relacionan con una imagen en específico dentro del JComboBox y cada vez que hagamos
una selección, se mostrará una imagen en el JLabel que designamos para el caso.
Como siempre para facilitar el diseño debemos de crear paquetes, una para nuestros formularios y otra para las imágenes que se usan habitualmente, en cuestión de
imágenes para botones es recomendable “png” con una dimensión 32x32 para los demás usos es a criterio de cada uno. En la imagen del diseño que se expone más abajo
se especifican los puntos importantes.
Diseñamos un formulario utilizando un JFrame, el elemento principal es el JComboBox a la cual le asignamos ítems desde el modo de diseño utilizando la propiedad
“model”, estas son en orden como sigue: (Computadora, Llave, Usuario, Cliente, Nota). Otro elemento es un JPanel para agregar nuestro JLabel con imagen la cual
podremos asignarle un icono en modo de diseño modificando la propiedad “icon” y otro JLabel en la parte superior para el título. Cada elemento tiene un nombre de variable
como se especifica en la imagen, tomar en cuenta este punto ya que es necesario para referenciar los objetos. Se puede cambiar el “Nombre de variable” de cada objeto
haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. (Clic sobre la imagen para ampliar)
//Este método permite especificar un índice para el jComboBox1 y cargar su imagen correspondiente.
jComboBox1.setSelectedIndex(0);
}
//Método que nos permitira cargar una imagen como icono pasándole una url
} else {
return null;
}
}
Antes de continuar veremos que método se llama desde el constructor y la importación necesaria en este caso.
El paso siguiente es establece un evento para nuestro JComboBox, esto le dará la funcionalidad que necesitamos. El evento que normalmente se utiliza para este tipo de
elementos es el ActionPerformed. En la imagen más abajo se ve como es la implementación y seguido el código para los eventos. Si ya vieron alguna guía anterior a esta,
podrán saber la ubicación habitual tanto para la lista de eventos como también los métodos que hayamos creado.
//Dependiendo del índice se carga el elemento.
//El íncide empieza de "0", que será el primer elemento del jComboBox
if(jComboBox1.getSelectedIndex() == 0){
}
else if(jComboBox1.getSelectedIndex() == 1){
imgLabel.setIcon(createImageIcon("/com/swing/basic/img/key.png"));
}
imgLabel.setIcon(createImageIcon("/com/swing/basic/img/userr.png"));
}
imgLabel.setIcon(createImageIcon("/com/swing/basic/img/client2.png"));
}
//También es posible obtener el elemento seleccionado para comparar con cierto valor.
else if(jComboBox1.getSelectedItem().toString().equals("Nota")){
imgLabel.setIcon(createImageIcon("/com/swing/basic/img/note.png"));
}
}
En este punto ya podremos ejecutar nuestro formulario y comprobar su funcionalidad. (Por si hay alguna duda en el proceso, debemos hacer clic derecho sobre nuestro
archivo fuente y presionar “ejecutar archivo” ya que nuestro proyecto no tiene una clase principal definida)
Uso básico de elementos Swing con NetBeans – 05 – Uso básico de JComboBox con eventos. Ej. 02.
En esta guía vemos un segundo ejemplo del uso que se le puede dar a un JComboBox junto con eventos. Utilizaremos una lista de formatos de fecha y hora con la que
podremos obtener los diferentes formatos de fecha y hora del sistema.
Diseñamos un formulario utilizando un JFrame, el primer elemento que agregamos es nuestro JComboBox al cual le agregaremos ítems utilizando un método que se
ejecutará al arrancar el formulario. Agregamos un JTextField para presentar nuestro resultado en el formato que elijamos del JComboBox. Utilizamos JLabels para las
etiquetas y el título. Cada elemento tiene un nombre de variable como se especifica en la imagen, tomar en cuenta este punto ya que es necesario para referenciar los
ampliar)
//Método que arranca al ejecutar el formulario..

//El campo jtFecha debe estar deshabilitada
jtFecha.setEnabled(false);
//Un array de String con formatos de fecha y hora estándar.
String[] formato = {
"dd MMMMM yyyy",
"dd.MM.yy",
"MM/dd/yy",
"yyyy.MM.dd G 'en' hh:mm:ss z",
"EEE, MMM d, ''yy",
"h:mm a",
"H:mm:ss:SSS",
"K:mm a,z",
"yyyy.MMMMM.dd GGG hh:mm aaa"
};
//Iteramos el array de String y agregaremos cada item al jComboBox.
for (int i = 0; i < formato.length; i++) {
String string = formato[i];
}
}
//Método para manejar nuestros formatos de fechas y horas.
private void fomatoFecha(){
//try - catch para controlar las excepciones
try {
//Instanciamos el objeto Date del que obtendremos la fecha y hora del sistema.
Date hoy = new Date();
String f = jComboBox1.getSelectedItem().toString();
//Creamo un SimpleDateFormat y le pasamos como argumento el formato que elijamos del jComboBox
SimpleDateFormat sdf = new SimpleDateFormat(f);
//Obtenemos los datos de fecha y hora con el formato especificado
String fecha = sdf.format(hoy);
//Cargamos esos datos al campo designado.
jtFecha.setText(fecha);
} catch (IllegalArgumentException iae) {
jtFecha.setForeground(Color.red);
jtFecha.setText("Error: " + iae.getMessage());
}
El paso siguiente es establece un evento para nuestro JComboBox, esto le dará la funcionalidad que necesitamos. El evento que normalmente se utiliza para este tipo de
elementos es el ActionPerformed. En la imagen más abajo se ve como es la implementación y seguido el código para los eventos. Si ya vieron alguna guía anterior a esta,
podrán saber la ubicación habitual tanto para la lista de eventos como también los métodos que hayamos creado.
//Se llama al método fomatoFecha(), que hace todo el trabajo.
fomatoFecha();
}
Uso básico de elementos Swing con NetBeans – 06 – Uso básico de JOptionPane con eventos. Ej. 01.
En esta ocasión veremos uno de los elemento del JOptionPane, el showMessageDialog, la cual se utiliza normalmente para comunicar al usuario una información, error o
advertencia, hay diferentes formas en la que se puede presentar este elemento, veremos algunas en una aplicación de ejemplo.
imágenes para botones es recomendable “png” con una dimensión 32x32 para los demás usos es a criterio de cada uno. La imagen que utilizamos en este caso es de
tamaño 32x32, la cual se mostrará como icono personalizado para uno de nuestros showMessageDialog.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario UsoJOptionPane). Para ejemplificar el uso de los showMessageDialog vamos a crear una aplicación
que utilizar varios JRadioButton (cuya utilización básica vimos en guías anteriores) en donde cada opción nos presentará un ejemplo, para lanzar el showMessageDialog
especificado marcamos la opción y presionamos el botón “Ver Ejemplo”. En la imagen siguiente vemos el diseño de nuestro formulario, cada elemento tiene un nombre de
variable como se especifica en la imagen, tomar en cuenta este punto ya que es necesario para referenciar los objetos. Se puede cambiar el “Nombre de variable” de cada
objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. (clic sobre la imagen para ampliar)

//Agrupamos nuestros JRadioButton creados.
group.add(jRB1);
group.add(jRB2);
group.add(jRB3);
group.add(jRB4);
group.add(jRB5);
//Incicamos que jRB1 este seleccionado de arranque.
jRB1.setSelected(true);
//Indicamos un valor para nuestra variable de clase tipo ImageIcon
img = createImageIcon("/com/swing/basic/img/help.png");
}
//Método para crear ImageIcon pasando una url.
//UsoJOptionPane es el nombre de la clase de nuestro jFrame.
java.net.URL imgURL = UsoJOptionPane.class.getResource(path);
} else {
return null;
}
}
//Según que opción se indique, se mostrará un tipo de diálogo....

private void ver(){
if(jRB1.isSelected()){
JOptionPane.showMessageDialog(null, "Titulo por defecto con icono por defecto…");
}
else if(jRB2.isSelected()){
JOptionPane.showMessageDialog(null, "Titulo personalizado, icono de
advertencia...","Advertencia",JOptionPane.WARNING_MESSAGE);
}
JOptionPane.showMessageDialog(null, "Titulo personalizado, icono de
error...","Advertencia",JOptionPane.ERROR_MESSAGE);
}
JOptionPane.showMessageDialog(null, "Titulo personalizado, sin icono...","Mensaje",JOptionPane.PLAIN_MESSAGE);
}
JOptionPane.showMessageDialog(null, "Titulo personalizado, icono
pesonalizado...","Advertencia",JOptionPane.INFORMATION_MESSAGE,img);
}
}
El paso siguiente es establece un evento para nuestro botón “Ver Ejemplo”, esto le dará la funcionalidad que necesitamos. El evento que normalmente se utiliza para este
tipo de elementos es el ActionPerformed. Si ya vieron alguna guía anterior a esta, podrán saber la ubicación habitual tanto para la lista de eventos, como también los
métodos que hayamos creado al igual de la forma en que se implementan estos eventos y llamadas a métodos.

ver();
}
En esta guía veremos otro de los elemento del JOptionPane, el showOptionDialog, tiene la función de mostrar una lista de opciones, normalmente la elección entre “Sí” “No”,
“Aceptar” “Cancelar” u otras parecidas. En este caso veremos una lista de opciones personalizadas.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario UsoJOptionPane2). La aplicación consiste en un botón que al presionar debe ejecutar un
showOptionDialog, con la lista de opciones de la cual seleccionaremos una, cuya selección se reflejará en un cuadro de texto. En la imagen siguiente vemos el diseño de
nuestro formulario, cada elemento tiene un nombre de variable como se especifica en la imagen, tomar en cuenta este punto ya que es necesario para referenciar los
ampliar)
Creamos nuestro único método en modo fuente. Los métodos creados por nosotros las ubicamos al final de la declaración de variables, justo antes de la llave de cierre
//Método que se ejecutará al precionar nuestro boton "btn"
private void opcionDialogo(){
//Array de objetos para nuestras opciones personalizadas.
Object[] obj = {
"Tierra",
"Marte",
"Venus"};
//Se otendrá el valor tipo entero que retorne nuestra selección.
//si son tres valores, van desde el "0" cero. [0,1,2] según el orden.
//Los parámetros son los siguientes, según la documentación.
//showOptionDialog(Component parentComponent, Object message, String title, int optionType, int messageType, Icon
icon, Object[] options, Object initialValue)
opt = JOptionPane.showOptionDialog(null, "¿De qué planeta eres?", "Pregunta...",
JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE,
null, obj, obj[0]);
//Dependiendo del valor obtenido se mostrará un texto en nuesto JTextField
if(opt >= 0){
if(opt == 0){
rp.setText("Soy de la Tierra");
}
else if(opt == 1){
rp.setText("Soy de Marte");
}
else if(opt == 2){
rp.setText("Soy de Venus");
}
}
}
El paso siguiente es establece un evento para nuestro único botón, esto le dará la funcionalidad que necesitamos. El evento que normalmente se utiliza para este tipo de
elementos es el ActionPerformed. Si ya vieron alguna guía anterior a esta, podrán saber la ubicación habitual tanto para la lista de eventos, como también los métodos que
hayamos creado al igual de la forma en que se implementan estos eventos y llamadas a métodos.
private void btnActionPerformed(java.awt.event.ActionEvent evt) {

opcionDialogo();
}
En esta guía veremos otro de los elemento del JOptionPane, el showOptionDialog, tiene la función de mostrar una lista de opciones, normalmente la elección entre “Sí” “No”,
“Aceptar” “Cancelar” u otras parecidas. El ejemplo que veremos nos muestra tres formas diferentes en que podemos configurar nuestro showOptionDialog.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario UsoJOptionPane3). En el ejemplo utilizaremos una lista seleccionable de forma individual utilizando
JRadioButton, un botón personalizado para ejecutar nuestra selección y un campo de texto JTextField que reflejará nuestra selección. Dependiendo de nuestra selección se
ejecutará un modelo de showOptionDialog, cada modelo tiene su utilidad en diferentes situaciones. En la imagen siguiente vemos el diseño de nuestro formulario, cada
elemento tiene un nombre de variable como se especifica en la imagen, tomar en cuenta este punto ya que es necesario para referenciar los objetos. Se puede cambiar el
“Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. (clic sobre la imagen para ampliar)

group.add(jRB1);
group.add(jRB2);
group.add(jRB3);
//Indicamos un valor para nuestra variable de clase tipo ImageIcon
img = createImageIcon("/com/swing/basic/img/usergroup.png");
}
//Método para crear ImageIcon pasando una url.
//UsoJOptionPane es el nombre de la clase de nuestro jFrame.
java.net.URL imgURL = UsoJOptionPane3.class.getResource(path);
} else {
return null;
}
}
//Método que se ejecutará al precionar nuestro botón

private void ver(){
//Dependiendo que JRadioButton este marcado se ejecutará uno de los "if"
//La selección que se haga devuelve un entero.
//La guardamos en nuestra variable de clase creado "n"
//Si cerramos si elegir devuelve -1, si seleccionamos el primer elemento devuelve 0, siguiente 1;
n = JOptionPane.showConfirmDialog(
null,
"¿Te gusta el planeta marte?",
"Pregunta",
if(n == 0){
rp.setText("Sí, me gusta el planeta marte.");
}
else if (n == 1){
rp.setText("No, no me gusta el planeta marte.");
}
}
//Opciones personalizadas
Object[] opt = {"Sí, me gusta...",
"No, para nada...","No se responder..."};
n = JOptionPane.showOptionDialog(null,
"¿Te gusta el planeta marte?",
"Pregunta",
JOptionPane.YES_NO_OPTION,
JOptionPane.QUESTION_MESSAGE,
null,
opt,
opt[0]);
//Como hay tres opciones, el valor devuelte puede ser 0, 1 o 2.
if(n == 0){
rp.setText("Sí, me gusta el planeta marte.");
}
else if (n == 1){
rp.setText("No, no me gusta el planeta marte.");
}
else if (n == 2){
rp.setText("No se que responder...");
}
}
Object[] opt = {"Sí, me agradan...",
"No, para nada..."};
n = JOptionPane.showOptionDialog(null,
"¿Te agradan los terrícolas?",
"Pregunta",
JOptionPane.YES_NO_OPTION,
JOptionPane.QUESTION_MESSAGE,
img,//Icono personalizado
opt,//Opcion personalizada
opt[0]);
if(n == 0){
rp.setText("Sí, me agradan los terrícolas.");
}
else if (n == 1) {
rp.setText("No, no me agradan los terricolas.");
}
}
}
Antes de continuar veremos que método se llama desde el constructor y las importaciones necesarias.
El paso siguiente es establece un evento para nuestro botón, esto le dará la funcionalidad que necesitamos. El evento que normalmente se utiliza para este tipo de

ver();
}
archivo fuente y presionar “ejecutar archivo” ya que nuestro proyecto no tiene una clase principal definida) (clic sobre la imagen para ampliar)
Otro elemento del JOptionPane es el showInputDialog, la cual permitirá al usuario ingresar datos o seleccionarla de una lista de opciones, dependiendo del caso. Hay dos
tipos principales, la primera que nos permite crear un “Array” de objetos, la cual contendrá las opciones que el usuario podrá seleccionar, estos elementos estarán dentro de
un combo. La otra solamente muestra un campo de texto en el que el usuario podrá ingresar texto.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario UsoJOptionPane4). En el ejemplo utilizaremos una lista seleccionable de forma individual utilizando
JRadioButton, un botón personalizado para ejecutar nuestra selección y un campo de texto JTextField que reflejará nuestra selección. Dependiendo de nuestra selección se
ejecutará un modelo de showInputDialog, cada modelo tiene su utilidad en diferentes situaciones. En la imagen siguiente vemos el diseño de nuestro formulario, cada
elemento tiene un nombre de variable como se especifica en la imagen, tomar en cuenta este punto ya que es necesario para referenciar los objetos. Se puede cambiar el
“Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. (clic sobre la imagen para ampliar)
Creamos los métodos necesarios en modo fuente. Los métodos creados por nosotros las ubicamos al final de la declaración de variables, justo antes de la llave de cierre

group.add(jRB1);
group.add(jRB2);
}
private void ver(){

//Comprobamos cuál de las opciones esta seleccionada.
//Creamos un Array de objetos para nuestras opciones.
Object[] opt = {"Mercurio", "Venus", "Tierra","Marte","Jupiter"};
//El showInputDialog nos retornará un String.
//Utilizamos nuestra variable de clase creada "String n".
//Esta variable se crea fuera del constructor y cualquier método.
s = (String)JOptionPane.showInputDialog(
null,
"¿De qué planeta eres?",
"Pregunta",
JOptionPane.PLAIN_MESSAGE,
null,
opt,
"Tierra");
//Comprobamos que se seleccionen datos...

if ((s != null) && (s.length() > 0)) {
//Obtenemos el valor de nuestro showInputDialog
rp.setText("Soy del planeta " + s);
}
}
s = (String)JOptionPane.showInputDialog(
null,
"¿De qué planeta eres?",
"Pregunta",
JOptionPane.PLAIN_MESSAGE
);
//Comprobamos que se escriban datos...

if ((s != null) && (s.length() > 0)) {
rp.setText("Soy del planeta " + s);
}
}
Antes de continuar veremos que método se llama desde el constructor, variables de clase creadas y las importaciones necesarias.
El paso siguiente es establece un evento para nuestro botón, esto le dará la funcionalidad que necesitamos. El evento que normalmente se utiliza para este tipo de

ver();
}
Uso básico de elementos Swing con NetBeans – 10 – Uso básico de JTextArea y JPanel. Ej. 01.
En esta guía veremos la utilización del “JTextArea” o área de texto como queramos llamarla, su función es simple, mostrar o permitir la edición de texto largo. En este
ejemplo agregamos un texto desde código; le especificamos tipo de letra, formato y tamaño. También indicamos que el Área de Texto ajuste el texto ingresado de forma
automática a su tamaño. El JPanel sirve como contenedor de objetos que tienen su propia distribución lo cual permite una gran independencia; en guías anteriores vimos
varios ejemplos de su uso.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario UsoJTextArea). Como se ve en la imagen, agregamos un JPanel al cual le especificamos un borde
con texto, esto se consigue modificando la propiedad “border” e indicando que sea “Borde con título”; dentro del JPanel agregamos nuestro JTextArea . En la imagen
siguiente vemos el diseño de nuestro formulario, cada elemento tiene un nombre de variable como se especifica en la imagen, tomar en cuenta este punto ya que es
necesario para referenciar los objetos. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de
variable…”. (clic sobre la imagen para ampliar)
En este proyecto creamos un único método, el cual se llama desde el constructor para que se ejecute al crearse el formulario, no utilizamos eventos.

//-Establecemos propiedades para el JTextArea-
//Establecemos tipo de fuente Consolas, texto plano, tamaño 15
jt.setFont(new Font("Consolas", Font.PLAIN, 15));
//Especificamos que el texto se ajusta al tamaño del Área de texto
jt.setLineWrap(true);
jt.setWrapStyleWord(true);
//Agregamos texto simple al Área de Texto como ejemplo.
//El indicador \n sirve para salto de línea.
jt.setText("Java Development Kit o (JDK), es un "
+ "software que provee herramientas de desarrollo "
+ "para la creación de programas en Java. "
+ "\nNetBeans IDE. Es un entorno de desarrollo integrado libre, "
+ "hecho principalmente para el lenguaje de programación Java.");
}
En la imagen siguiente vemos las importaciones que necesitamos, nuestro paquete si la utilizamos y el método que llámanos desde el constructor.
Uso básico de elementos Swing con NetBeans – 11 – Uso básico de JEditorPane y JPanel, visualizar
documento HTML.
En esta oportunidad veremos el uso que se le puede dar a un “JEditorPane”, precisamente la utilizaremos para abrir un documento HTML. Es un elemento útil para la
apertura de documentos en texto plano o del tipo HTML. El ejemplo es sencillo, agregaremos nuestro “JEditorPane” dentro de un panel junto con dos botones, al apretar
cada botón se podrá visualizar un ejemplo de documento HTML. Los documentos HTML deberán estar dentro del mismo paquete que nuestro formulario.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario UsoJEditorPane). Como se ve en la imagen, agregamos un JPanel al cual le especificamos un borde
con texto, esto se consigue modificando la propiedad “border” e indicando que sea “Borde con título”; dentro del JPanel agregamos nuestro JEditorPane. En la imagen
En este caso creamos dos métodos similares, cada una se relacionará con un documento HTML distinto. Se agregan comentario para conocer el funcionamiento de cada
línea de código.

//jep es el nombre de variable de nuesto JEditorPane.
//indicamos que no sea editable.
jep.setEditable(false);
//Utilizamos el método siguiente para referenciar nuestro HTML
//Para ejemplo se puede usar cualquier documento HTML, tomar en cuenta el nombre.
java.net.URL urlHtm = UsoJEditorPane.class.getResource("Welcome.html");
//Se ejecuta si no se retorna vacio.
if (urlHtm != null){
//Control de posibles errores de lectura.
try {
//Método para cargar el documento HTML al JEditorPane
jep.setPage(urlHtm);
System.err.println("No se puede leer la URL: " + urlHtm + e);
}
}
//Se ejecuta en caso que retorne vacio.
else{
JOptionPane.showMessageDialog(null, "No se pudo cargar la url...");
}
}
//Método similar a la anterior, solo varia el nombre del documento HTML
private void inicioDos(){
jep.setEditable(false);
java.net.URL urlHtm = UsoJEditorPane.class.getResource("bookmarks.html");
if (urlHtm != null){
try {
jep.setPage(urlHtm);
System.err.println("No se puede leer la URL: " + urlHtm + e);
}
}
else{
JOptionPane.showMessageDialog(null, "No se pudo cargar la url...");
}
El paso siguiente es establece eventos para los botones, esto les dará la funcionalidad que necesitamos. El evento que normalmente se utiliza para este tipo de elementos
es el ActionPerformed. Si ya vieron alguna guía anterior a esta podrán saber cómo se agrega un evento, la ubicación habitual tanto para la lista de eventos, como también
los métodos que hayamos creado al igual de la forma en que se implementan estos eventos y llamadas a métodos.
inicio();
}

inicioDos();
}
Uso básico de elementos Swing con NetBeans – 12 – Uso básico de JTextPane y JPanel, visualizar
texto con estilo y objetos.
En esta guía podremos ver la utilización de “JTextPane” o Panel de Texto. Este es un componente al cual se le puede aplicar estilos de texto además de agregar otros
componentes como botones o imágenes como ya veremos.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario UsoJTextPane). Como se ve en la imagen, agregamos un JPanel al cual le especificamos un borde
con texto, esto se consigue modificando la propiedad “border” e indicando que sea “Borde con título”; dentro del JPanel agregamos nuestro JTextPane. En la imagen
Para este proyecto creamos tres métodos específicos, la primera que arrancará al crear el formulario y pondrá en marcha los demás métodos, el segundo maneja los estilos
que utilizaremos y el último se utilizar para cargar imágenes desde archivos.
//Método que se ejecuta al crear el formulario

//Array de String para muestras de estilo.
String[] textos = {"Codigo Java - (Texto Normal)." + "\n",
"Utilizando Swing - (Texto Cursiva)." + "\n",
"Programando con Java - (Texto Negrita)" + "\n",
"Utilizando JTextPane - (Texto pequeño)" + "\n",
"Utilizando Style. (Texto grande)" + "\n",
"JTextPane con soporte para insertar objetos." + "\n",
" " + "\n",
"Soporte insertar iconos." + "\n",
" " + "\n",
"JTextPane permite utilizar StyledEditorKit y StyledDocument, " +
"también interactua con diferentes objetos."
};
//Array de String para el nombre de cada estilo "Style"
String[] iniText = {
"normal","cursiva","negrita","peque","grande","boton","normal","icono","normal","normal"
};
//Cramos una variable tipo StyledDocument que manejara los estilos.
StyledDocument sd = jtp.getStyledDocument();
//Método que se crea más abajo, le pasamos como argumento nuestro StyledDocument.
styleDoc(sd);
//Control de errores
try {
//Método insertString(int offset, String str, AttributeSet a)
//Primer argumento - Posición de inserción. Segundo - String que se va insertar.
//Atributo asociado al String ingresado. En este caso los estilos.
for (int i = 0; i < iniText.length; i++) {
sd.insertString(sd.getLength(), textos[i], sd.getStyle(iniText[i]));
}
System.err.println("error " + e);
}
}
//Inicialización de los diferentes estilos a utilizar.
//Hay diferentes propiedades, pero fáciles de entender.
private void styleDoc(StyledDocument sd){
Style def = StyleContext.getDefaultStyleContext().
getStyle(StyleContext.DEFAULT_STYLE);
Style nm = sd.addStyle("normal", def);

StyleConstants.setFontFamily(def, "SansSerif");
Style s = sd.addStyle("cursiva", nm);

StyleConstants.setItalic(s, true);
s = sd.addStyle("negrita", nm);
StyleConstants.setBold(s, true);
s = sd.addStyle("peque", nm);
StyleConstants.setFontSize(s, 10);
s = sd.addStyle("grande", nm);
StyleConstants.setFontSize(s, 16);
s = sd.addStyle("icono", nm);
//Tomar en cuentra la imagen que utilizaremos y su ubicación
StyleConstants.setAlignment(s, StyleConstants.ALIGN_CENTER);
ImageIcon compu = createImageIcon("/com/swing/basic/img/Computer.png",
"Icono PNG - Coputadora");
if (compu != null) {
StyleConstants.setIcon(s, compu);
}
//Icono para nuestro botón
s = sd.addStyle("boton", nm);
StyleConstants.setAlignment(s, StyleConstants.ALIGN_CENTER);
ImageIcon searchIcon = createImageIcon("/com/swing/basic/img/Search.png",
"Icono de búsqueda");
JButton button = new JButton("Buscar");
if (searchIcon != null) {
button.setIcon(searchIcon);
} else {
button.setText("Search");
}
button.setCursor(Cursor.getDefaultCursor());
button.setMargin(new Insets(0,0,0,0));
StyleConstants.setComponent(s, button);
}
protected static ImageIcon createImageIcon(String path,String des) {
} else {
return null;
}
}
Lista de Importaciones.
import java.awt.Cursor;
import java.awt.Insets;
import javax.swing.JButton;
import javax.swing.text.Style;//Importaciones necesarias
import javax.swing.text.StyleConstants;
import javax.swing.text.StyleContext;
import javax.swing.text.StyledDocument;
En este caso no utilizaremos eventos, por tanto ya podremos ejecutar el formulario creado. (Por si hay alguna duda en el proceso, debemos hacer clic derecho sobre nuestro
Uso básico de elementos Swing con NetBeans – 13 – Uso básico de JFileChooser, diálogo de apertura
y guardado.
En esta ocasión veremos el manejo básico que se le puede dar a un JFileChooser. Este componente nos permite acceder a una pantalla, la cual según la configuración que
le demos, podremos obtener acceso a las opciones de apertura y guardo de contenidos en nuestra pc. Para esta guía podremos configurar un JFileChooser para obtener
acceso a las carpetas y archivos de nuestro computador, en caso de apertura podremos obtener el nombre del archivo y decir si optamos por abrirla o cancelar la operación;
al igual podremos acceder a la pantalla de guardado y obtener el nombre que le damos al archivo o si cancelamos la operación. Cada resultado iremos almacenando en un
JTextArea, la cual servirá como log del programa.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario UsoJFileChooser). Para el diseño utilizamos dos botones de comando (el icono para cada botón la
obtenemos de nuestra carpeta de imágenes, como vimos en los primeros tutoriales de la serie), cada una lanzará un tipo de dialogo, debajo de los botones tenemos nuestro
área de texto que almacenará los resultados de cada operación. En la imagen siguiente vemos el diseño de nuestro formulario, cada elemento tiene un nombre de variable
como se especifica en la imagen, tomar en cuenta este punto ya que es necesario para referenciar los objetos. Se puede cambiar el “Nombre de variable” de cada objeto
haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. (clic sobre la imagen para ampliar)
Para este proyecto creamos tres métodos específicos, la primera que arrancará al crearse el formulario, el segundo se encargará de manejar la apertura de archivos y la
última para mostrar la pantalla de guardado.

//Método que llamaremos desde el constructor del JFrame.
//Especificamos algunas propiedades de nuestro JTextArea.
//Opción no editable.
jt.setEditable(false);
//Color de fondo.
jt.setBackground(Color.GRAY);
//Color de texto
jt.setForeground(Color.GREEN);
}
private void open(){
//Método para apertura de archivo.
//Creamos un objeto JFileChooser
JFileChooser jf = new JFileChooser();
//showOpenDialog para JFileChooser de apertura.
//Guardamos el valor en un entero, pues es lo que retorna.
int rs = jf.showOpenDialog(this);
//Comprabamos el retorno como vemos más abajo.
if(rs == JFileChooser.APPROVE_OPTION){
//Creamos una variable tipo File para obtener el archivo seleccionado.
File fl = jf.getSelectedFile();
//Agregamos una línea de texto a nuestro JTextArea para indicar la acción realizada.
jt.append("Se ha abierto el archivo con nombre: " + fl.getName() + "\n" );
}
//Si retorna diferente a APPROVE_OPTION.
else{
jt.append("Operación cancelada..." + "\n" );
}
}
private void save(){
//Método para guardar archivo.
//showSaveDialog para ventana de guardado.
int rs = jf.showSaveDialog(this);
//El procedimiento es igual al método de open()
jt.append("Se ha guardado un archivo con nombre: " + fl.getName() + "\n" );
}
else{
}
}
import java.awt.Color;
import java.io.File;//Importaciones necesarias
Para cada botón utilizaremos el evento “ActionPerformed”, en guías anteriores de esta serie vimos como se implementan los eventos. Seguido los eventos.
private void abrirActionPerformed(java.awt.event.ActionEvent evt) {

open();
}
private void guardarActionPerformed(java.awt.event.ActionEvent evt) {

save();
}
Llegado a esta parte podremos ejecutar nuestro formulario. (Por si hay alguna duda en el proceso, debemos hacer clic derecho sobre nuestro archivo fuente y presionar
“ejecutar archivo” ya que nuestro proyecto no tiene una clase principal definida)
con filtro de imagen y vista previa.
Segundo ejemplo de la utilización del JFileChooser, en esta ocasión a diferencia de la anterior le agregamos un filtro de imágenes y la posibilidad de obtener una vista previa
de la imagen antes de abrirla, esto con solo seleccionarla. El ejemplo utiliza dos clases preestablecidas, que están disponibles en la página oficial de java, las clases son:
“Utils” e “ImagePreview”, ambas clases deben estar en el mismo paquete que nuestro JFrame. El ejemplo es sencillo a diferencia de las clases que se implementan.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario UsoJFileChooser2). Para el diseño utilizamos un botón de comando (el icono para nuestro botón la
obtenemos de nuestra carpeta de imágenes, como vimos en los primeros tutoriales de la serie), el botón lanzará en método que crea el JFileChooser junto con las
implementaciones, debajo del botón tenemos nuestro área de texto que almacenará los resultados de cada operación. En la imagen siguiente vemos el diseño de nuestro
formulario, cada elemento tiene un nombre de variable como se especifica en la imagen, tomar en cuenta este punto ya que es necesario para referenciar los objetos. Se
puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. (clic sobre la imagen para ampliar)
Estas clases servirán de soporte para establecer un filtro de imágenes y la posibilidad de tener una vista previa de esas imágenes.
Clase Utils. Tomar en cuenta el paquete en donde se almacena la clase.
package com.swing.basic;
/**
* Clase disponible en la página de JAVA Oracle.
* Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
*/
class Utils {
public final static String jpeg = "jpeg";
public final static String jpg = "jpg";
public final static String gif = "gif";
public final static String tiff = "tiff";
public final static String tif = "tif";
public final static String png = "png";
/*
* Método para obtener la extensión de cada archivo desde nuestro JFileChooser .
*/
public static String getExtension(File f) {
String ext = null;
String s = f.getName();
int i = s.lastIndexOf('.');
if (i > 0 && i < s.length() - 1) {

ext = s.substring(i+1).toLowerCase();
}
return ext;
}
//Método para obtener una imagen desde una URL.

java.net.URL imgURL = Utils.class.getResource(path);
} else {
System.err.println("Couldn't find file: " + path);
return null;
}
}
Clase ImagePreview. Tomar en cuenta el paquete en donde se almacena la clase.
/**
* Clase disponible en la página de Java Oracle
* Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
*/
import javax.swing.*;
import java.beans.*;
import java.awt.*;
//Vista previa de la imagen seleccionada desde nuestro JFileChooser.

public class ImagePreview extends JComponent implements PropertyChangeListener {
ImageIcon thumbnail = null;
File file = null;
public ImagePreview(JFileChooser fc) {

setPreferredSize(new Dimension(100, 50));
fc.addPropertyChangeListener(this);
}
public void loadImage() {

if (file == null) {
thumbnail = null;
return;
}
//Método para obtener la imagen desde la URL
ImageIcon tmpIcon = new ImageIcon(file.getPath());
if (tmpIcon != null) {
//Mostramos la imagen en un tamaño tipo vista previa.
//Si la imagen es grande la disminuimos hasta lograr un thumbnail.
if (tmpIcon.getIconWidth() > 90) {
thumbnail = new ImageIcon(tmpIcon.getImage().
getScaledInstance(90, -1,
Image.SCALE_DEFAULT));
}
//No se ejecuta el proceso si la imagen es pequeña.
else {
thumbnail = tmpIcon;
}
}
}
//Método predeterminado, para manejar los thumbnail.

@Override
public void propertyChange(PropertyChangeEvent e) {
boolean update = false;
String prop = e.getPropertyName();
if (JFileChooser.DIRECTORY_CHANGED_PROPERTY.equals(prop)) {
file = null;
update = true;
} else if (JFileChooser.SELECTED_FILE_CHANGED_PROPERTY.equals(prop)) {
file = (File) e.getNewValue();
update = true;
}
if (update) {
thumbnail = null;
if (isShowing()) {
loadImage();
repaint();
}
}
}
//Método para dibujar los thumbnail.

@Override
protected void paintComponent(Graphics g) {
if (thumbnail == null) {
loadImage();
}
if (thumbnail != null) {
int x = getWidth()/2 - thumbnail.getIconWidth()/2;
int y = getHeight()/2 - thumbnail.getIconHeight()/2;
if (y < 0) {
y = 0;
}
if (x < 5) {
x = 5;
}
thumbnail.paintIcon(this, g, x, y);
}
}
}
Para el proyecto tenemos dos métodos, la primera se ejecuta al crearse el JFrame ya que se llama desde el constructor del mismo. El segundo no lanza nuestro
JFileChooser con sus implementaciones.

//Método que llamaremos desde el constructor del JFrame.
//Especificamos algunas propiedades de nuestro JTextArea.
//Opción no editable.
jt.setEditable(false);
//Color de fondo.
jt.setBackground(Color.GRAY);
//Color de texto
jt.setForeground(Color.GREEN);
}
private void abrir(){
//Método para apertura de archivo.
//Creamos un objeto JFileChooser
//Creamos un filtro de imágenes utilizando nuestra clase Utils
jf.addChoosableFileFilter(new FileFilter() {
//Los métos siguientes son implementaciones
@Override
public boolean accept(File f) {
if(f.isDirectory()){
return true;
}
String exts = Utils.getExtension(f);
if (exts != null) {
if (exts.equals(Utils.tiff) ||
exts.equals(Utils.tif) ||
exts.equals(Utils.gif) ||
exts.equals(Utils.jpeg) ||
exts.equals(Utils.jpg) ||
exts.equals(Utils.png)) {
return true;
}
else {
return false;
}
}
return false;
@Override
public String getDescription() {
return "Imágenes";
}
});
//Establecemos un accesorio que será nuestra vista previa.
jf.setAccessory(new ImagePreview(jf));
//showOpenDialog para JFileChooser de apertura.
//Guardamos el valor en un entero, pues es lo que retorna.
int rs = jf.showOpenDialog(this);
//Comprabamos el retorno como vemos más abajo.
//Creamos una variable tipo File para obtener el archivo seleccionado.
//Agregamos una línea de texto a nuestro JTextArea para indicar la acción realizada.
jt.append("Se ha abierto el archivo con nombre: " + fl.getName() + "\n" );
}
//Si retorna diferente a APPROVE_OPTION.
else{
}
}
import javax.swing.JFileChooser;//Importaciones necesarias
import javax.swing.filechooser.FileFilter;
Para los botones como siempre se utiliza el evento “ActionPerformed”, en guías anteriores de esta serie vimos como se implementan los eventos. Seguido el evento para
nuestro botón Abrir.
private void abrirActionPerformed(java.awt.event.ActionEvent evt) {

abrir();
}
con filtro de imagen simple y carga de imagen.
Tercer ejemplo del uso que se le puede dar a un JFileChooser, esta vez el filtro que utilizaremos es simple y eficientes, no requiere de implementación alguna. También
incluimos la posibilidad de abrir la imagen que se haya seleccionado.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario UsoJFileChooser3). Para el diseño utilizamos un botón de comando (el icono para nuestro botón la
obtenemos de nuestra carpeta de imágenes, como vimos en los primeros tutoriales de la serie), el botón lanzará el método que crea el JFileChooser dependiendo de cuál de
los JRadioButton esta seleccionado, debajo del botón y el panel de JRadioButton tenemos otro panel que almacena un JLabel, la cual podrá mostrar texto o imagen
dependiendo del caso. En la imagen siguiente vemos el diseño de nuestro formulario, cada elemento tiene un nombre de variable como se especifica en la imagen, tomar en
cuenta este punto ya que es necesario para referenciar los objetos. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en
“Cambiar nombre de variable…”. (clic sobre la imagen para ampliar)
Abajo los métodos que estaremos utilizado. Cada uno tiene una función específica, se agregan comentarios para facilitar la comprensión. El método “inicio()” se llama desde
el constructor del JFrame.

//Grupo de botones para que se seleccione un solo JRadioButton a la vez.
ButtonGroup br = new ButtonGroup();
br.add(rb1);
br.add(rb2);
br.add(rb3);
}
private void ver(){
//Dependiendo cual este marcada se ejecuta un grupo de codigos.
if(rb1.isSelected()){
//Se crea el JFileChooser
JFileChooser fl = new JFileChooser();
//Indicamos que muestre solo directorios.
fl.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
//Con showOpenDialog se lanza el JFileChooser, si es "Abrir" retorna 1 o -1 "Cancelar".
if(fl.showOpenDialog(null)==JFileChooser.APPROVE_OPTION){
//Obtenemos el nombre del directorio
String fil = fl.getCurrentDirectory().getName();
//Borramos el icono de nuestro JLabel
jlb.setIcon(null);
//Mostramos los datos dentro de JLabel
jlb.setText("Opcion de directorio seleccionado: " + fil);
}
}
else if(rb2.isSelected()){
//Indicamos que muestre tanto directorios como archivos.
fl.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
//Optenemos el nombre del directorio
String fil = fl.getCurrentDirectory().getName();
//Obtenemos el nombre del archivo que se haya seleccionado
String file = fl.getSelectedFile().getName();
jlb.setIcon(null);
//Mostramos en el JLabel tanto el nombre del directorio como el nombre del archivo
jlb.setText("Archivo o directorio: [Carpeta: " + fil + "] [Archivo: " + file + "]");
}
}
else if(rb3.isSelected()){
//Indicamos que muestre tanto directorios como archivos.
fl.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
//Creamos un filtro simple de formatos.
fl.setFileFilter(new FileNameExtensionFilter("Archivo de Imagen","jpg","png"));
//Obtenemos el archivo seleccionado
File file = fl.getSelectedFile();
jlb.setText(null);
//Mostramos la imagen en nuestro JLabel.
//El método imgIcon() nos localiza el archivo y retorna como imagen.
jlb.setIcon(imgIcon(file));
}
}
}
//Método para retornar la imagen pasándole como parámetro un archivo.
private ImageIcon imgIcon( File fichero ){
ImageIcon imageIcon = new ImageIcon( fichero.getAbsolutePath() );
return imageIcon;
}
import javax.swing.ButtonGroup;
import javax.swing.ImageIcon;//Importaciones necesarias.
Para los botones como siempre se utiliza el evento “ActionPerformed”, en guías anteriores de esta serie vimos como se implementan los eventos. Seguido el evento
individual necesario.
private void verActionPerformed(java.awt.event.ActionEvent evt) {

ver();
}
Uso básico de elementos Swing con NetBeans – 17 – Uso de LookAndFeel con JFrame e icono
personalizado para formulario.
En esta guía veremos la forma de modificar de manera fácil el aspecto de nuestro formulario utilizando LookAndFeel, también le asignaremos un icono personalizado.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario UsoJFrame). Utilizamos tres botones de comando para poder aplicar cada uno de los LookAndFeel,
solo se mencionan tres, las más habituales, hay muchas más. También agregamos un botón de comando con la cual podremos salir del formulario sin utilizar el modo
habitual. En la imagen siguiente vemos el diseño de nuestro formulario, cada elemento tiene un nombre de variable como se especifica en la imagen, tomar en cuenta este
punto ya que es necesario para referenciar los objetos. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar
nombre de variable…”. (clic sobre la imagen para ampliar)
Antes de continuar vemos que importaciones debemos de tener para utilizar ciertos elementos en nuestro formulario.
import javax.swing.SwingUtilities;
Códigos utilizados en el constructor.
//Centrar formulario
setLocationRelativeTo(null);
//Especificar un icono para nuestro formulario
setIconImage(new ImageIcon(ClassLoader.getSystemResource("com/swing/basic/img/Login.png")).getImage());
//Título para el formulario
setTitle("Uso de JFrame.");
En esta guía los códigos se ejecutarán desde el evento asignado a cada botón sin crea métodos. Para los botones como siempre se utiliza el evento “ActionPerformed”, en
guías anteriores de esta serie vimos como se implementan los eventos. Seguido los eventos con la explicación de las líneas de código.
private void jWinActionPerformed(java.awt.event.ActionEvent evt) {

//Se requiere try-catch, es predeterminado
try {
//Forma de localizar el LookAndFeel
for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) {
//Entre comillas ("Windows") el nombre del LookAndFeel
if ("Windows".equals(info.getName())) {
//Asignamos el LookAndFeel
javax.swing.UIManager.setLookAndFeel(info.getClassName());
//Recargamos la el formulario para que se vea el cambio
SwingUtilities.updateComponentTreeUI(this);
//Se reagrupan los componentes
this.pack();
//Se sale del bucle for
break;
}
}
} catch (ClassNotFoundException ex) {
java.util.logging.Logger.getLogger(UsoJFrame.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
} catch (InstantiationException ex) {
} catch (IllegalAccessException ex) {
} catch (javax.swing.UnsupportedLookAndFeelException ex) {
}
}
private void jNimActionPerformed(java.awt.event.ActionEvent evt) {

try {
if ("Nimbus".equals(info.getName())) {
this.pack();
break;
}
}
}
}
private void jMetActionPerformed(java.awt.event.ActionEvent evt) {

try {
if ("Metal".equals(info.getName())) {
this.pack();
break;
}
}
}
}
private void cerrarActionPerformed(java.awt.event.ActionEvent evt) {

System.exit(0);
}
Uso básico de elementos Swing con NetBeans – 18 – Uso de JInternalFrame.
En esta ocasión veremos la utilidad que se le puede dar a un JInternalFrame. Crearemos un formulario JFrame la cual podrá contener a la vez múltiples formularios internos
utilizando una clase preestablecida que extiende a JInternalFrame. Esta es una de las tantas formas en que se puede organizar una aplicación de escritorio.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario JInternalFrame). Utilizamos una barra de menú simple para poder ejecutar el método que crea el
Formulario interno. En la imagen siguiente vemos el diseño de nuestro formulario, cada elemento tiene un nombre de variable como se especifica en la imagen, tomar en
A continuación debemos de crear una clase externa la cual será la plantilla de nuestro formulario interno. Si no está en el mismo paquete que nuestro formulario debemos de
importarla.
import javax.swing.JInternalFrame;
//Clase disponible en oracle.com

public class MyInternalFrame extends JInternalFrame {
//Cuenta la cantidad de JInternalFrame
static int openFrameCount = 0;
//Marca la posición "x" e "y"
static final int xOffset = 30, yOffset = 30;
//Contructor para el JInternalFrame

public MyInternalFrame() {
/*Parámetros public JInternalFrame(String title, boolean resizable, boolean closable,
boolean maximizable, boolean iconifiable)
*/
super("Documento. Frame " + (++openFrameCount),
true, //resizable
true, //closable
true, //maximizable
true);//iconifiable
//Tamaño asiganado
setSize(300,300);
//Localización en la pantalla.
setLocation(xOffset*openFrameCount, yOffset*openFrameCount);
}
}
Método único necesario.
protected void frameUno(){

//Utilizamos nuestra clase MyInternalFrame creado
MyInternalFrame frame = new MyInternalFrame();
frame.setVisible(true);
//Se agrega al contenedor
desktop.add(frame);
try {
//Seleccionable
frame.setSelected(true);
} catch (java.beans.PropertyVetoException e) {
}
}
Lista de las importaciones que debemos de tener para utilizar ciertos elementos en nuestro formulario. También el código que debe contener el constructor del JFrame.
Lista de Importaciones. El
import com.app.MyInternalFrame;
depende en que paquete este la clase. Tomar en cuenta.
import com.app.MyInternalFrame;
import java.awt.Dimension;
import java.awt.Toolkit;
import javax.swing.JDesktopPane;
Códigos utilizados en el constructor.
public JInternalFrame() {
initComponents();
setLocationRelativeTo(null);//Centrar el formulario
setTitle("Uso de JInternalFrame.");
int inset = 80;
//Dimensión del JFrame
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
//parámetros setBounds(int x, int y, int width, int height)
setBounds(inset, inset,
screenSize.width - inset*2,
screenSize.height - inset*2);
//JDesktopPane será el contenedor del JInternalFrame
desktop = new JDesktopPane();
//Al ejecutar el formulario se crea el primer JInternalFrame ejecutando el
//método que la crea
frameUno();
//Agregamos desktop al JFrame
setContentPane(desktop);
//Posibilita mover el JInternalFrame en la pantalla
desktop.setDragMode(JDesktopPane.OUTLINE_DRAG_MODE);
}
JDesktopPane desktop;//Variable de clase
Para el menú utilizaremos el evento “ActionPerformed”, en guías anteriores de esta serie vimos como se implementan los eventos. Seguido el evento que llama a nuestro
método.

frameUno();
}
Llegado a esta parte podremos ejecutar nuestro formulario. Como se ve en la imagen, es posible tener multitud de formulario dentro del JFrame, cada uno con sus propiedades
específicas. (Por si hay alguna duda en el proceso, debemos hacer clic derecho sobre nuestro archivo fuente y presionar “ejecutar archivo” ya que nuestro proyecto no tiene
una clase principal definida) (clic sobre la imagen para ampliar)
Uso básico de elementos Swing con NetBeans – 19 – Uso de JLabel.

JLabel es uno de los elementos más simples en modo diseño, se utiliza en múltiples formas, como etiqueta, para mostrar imágenes, iconos, texto simple, etc. En esta ocasión
veremos algunas propiedades básicas de este elemento.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario UsoJLabel). Le agregamos un JPanel al JFrame para tener un poco más organizado y delimitado los
elementos, que en este caso solo serán tres JLabel, si el IDE es español completo se muestra como “Etiqueta”. En la imagen siguiente vemos el diseño de nuestro formulario,
cada elemento tiene un nombre de variable como se especifica en la imagen, tomar en cuenta este punto ya que es necesario para referenciar los objetos. Se puede cambiar
el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. (clic sobre la imagen para ampliar)
Lista de las importaciones que debemos de tener para utilizar ciertos elementos en nuestro formulario. Agregamos algunas líneas de código en el constructo del JFrame que
se explican con comentarios.
Códigos utilizados en el constructor e importaciones.
package com.swing.basic;//Paquete de fuente
import javax.swing.ImageIcon;//Importaciones
import javax.swing.JLabel;
/**
*
* @author ECS
*/
public class UsoJLabel extends javax.swing.JFrame {
/**
* Creates new form UsoJLabel
*/
public UsoJLabel() {
initComponents();
setTitle("Uso de JLabel");//Título para el Formualario
//Icono personalizado para el formulario
setIconImage(createImageIcon("/com/swing/basic/img/Login.png").getImage());
//Centrar formulario
setLocationRelativeTo(null);
//Método que arranca con el formulario
inicio();
}
private ImageIcon ico;//Variable de clase
Métodos necesarios. En esta ocasión no utilizaremos eventos.

//Cambiando algunas propiedades del jLabel1
//Texto que muestra
jLabel1.setText("JLabel - Solo Texto");
//Texto de sugerencia o anuncio
jLabel1.setToolTipText("Solo Texto...");
jLabel1.setOpaque(false);
//Le asignamos un valor a nuestra variable de clase ico

ico = createImageIcon("/com/swing/basic/img/Save.png");
//jLabel2 con texto e icono

jLabel2.setText("Texto e Icono");
jLabel2.setToolTipText("Texto e icono...");
jLabel2.setIcon(ico);
//Ubicación del texto con relación al icono
jLabel2.setVerticalTextPosition(JLabel.BOTTOM);
jLabel2.setHorizontalTextPosition(JLabel.CENTER);
//jLabel3 solo con icono

jLabel3.setIcon(ico);
jLabel3.setText(null);
jLabel3.setToolTipText("Solo icono...");
}
//Método para obtener un archivo de imagen
} else {
return null;
}
}
Uso básico de elementos Swing con NetBeans – 20 – Uso de JList. Ejemplo 1.

JList es uno de los tantos elementos que nos pueden facilitar ordenar y visualizar datos en un formulario, es esta oportunidad veremos cómo agregar, eliminar y verificar
repetición de datos dentro de la lista.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario UsoJList). Agregamos a nuestro formulario un JList junto con dos botones de comando para agregar y
eliminar datos y un campo de texto para ingresar datos. En la imagen siguiente vemos el diseño de nuestro formulario, cada elemento tiene un nombre de variable como se
especifica en la imagen, tomar en cuenta este punto ya que es necesario para referenciar los objetos. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic
derecho sobre la misma y clic en “Cambiar nombre de variable…”. (clic sobre la imagen para ampliar)
package com.swing.basic;//Paquete de fuentes
import javax.swing.DefaultListModel;//Lista de importaciones

import javax.swing.ListSelectionModel;
/**
*
* @author ECS
*/
public class UsoJList extends javax.swing.JFrame {
/**
* Creates new form UsoJList
*/
public UsoJList() {
initComponents();
setTitle("Uso de JList.");
//Método de arranque.
inicio();
}
private DefaultListModel modelList;//Variable de clase.
Creamos los métodos siguiente en modo fuente, los métodos creados por nosotros las ubicamos al final de la declaración de variables, justo antes de la llave de cierre general.
Se agregan comentario para aclarar la función de cada línea de código.

//Array de String para agregar al JList
//Si trabajamos con base de datos, puede ser un ArrayList
String nom[] = {"Ariel","Luís","Ana","Juan","Arnaldo","María","Perla"};
//DefaultListModel para manejar las lista.
modelList = new DefaultListModel();
//Agregamos datos a la lista utilizando for
for (String string : nom) {
modelList.addElement(string);
}
//Establecemos algunas propiedades de la lista
jL.setModel(modelList);
jL.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
jL.setSelectedIndex(0);
jL.setVisibleRowCount(7);
}

//Método para eliminar elementos de la lista
//Se optiene el índice del elemento seleccionado
int selectedIndex = jL.getSelectedIndex();
//Si selectedIndex es igual a -1, no hay elemento seleccionado
if(selectedIndex != -1){
modelList.remove(selectedIndex);
}
else{
JOptionPane.showMessageDialog(null, "Seleccione un elemento de la lista.");
}
}

//Método para agregar elementos a la lista
//Comprobamos que el campo de datos no este vacio
if(nomText.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Campo vacio.");
}
else{
//Utilizando el método enLista, comprobamos que no se repitan los datos.
if(enLista(nomText.getText())){
JOptionPane.showMessageDialog(null, "Nombre repetido..");
}
//Agregamos elemento y limpiamos campo.
else{
modelList.addElement(nomText.getText());
nomText.setText(null);
}
}
}
//Método para comprobar datos repetidos

protected boolean enLista(String name) {
return modelList.contains(name);
}

java.net.URL imgURL;
imgURL = UsoJRadioButton.class.getResource(path);
} else {
return null;
}
}
El paso siguiente es establece eventos para los botones, esto les dará la funcionalidad que necesitamos. El evento que normalmente se utiliza para este tipo de elementos es
el ActionPerformed. Si ya vieron alguna guía anterior a esta podrán saber cómo se agrega un evento, la ubicación habitual tanto para la lista de eventos, como también los
eliminar();
}

agregar();
}
Uso básico de elementos Swing con NetBeans – 21 – Uso de JList. Ejemplo 2.

En este ejemplo, a diferencia de la anterior modificaremos ciertas propiedades de la lista para que se ordene de forma horizontal y la posibilidad de seleccionar más de un
elemento de la lista. Si ya realizaron en el ejemplo 1, podrán modificar solamente ciertas partes del código anterior.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario UsoJList). Agregamos a nuestro formulario un JList junto con dos botones de comando para agregar y
eliminar datos y un campo de texto para ingresar datos. En la imagen siguiente vemos el diseño de nuestro formulario, cada elemento tiene un nombre de variable como se
especifica en la imagen, tomar en cuenta este punto ya que es necesario para referenciar los objetos. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic
import javax.swing.DefaultListModel;//Lista de importaciones

import javax.swing.JList;
/**
*
* @author ECS
*/
public class UsoJList extends javax.swing.JFrame {
/**
* Creates new form UsoJList
*/
public UsoJList() {
initComponents();
inicio();
}

//Array de String para agregar al JList
//Si trabajamos con base de datos, puede ser un ArrayList
String nom[] = {"Java","PHP","C++","Basic","Bash","C#","Delphi","FoxPro","JavaScript",
"MATLAB","Objective-C","Python","Perl","Ruby","Visual Basic"};
//Agregamos datos a la lista utilizando for
for (String string : nom) {
}
//Establecemos el modelo, nos permite agregar y eliminar elementos, etc.
//Intervalo de selección
jL.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
jL.setVisibleRowCount(-1);
//Distribución horizontal
jL.setLayoutOrientation(JList.HORIZONTAL_WRAP);
}
//Método para eliminar elementos de la lista
//Se optiene el índice del los elementos a eliminar
//Los índices se almacenan en un array
int[] selectedIndices = jL.getSelectedIndices();
//Comprobamos que el array no este vacío
if(selectedIndices.length > 0){
//Recorremos el array en orden inverso.
for (int i = selectedIndices.length - 1; i >= 0; i--) {
//Se elimina cada {indice
modelList.remove(selectedIndices[i]);
}
}
else{
JOptionPane.showMessageDialog(null, "Selecciona los elementos a eliminar.");
}

//Método para agregar elementos a la lista
//Comprobamos que el campo de datos no este vacio
if(nomText.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Campo vacio.");
}
else{
//Utilizando el método enLista, comprobamos que no se repitan los datos.
if(enLista(nomText.getText())){
JOptionPane.showMessageDialog(null, "Nombre repetido..");
}
//Agregamos elemento y limpiamos campo.
else{
modelList.addElement(nomText.getText());
nomText.setText(null);
}
}
}
//Método para comprobar datos repetidos

protected boolean enLista(String name) {
return modelList.contains(name);
}

} else {
return null;
}
}
El paso siguiente es establece eventos para los botones, esto les dará la funcionalidad que necesitamos. El evento que normalmente se utiliza para este tipo de elementos es
el ActionPerformed. Si ya vieron alguna guía anterior a esta podrán saber cómo se agrega un evento, la ubicación habitual tanto para la lista de eventos, como también los

eliminar();
}

agregar();
}
Uso básico de elementos Swing con NetBeans – 22 – Uso de Menú - JMenu.
Para esta guía veremos el uso de los elementos Swing Menús, que incluyen la barra de menú, los ítems como los JMenuItem, JCheckBoxMenuItem y JRadioButtonMenuItem.
Para el caso, agregamos un JList para almacenar los datos que se recoge cuando se utiliza con eventos.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario UsojMenu). Dentro del formulario agregamos una JList para almacenar los datos que se recoge al
ejecutar un evento. En la imagen siguiente vemos el diseño de nuestro formulario, cada elemento tiene un nombre de variable como se especifica en la imagen, tomar en
package com.swing.basic;
import javax.swing.DefaultListModel;
/**
*
* @author ECS
*/
public class UsoJMenu extends javax.swing.JFrame {
/**
* Creates new form UsoJMenu
*/
public UsoJMenu() {
initComponents();
inicio();
}

jRBM.setSelected(false);
salir.setIcon(createImageIcon("/com/swing/basic/img/update.png"));
jCBM.setSelected(false);
jL.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
jL.setVisibleRowCount(8);
//Distribución vertical
jL.setLayoutOrientation(JList.VERTICAL);
}
} else {
return null;
}
}
Utilizamos el evento “ActionPerformed” para los menús. Si ya vieron alguna guía anterior a esta podrán saber cómo se agrega un evento, la ubicación habitual tanto para la
lista de eventos, como también los métodos que hayamos creado al igual de la forma en que se implementan estos eventos y llamadas a métodos.
private void jRBMActionPerformed(java.awt.event.ActionEvent evt) {

modelList.addElement(evt);//Se egrega un elemento a la lista
//evt contiene las propiedades del evento del objeto
}
private void jCBMActionPerformed(java.awt.event.ActionEvent evt) {

modelList.addElement(evt);
}
private void salirActionPerformed(java.awt.event.ActionEvent evt) {

System.exit(0);
}

modelList.addElement(evt);
}
Uso básico de elementos Swing con NetBeans – 23 – Uso de JPopupMenu, menú emergente.
En este ejemplo veremos cómo podemos utilizar el JPopupMenu dentro de una tabla, a la vez veremos el uso básico que se le puede dar a esta tabla, pudiendo manejarla
utilizando DefaultTableModel, se personalizan las columnas del “JTable” haciendo clic derecho sobre la misma, si el menú es en español dirá “Contenido de tabla”, luego
seleccionamos pestaña “columnas” y hacemos las modificaciones, en la imagen del diseño se especifican los detalles. Los campos de texto servirán para obtener datos del
usuario y el botón “Agregar” para obtener esos datos y pasarla a la tabla. El JPopupMenu se agrega al formulario tomándola desde la paleta, pero esta se ubica en el área
que dice “Otros componentes” como vemos en el diseño más abajo, seguido le podremos añadir los “JMenuItem” que necesitemos; para este ejemplo utilizamos dos que
serán “Eliminar” y “Sumar”. Para el diseño del formulario utilizamos JFrame, el nombre del mismo es a criterio de cada uno en esta ocasión. Tomar en cuenta los nombres de
variable de cada objeto, en el diseño se especifican; es muy importante ya que desde los métodos se utilizan estos nombres para referencia a cada objeto. Se puede cambiar
el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. (clic sobre la imagen para ampliar)
import java.awt.event.MouseEvent;
import javax.swing.JOptionPane;//Importaciones
/**
*
* @author ECS
*/
public class UsoMenu extends javax.swing.JFrame {
/**
* Creates new form UsoMenu
*/
public UsoMenu() {
initComponents();
setLocationRelativeTo(null);//Centrar formulario
tableModel();//Método de inicio
}
private DefaultTableModel model;//Variable de clase

//DefaultTableModel para trabajar con tablas
table.getColumnModel().getColumn(0).setPreferredWidth(10);
model = (DefaultTableModel)table.getModel();
model.setRowCount(0);
}
//El id agregamos desde código
int id = table.getRowCount() + 1;
//Comprobamos que los campos no esten vacios
if(!nombres.getText().isEmpty() && !apellidos.getText().isEmpty() && !edad.getText().isEmpty()){
int ed = 0;
//Si el datos de edad no es númerico se utiliza 0-cero
try {
ed = Integer.parseInt(edad.getText());
} catch (NumberFormatException e) {
JOptionPane.showMessageDialog(null, "Se requiere dato numérico para edad..." + e);
}
//Se agregan datos a la tabla utilizando addRow
id, nombres.getText(), apellidos.getText(),ed
});
//Se limpian los campos al agregar datos
limpiar();
}
else{
JOptionPane.showMessageDialog(null, "Faltan datos...");
}
}
//Método para limpiar campos
edad.setText(null);
nombres.setText(null);
apellidos.setText(null);
}
//Método para sumar el número de elementos y suma total de edades
//Se llama desde JPopupMenu Sumar
private void sumar(){
//Solo se ejecuta si hay almenos una fila
if(table.getRowCount() > 0){
int count = 0;
int sum = 0;
//Se suman los datos...
for (int i = 0; i < table.getRowCount(); i++) {
count++;
sum += Integer.parseInt(model.getValueAt(i, 3).toString());
}
//Se agrega una fila con los datos...
count,"","",sum
});
}
}
//Método para eliminar filas de la tabla...
//Se llama desde JPopupMenu Eliminar
try {
model.removeRow(table.getSelectedRow());
JOptionPane.showMessageDialog(null, "No hay fila seleccionada...");
}
}
Para el botón “Agregar” utilizamos el evento “ActionPerformed” al igual que para los “JMenuItem”. A diferencia para nuestra “Tabla” utilizamos el evento “MousePressed”, que
llamará a nuestro “menú” desplegable emergente haciendo clic derecho. Si hay dudas sobre como agregar “Eventos” a objetos, en las primeras guías de la serie vimos con
detalle ese punto.

agregar();
}
private void tableMousePressed(java.awt.event.MouseEvent evt) {

if(evt.getButton()== MouseEvent.BUTTON3){
//Forma de localizar el punto en que se hace clic
//Parámetro x e y
//BUTTON3, clic derecho
popup.show(evt.getComponent(), evt.getX(), evt.getY());
popup.setVisible(true);
}
}
private void SumarActionPerformed(java.awt.event.ActionEvent evt) {

sumar();
}
private void EliminarActionPerformed(java.awt.event.ActionEvent evt) {

eliminar();
}
En este punto ya podremos ejecutar nuestro formulario y comprobar su funcionalidad. (Por si hay alguna duda en el proceso, debemos hacer clic derecho sobre nuestro archivo
fuente y presionar “ejecutar archivo” ya que nuestro proyecto no tiene una clase principal definida)
Uso básico de elementos Swing con NetBeans – 24 – Uso de JPasswordField, campo para
contraseña.
En esta guía mostraremos una forma sencilla de usar el campo de contraseña, que es una extensión de la clase campo de textos. Para este ejemplo utilizaremos un
JPasswordField para ingresar la contraseña de comprobación y un JTextField con la salida del resultado; un botón con evento para ejecutar el método de comprobación. Para
el diseño utilizamos un “JFrame” que nombraremos “UsoJPasswordField”.
Tomar en cuenta los nombres de variable de cada objeto, en el diseño se especifican; es muy importante ya que desde los métodos se utilizan estos nombres para referencia
a cada objeto. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. (clic sobre la imagen
para ampliar)
La única importación necesaria será la siguiente: import java.util.Arrays;
private void aceptar(){

//Obtenemos el password que es un array de caracteres
//El resultado no es texto en claro sino codificado.
char[] password = jPass.getPassword();
//Usamos nuestro método creado para comprobar
if(esCorrecta(password)){
jTextP.setText("Es Correcta: " + password);
}
else{
jTextP.setText("Contraseña errónea, intenta de nuevo: " + password);
}
//Limpiamos los datos del array.
Arrays.fill(password, '0');
jPass.selectAll();
jPass.requestFocus();
}
//Creamos un método para comprobar la contraseña correcta
private static boolean esCorrecta(char[] p) {
boolean esPass = true;
//Nuestra contraseña de prueba "usuario"
char[] pass = { 'u', 's', 'u', 'a', 'r', 'i', 'o' };
//Comprobamos que la longitud sea igual
if (p.length != pass.length) {
esPass = false;
} else {
//Usamos un comparador para verificar carácter por carácter.
esPass = Arrays.equals(p, pass);
}
//Limpiamos los datos del array.
//Requerimiento de seguridad.
Arrays.fill(pass,'0');
return esPass;
}
Para el botón “Aceptar” utilizamos el evento “ActionPerformed”. Si hay dudas sobre como agregar “Eventos” a objetos, en las primeras guías de la serie vimos con detalle ese
punto.
aceptar();
}
Uso básico de elementos Swing con NetBeans – 25 – Uso de JProgressBar, barra de progreso.
En esta guía veremos el funcionamiento de la barra de progresos “JProgressBar” de uso habitual en ciertos procesos que requieren tiempo de ejecución controlada. Como
vemos en el diseño más abajo, creamos un formulario utilizando un JFrame, la nombramos “UsoJProgressBar”. Agregamos al formulario un “Botón” para lanzar nuestro
método, el objeto “JProgressBar” y un “JTextArea” para mostrar el progreso de la ejecución.
para ampliar)
Para este ejemplo no se requiere de ninguna importación. Creamos los métodos siguiente en modo fuente, los métodos creados por nosotros las ubicamos al final de la
declaración de variables, justo antes de la llave de cierre general. Se agregan comentario para aclarar la función de cada línea de código.
//Método que llamaremos desde nuestro botón

//Creamos un Thread para mejorar el ejemplo
final Thread t;
//Inicializamos
t = new Thread(new Runnable() {
//Implementamos el método run()
@Override
public void run() {
//Permite mostrar el valor del progreso
jPr.setStringPainted(true);
int x = 1;
//Utilizamos un while para emular el valor mínimo y máximo
//En este caso 0 - 100
while(x <= 100){
//Asignamos valor a nuestro JProgressBar por cada siclo del bucle
jPr.setValue(x);
//Valor que se mostrará en el JTextArea
salida.append("Progreso " + x + "%...\n");
//Hacemos una parada de medio segundo por cada siclo while
try {
Thread.sleep(500);
} catch (InterruptedException e) {
}
//Se incrementa el valor de x
x++;
}
}
});
//Se ejecuta el Thread
t.start();
}
Para el botón “Iniciar” utilizamos el evento “ActionPerformed”. Si hay dudas sobre como agregar “Eventos” a objetos, en las primeras guías de la serie vimos con detalle ese
punto.

inicio();
}
“ejecutar archivo” ya que nuestro proyecto no tiene una clase principal definida).
Uso básico de elementos Swing con NetBeans – 26 – Uso de JProgressBar, barra de progreso.
Ejemplo 2.
En esta guía veremos el funcionamiento de la barra de progresos “JProgressBar” de uso habitual en ciertos procesos que requieren tiempo de ejecución controlada. Para este
segundo ejemplo realizaremos algo un poco más complejo, específicamente aplicaremos una método que calcula números primos. Este método la hemos creado como ejemplo
para el curso en modo consola, realizaremos pequeñas modificaciones para ajustarla a este propósito. Para el diseño utilizamos un JFrame, la nombramos “UsoJProgressBar2”.
Podemos utilizar “JPanel” para ordenar los elementos de forma independiente. En vista de diseño vemos en uno de los paneles dos campos de texto con sus etiquetas más
los botones de comando que servirán para poner en marcha la aplicación. Seguido la barra de progresos. Por último dentro de un panel el “JList” que mostrará los números
primos que obtengamos.
para ampliar)
Lista de importaciones que necesitamos para trabajar con ciertos objetos. Además los métodos llamados desde el constructor del JFrame y variables de clase que necesitamos
crear.
package com.swing.basic;//tomar en cuenta el paquete del JFrame
/**
*
* @author Ariel
*/
public class UsoJProgressBar2 extends javax.swing.JFrame {
/**
* Creates new form UsoJProgressBar2
*/
public UsoJProgressBar2() {
initComponents();
inicio();//Método de inicio
}

//Especificamos algunas propiedades de nuestra lista
//Inicializamos la variable DefaultListModel
lista.setModel(modelList);
lista.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
lista.setSelectedIndex(0);
lista.setVisibleRowCount(-1);
//Distribución horizontal
lista.setLayoutOrientation(JList.HORIZONTAL_WRAP);
//Limpiamos los campos de texto
desde.setText(null);
hasta.setText(null);
//Indicamos el valor que muestra JProgressBar al iniciar el programa
jpb.setValue(0);
}
private void iniciar(){

//Creamos un Thread para mejorar el ejemplo
final Thread t;
//Inicializamos
t = new Thread(new Runnable() {
//Implementamos el método run()
@Override
public void run() {
//Permite mostrar el valor del progreso
jpb.setStringPainted(true);
//Comprobamos que no esten vacíos los campos de texto
if(!desde.getText().isEmpty() && !hasta.getText().isEmpty()){
//Utilizamos try... por si falla la coversión numérica
try {
int d = Integer.parseInt(desde.getText());
int h = Integer.parseInt(hasta.getText());
//Verificamos que los datos numéricos sean mayor que cero-0
if(d > 0 && h > 0){
//Verificamos que h sea mayor que d
if(h > d){
//Establecemos el valor mínimo y máximo de nuestro barra de progreso
//Esta permitirá mostra el valor correcto del progreso
jpb.setMinimum(d);
jpb.setMaximum(h);
//Con un for iremos comprobando si el valor de i es primo
for (int i = d; i <= h; i++) {
//i será el valor de la barra de progreso en cada momento, esta se ira incrementando
jpb.setValue(i);
//Comprobamos que el valor sea primo por cada ciclo
if(!esPrimo(i)){
modelList.addElement(i);
}
//Hacemos una interrupción de 100 milisegundos
//Se puede disminuir o aumentar según se desee
try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
}
}
}
JOptionPane.showMessageDialog(null, "Datos no numéricos" + e);
}
}
}
});
//Se ejecuta el Thread
t.start();
}
//Este método vimos su funcionamiento en modo consola
//La función recibe un entero como argumento para calcular si es primo
private boolean esPrimo(int n){
boolean b = false;
//Los números negativos no entran como primos, el 1-uno tampoco
if(n <= 0 || n == 1){
b = true;
}
//El 2,3,5 son primos conocidos por tanto las obviamos
else if(n != 2 && n != 3 && n != 5){
for (int i = 2; i < n; i++) {
//Si b es true, demuestra que n no es primo y salimos del bucle
if(b){
break;
}
b = (n%i == 0);
}
}
//2,3 y 5 son los primeros primos conocidos
else{
b = false;
}
return b;
}
Para los botones utilizamos el evento “ActionPerformed”. Si hay dudas sobre como agregar “Eventos” a objetos, en las primeras guías de la serie vimos con detalle ese punto.

iniciar();
}
inicio();
}
Uso básico de elementos Swing con NetBeans – 27 – Uso de JSlider, regla interactiva.
Para este ejemplo veremos el uso básico de un “JSlider”, que es similar a una regla interactiva con valores numéricos o etiquetas que indican propiedades. En esta aplicación
utilizaremos un Área de Texto junto con el JSlider. Específicamente el JSlider contendrá valores numéricos que representaran tamaños de fuentes, el Área de Texto contendrá
dos párrafos que irán variando el tamaño de texto conforme desplacemos los valores más o menos en el JSlider.
Tomar en cuenta los nombres de variable de cada objeto, se especifican los nombres en el diseño. Esto es muy importante ya que desde los métodos se utilizan estos nombres
para referencia a cada objeto. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. (clic
sobre la imagen para ampliar)
Lista de importaciones que necesitamos para trabajar con ciertos objetos. Además los métodos llamados desde el constructor del JFrame.
import java.awt.Font;
/**
*
* @author Ariel
*/
public class UsoJSlider extends javax.swing.JFrame {
/**
* Creates new form UsoJSlider
*/
public UsoJSlider() {
initComponents();
}
Para este ejemplo requerimos un único método que llamaremos al ejecutar el formulario y esto nos permitirá inicializar los objetos que agregamos en modo de diseño. Los
métodos creados por nosotros las ubicamos al final de la declaración de variables, justo antes de la llave de cierre general. Se agregan comentario para aclarar la función de
cada línea de código.

//Establecemos tipo de fuente Consolas, texto plano, tamaño 15
jt.setFont(new Font("Consolas", Font.PLAIN, 16));
jt.setLineWrap(true);
jt.setWrapStyleWord(true);
//Agregamos texto simple al Área de Texto como ejemplo.
//El indicador \n sirve para salto de línea.
jt.setText("Java Development Kit o (JDK), es un "
+ "software que provee herramientas de desarrollo "
+ "para la creación de programas en Java. "
+ "\nNetBeans IDE. Es un entorno de desarrollo integrado libre, "
+ "hecho principalmente para el lenguaje de programación Java.");
//Configurams el JSlider
//Valor mínimo
jl.setMinimum(8);
//Valor máximo
jl.setMaximum(44);
//valor inicial
jl.setValue(16);
//Valores para mostrar regla
//mínimo para mostrar
jl.setMinorTickSpacing(1);
//máximo para mostrar
jl.setMajorTickSpacing(4);
//Especificamos que se muestren los valores
jl.setPaintTicks(true);
jl.setPaintLabels(true);
}
Para el JSlider utilizamos el evento “StateChanged”, que nos permitirá capturar el valor cuando se deslice el marcador en la regla. En las primeras guías de la serie vimos
cómo se implementan los eventos desde el entorno de diseño, si hay dudas se pueden consultar esas entradas.
private void jlStateChanged(javax.swing.event.ChangeEvent evt) {

//Obtenemos valor del JSlider
int value = jl.getValue();
//Indicamos las propiedades de fuente del JTextArea
//value será la que cambien según se mueva el marcador del JSlider.
jt.setFont(new Font("Consolas", Font.PLAIN, value));
}
Uso básico de elementos Swing con NetBeans – 28 – Uso de Spinners, lista de elementos.
En esta oportunidad pondremos en funcionamiento tres Spinnes, que contendrán una lista de días meses y años respectivamente. Como sabemos un spinner puede contener
diferentes tipos de elementos sean estas numéricas o no. Para el ejemplo agregaremos tres Spinnes que contendrán cada uno un modelo específico de elementos que se
contendrán en Arrays y enteros. Dependiendo del caso se pueden utilizar SpinnerListModel o SpinnerNumberModel.
import javax.swing.SpinnerListModel;
import javax.swing.SpinnerModel;//Importaciones
import javax.swing.SpinnerNumberModel;
/**
*
* @author Ariel
*/
public class UsoSpinner extends javax.swing.JFrame {
/**
* Creates new form UsoSpinner
*/
public UsoSpinner() {
initComponents();
setLocationRelativeTo(null);//Centrar Formulario
inicio();
}
Calendar calendar = Calendar.getInstance();//Variable de Objeto Calendar
Para este ejemplo requerimos de un solo método privado, que se iniciará desde el constructor del JFrame y permitirá inicializar los spinners. Se especifica el funcionamiento
de cada línea de código utilizando comentarios. No se requieren eventos para este ejemplo.

//Array de String para los días y meses
String[] d = {"Domingo","Lunes","Martes","Miércoles","Jueves","Viernes","Sábado"};
//El array mes puede contener un registro vacío, se puede corregir con un pequeño ajuste...
String[] mes = new java.text.DateFormatSymbols().getMonths();
//Tipo entero para año
int an = calendar.get(Calendar.YEAR);
//Especificando modelos para cada Spinner
SpinnerListModel modelDias = new SpinnerListModel(d);
SpinnerListModel modelMes = new SpinnerListModel(mes);
//Parámetro numéricos
//public SpinnerNumberModel(int value, int minimum, int maximum, int stepSize)
//Valor inicial - valor mínimo - valor máximo - incremento a 1
SpinnerModel modelAnyo = new SpinnerNumberModel(an, an - 100, an + 100, 1);
//Agregamos el modelo a cada Spinner
dias.setModel(modelDias);
meses.setModel(modelMes);
anyos.setModel(modelAnyo);
}
“ejecutar archivo” ya que nuestro proyecto no tiene una clase principal definida) (clic sobre la imagen para ampliar)
Uso básico de elementos Swing con NetBeans – 29 – Uso de Spinners, ejemplo 2.

Para este ejemplo utilizamos dos JSpinner, una para indicar fecha y otra para hora. Aparte de las etiquetas no se utiliza otro elemento, el diseño es bastante sencillo. El
proceso es similar al ejemplo uno, se especifica el funcionamiento de cada línea de código con comentarios.
import java.util.Date;
import javax.swing.JSpinner;//Importaciones
import javax.swing.SpinnerDateModel;
import javax.swing.SpinnerModel;
/**
*
* @author Ariel
*/
public class UsoSpinnerDos extends javax.swing.JFrame {
/**
* Creates new form UsoJSliderDos
*/
public UsoSpinnerDos() {
initComponents();
inicio();//Método de arranque
}
Calendar calendar = Calendar.getInstance();//Variable de Objeto Calendar
Para este ejemplo requerimos de un solo método privado, que se iniciará desde el constructor del JFrame y permitirá inicializar los spinners. Se especifica el funcionamiento
de cada línea de código utilizando comentarios. No se requieren eventos para este ejemplo.

//Obtenemos una fecha de inicio, será la fecha actual del sistema
Date inicio = calendar.getTime();
//Indicamos año hasta -100 del actual
calendar.add(Calendar.YEAR, -100);
//Guardamos la configuración en un DATE
Date fechaAnterior = calendar.getTime();
//Indicamos año hasta +200 del actual
calendar.add(Calendar.YEAR, 200);
//Guardamos la configuración en un DATE
Date fechaPosterior = calendar.getTime();
//Usamos el contructor de abajo para crear un modelo para el Spinner
//SpinnerDateModel(Date value, Comparable start, Comparable end, int calendarField)
//Utilizamos los datos que creamos más arriba
//Para fecha utilizamos Calendar.YEAR y para hora Calendar.HOUR, el resto puede ser igual
SpinnerModel fechaModel = new SpinnerDateModel(inicio, fechaAnterior, fechaPosterior, Calendar.YEAR);
SpinnerModel horaModel = new SpinnerDateModel(inicio, fechaAnterior, fechaPosterior, Calendar.HOUR);
//Indicamos el model para cada Spinner además del formato de fecha y hora según corresponda.
fecha.setModel(fechaModel);
fecha.setEditor(new JSpinner.DateEditor(fecha, "dd/MM/yyyy"));
hora.setModel(horaModel);
hora.setEditor(new JSpinner.DateEditor(hora, "HH:mm:ss"));
}
Ahora sí, podemos ejecutar nuestro formulario. (Por si hay alguna duda en el proceso, debemos hacer clic derecho sobre nuestro archivo fuente y presionar “ejecutar archivo”
ya que nuestro proyecto no tiene una clase principal definida) (clic sobre la imagen para ampliar)
Uso básico de elementos Swing con NetBeans – 30 – Uso de JSplitPane, divisor de elementos.
El JSplitPane es un elemento muy útil que nos permite dividir objetos distintos en uno o varios paneles redimensionables. En este ejemplo agregamos una Lista de nombres
de imágenes PNG, que se cargarán al seleccionarlas con un clic y que se mostraran en un Label, como se ve en el diseño el JSplitPane muestra la lista en la parte izquierda
y al label en la parte derecha en el medio el divisor redimensionable. Como vemos en el diseño también necesitamos dos JScrollPane, que se puede agregar arrastrando y
soltando en el punto específico, la misma forma el elemento que la utilizan se arrastra y suelta en su interior. Es más fácil mover elementos de un lugar a otro utilizando el
“Navegador” como se muestra en la imagen más abajo.
/**
*
* @author Ariel
*/
public class UsoJSplitPane extends javax.swing.JFrame {
/**
* Creates new form UsoJSplitPane
*/
public UsoJSplitPane() {
initComponents();
}
Para el ejemplo utilizamos varios métodos que cumplen funciones específicas, la principal es “inicio” que nos permitirá inicializar la lista y configurar ciertas propiedades de
cada elemento del diseño. Las propiedades de objetos se pueden editar en modo diseño, pero es más fácil entender cómo funcionan al hacerla en modo código.
//Incluye las fechitas de expanción rápida al JSplitPane
jSp.setOneTouchExpandable(true);
//Localización de divisor
jSp.setDividerLocation(150);
//Array de String con los nombres de archivos PNG que utilizaremos
//Cada uno puede hacer su propia lista.
String[] img = {"paisaje","bosque","kirito","Delete","Login","New","Save","Select","load","note","package",
"print","userr","aqua"};
//DefaultListModel para el JList
//Agregamos el array de String a la lista
for (String string : img) {
}
//Específicamos el DefaultListModel para nuestro JList
jLt.setModel(modelList);
//Indicamos que el JLabel no muestre texto
jLb.setText(null);
/**
Imagen tipo JPG para indicar una imagen incial al JLabel
El resto de las imagenes utilizada son PNG
Las imagenes debemos de tenerlas en un paquete dentro del mismo proyecto...
O dentro del mismo paquete que nuestro JFrame, en tal caso solo indicamos el nombre y la extensión,
Caso contrario debemos de indicar toda la ruta...
* */
jLb.setIcon(createImageIcon("/com/swing/basic/img/" + "acercaFond" + ".jpg"));
}
//Método para actualizar la imagenes mostradas en el JLabel
private void actualizar(){
imageLabel(jLt.getSelectedValue().toString());
}
//Método que requiere como parámetro el nombre del la imagen para mostrar
private void imageLabel(String nombre){
jLb.setIcon(createImageIcon("/com/swing/basic/img/" + nombre + ".png"));
}
private static ImageIcon createImageIcon(String path) {
} else {
return null;
}
}
En este ejemplo el único elemento que maneja eventos es la lista, la cual utiliza el MouseClicked. En las primeras guías de la serie vimos cómo se implementan los eventos
desde el entorno de diseño, si hay dudas se pueden consultar esas entradas.
private void jLtMouseClicked(java.awt.event.MouseEvent evt) {

actualizar();
}
ya que nuestro proyecto no tiene una clase principal definida) (clic sobre la imagen para ampliar)
Uso básico de elementos Swing con NetBeans – 31 – Uso de JTabbedPane, divisor de paneles.
JTabbedPane es un elemento útil a la hora de dividir múltiples paneles en pestañas, lo cual permite incluir multitud de funcionalidades en un solo formulario, permitiendo
compactarlas en paneles independientes y de fácil navegación. Para este ejemplo utilizaremos un JTabbedPane a la cual le incluiremos tres JPanel, cada una indicará una
pestaña funcional por si sola. A cada JPanel le agregaremos un JScrollPane para ajustar el redimensionado y dentro de esta última un JLabel la cual utilizando ejemplos
anteriores le agregaremos una imagen. Como se ver en el diseño más abajo, los ajustes básicos la hacemos en modo código, por tanto basta con agregar de forma correcta
cada elemento.
package com.swing.basic;//Paquete
import javax.swing.ImageIcon;//Importación
/**
*
* @author Ariel
*/
public class UsoJTabbedPane extends javax.swing.JFrame {
/**
* Creates new form UsoJTabbedPane
*/
public UsoJTabbedPane() {
initComponents();
setLocationRelativeTo(null);//Centrar Formulario
}
Como es habitual utilizamos un método privado que arrancará junto con el formulario al llamarla desde el constructor, esto nos permitirá inicializar las propiedades necesarias
de cada objeto del formulario. Se especifican con comentarios la funcionalidad de cada línea de código. Para este ejemplo no se aplican los eventos.

//Configuramos el primer tabbed, el primer parámetro indica el índice.
jTabb.setTitleAt(0, "Primer Panel");
jTabb.setIconAt(0, createImageIcon("/com/swing/basic/img/Search.png"));
jTabb.setToolTipTextAt(0, "Esta es la primera pestaña");
//Agregamos el icono al label
jLab01.setText(null);
//Depende de como tengamos oragnizado los paquetes para ubicar las imagenes
jLab01.setIcon(createImageIcon("/com/swing/basic/img/aqua.png"));
//Configuramos el segundo tabbed, el primer parámetro indica el índice.

jTabb.setTitleAt(1, "Segundo Panel");
jTabb.setIconAt(1, createImageIcon("/com/swing/basic/img/clients.png"));
jTabb.setToolTipTextAt(1, "Esta es la segunda pestaña");
jLab02.setIcon(createImageIcon("/com/swing/basic/img/kirito.png"));
//Configuramos el tercer tabbed, el primer parámetro indica el índice.

jTabb.setTitleAt(2, "Tercer Panel");
jTabb.setIconAt(2, createImageIcon("/com/swing/basic/img/load.png"));
jTabb.setToolTipTextAt(2, "Esta es la tercera pestaña");
jLab03.setIcon(createImageIcon("/com/swing/basic/img/paisaje.png"));
}
//Método que nos permitirá cargar una imagen como icono pasándole una url
private static ImageIcon createImageIcon(String path) {
} else {
return null;
}
}
ya que nuestro proyecto no tiene una clase principal definida)
Uso básico de elementos Swing con NetBeans – 32 – Uso de JTable, agregar y eliminar elementos de
tabla.
Las tablas son uno de los elementos más utilizados dentro de cualquier lenguaje de programación, se puede utilizar para desplegar lista de datos similares ordenados de una
forma específica. Su uso es bastante amplio pues es bastante versátil. En este ejemplo utilizaremos la tabla para mostrar datos ingresados por el usuario. Con esto podremos
ver como se agregan y eliminan filas de una tabla. Como agregado veremos cómo agregar un JCheckBox a la tabla utilizando CellEditor y CellRenderer.
La tabla se puede manipular en modo diseño, se especifican los nombres y cantidad de columnas haciendo clic derecho sobre la tabla y accediendo a “Contenidos de tabla
(Table Contents)”. Para el combo agregamos “Sí” y “No” en modo diseño desde la propiedad del objeto y en el apartado “model”. Agregar icono para los botones es opcional.
Lista de importaciones que necesitamos para trabajar con ciertos objetos. Además los métodos llamados desde el constructor del JFrame y las variables de clase.
import java.awt.Component;
import javax.swing.DefaultCellEditor;
import javax.swing.JCheckBox;
import javax.swing.JComponent;//Importaciones
import javax.swing.JTable;
import javax.swing.table.TableCellRenderer;
/**
*
* @author Ariel
*/
public class UsoJTable extends javax.swing.JFrame {
/**
* Creates new form UsoJTable
*/
public UsoJTable() {
initComponents();
}
private DefaultTableModel model;//Modelo para tabla
private int sel;//Variable para obtener fila seleccionada de tabla.
Para el ejemplo utilizamos varios métodos que cumplen funciones específicas. El nombre que le damos a cada método nos da una idea de que función cumple. El método
“inicio()” por ejemplo arranca desde el constructor del JFrame y nos permite inicializar algunas propiedades de la tabla. Se agregan comentarios para indicar la funciona de
cada línea de código.

//Método para configurar el DefaultTableModel de la tabla.
//Especificamos el tamaño de cada columna
jTb.getColumnModel().getColumn(0).setPreferredWidth(100);
//Indicamos el DefaultTableModel de nuestra tabla
model = (DefaultTableModel) jTb.getModel();
//Indicamos el número de filas
}
//Método para agregar datos a la tabla.

//También mostramos como agregar un JCheckBox a la tabla
JCheckBox check = new JCheckBox();
//Comprobamos que los campos de datos no esten vacíos
if(!nombre.getText().isEmpty() || !apellido.getText().isEmpty() ||
!edad.getText().isEmpty() || !profesion.getText().isEmpty()){
//Utilizamos un boolean para obtener el valor del combo.
boolean rp = casado.getSelectedItem().toString().equals("Sí");
//Utilizamos try para la controlar posibles errores de conversión.
try {
//Convertimos en entero lo obtenido del campo edad.
int edd = Integer.parseInt(edad.getText());
//agregamos los datos a la tabla utilizando Object[]
nombre.getText(),apellido.getText(),edd, profesion.getText(),rp
});
limpiar();
JOptionPane.showMessageDialog(null, "Edad debe ser numérico");
}
}
//Agregamos el JCheckBox utilizando CellEditor y la clase CellRenderer creado más abajo
jTb.getColumnModel().getColumn(4).setCellEditor(new DefaultCellEditor(check));
jTb.getColumnModel().getColumn(4).setCellRenderer(new Render_CheckBox());
}
//Método para obtener la fila seleccionada de la tabla
private void seleccion(){
if(jTb.getRowCount() > 0 ){
sel = jTb.getSelectedRow();
}
}
//Método para obtener la fila seleccionada de la tabla.
if(sel >= 0){
model.removeRow(sel);
sel = -1;
}
else{
JOptionPane.showMessageDialog(null, "Selecciona una fila.");
}
}
//Método para limpiar campos después de agregar los datos a la tabla

nombre.setText(null);
apellido.setText(null);
edad.setText(null);
profesion.setText(null);
casado.setSelectedIndex(-1);
}
//Clase para manejar el TableCellRenderer, que permitirá mostrar el JCheckBox
class Render_CheckBox extends JCheckBox implements TableCellRenderer {
//
private final JComponent component = new JCheckBox();
/** Constructor de clase */

public Render_CheckBox() {
setOpaque(true);
}
@Override
public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int
row, int column) {
//Color de fondo de la celda
( (JCheckBox) component).setBackground( new Color(98,138,183) );
//obtiene valor boolean y coloca valor en el JCheckBox
boolean b = ((Boolean) value).booleanValue();
( (JCheckBox) component).setSelected( b );
return ( (JCheckBox) component);
}
}
Para el ejemplo utilizamos dos tipos de evento, “ActionPerformed” para los botones y “MouseClicked” para la tabla. Abajo la lista de eventos. Obs.: En las primeras guías de
esta serie vimos cómo se agregan eventos a objetos en modo diseño.

agregar();
}

eliminar();
}
private void jTbMouseClicked(java.awt.event.MouseEvent evt) {

seleccion();
}
Llegado a este punto podremos ejecutar y probar nuestro formulario. (Por si hay alguna duda en el proceso, debemos hacer clic derecho sobre nuestro archivo fuente y
presionar “ejecutar archivo” ya que nuestro proyecto no tiene una clase principal definida) (clic sobre la imagen para ampliar)
Uso básico de elementos Swing con NetBeans – 33 – Uso de JTextArea, agregar elementos desde
JTextField.
Anteriormente ya vimos la utilizando de un “JTextArea” o Área de Texto, en esta oportunidad daremos un pequeño ejemplo de cómo agregar texto desde un JTextField. El
nombre que le demos al formulario es a criterio de cada uno. Tomar en cuenta los nombres de variable de cada objeto, se especifican los nombres en el diseño. Esto es muy
importante ya que desde los métodos se utilizan estos nombres para referencia a cada objeto. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho
sobre la misma y clic en “Cambiar nombre de variable…”. (clic sobre la imagen para ampliar)
import java.awt.Font;//Importación
/**
*
* @author Ariel
*/
public class EjJTextArea extends javax.swing.JFrame {
/**
* Creates new form EjJTextArea
*/
public EjJTextArea() {
initComponents();
}
“inicio()” por ejemplo arranca desde el constructor del JFrame y nos permite inicializar algunas propiedades del área de texto. Se agregan comentarios para indicar la funciona
de cada línea de código.

//Establecemos tipo de fuente predeterminado, texto itálico, tamaño 15
jTex.setFont(new Font("Default", Font.ITALIC, 15));
jTex.setLineWrap(true);
jTex.setWrapStyleWord(true);
//Hacemos que el área de texto no sea editable
jTex.setEditable(false);
}
//Método para agregar texto al área de texto.

//Verificamos que el campo de texto no este vacío
if(!jT.getText().isEmpty()){
//Para agregar textos se utiliza append. "\n" indica salto de línea.
jTex.append(jT.getText() + "\n");
//Limpiamos el campo JTextField.
jT.setText(null);
}
}
En este ejemplo tenemos un solo botón denominado “Agregar” la cual utilizará el evento “ActionPerformed” que permitirá ejecutar el método “agregar()”. En las primeras guías
de la serie vimos cómo se hacer para relacionar un evento con un objeto visual.

agregar();
}
presionar “ejecutar archivo” ya que nuestro proyecto no tiene una clase principal definida).
Uso básico de elementos Swing con NetBeans – 34 – Uso de JTextArea, cambio de fuente y tamaño
de fuente.
Ampliando el ejemplo anterior, veremos cómo obtener la lista de fuentes del sistema y aplicarlas a nuestro Área de Texto, también veremos cómo ajustar el tamaño de fuentes.
El resto es totalmente igual al del ejemplo anterior. Para mostrar la lista de fuentes y tamaño de fuente utilizamos combos. Es necesario limpiar los ítems del “model” en modo
diseño.
El nombre que le demos al formulario es a criterio de cada uno. Tomar en cuenta los nombres de variable de cada objeto, se especifican los nombres en el diseño. Esto es
muy importante ya que desde los métodos se utilizan estos nombres para referencia a cada objeto. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic
import java.awt.Font;//Importación
import java.awt.GraphicsEnvironment;
/**
*
* @author Ariel
*/
public class EjJTextArea extends javax.swing.JFrame {
/**
* Creates new form EjJTextArea
*/
public EjJTextArea() {
initComponents();
}
“inicio()” por ejemplo arranca desde el constructor del JFrame y nos permite inicializar algunas propiedades del área de texto. Se agregan comentarios para indicar la funciona
de cada línea de código.

//Establecemos tipo de fuente predeterminado, texto itálico, tamaño 15
jTex.setFont(new Font("Default", Font.PLAIN, 15));
jTex.setLineWrap(true);
jTex.setWrapStyleWord(true);
//Hacemos que el área de texto no sea editable
jTex.setEditable(false);
//Configuramos la lista de tipo de fuentes y tamaño

//Obtenemos la lista de fuentes del sistema utilizando getAvailableFontFamilyNames()
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
String[] fonts = ge.getAvailableFontFamilyNames();
//Agregamos cada nombre de fuente a nuestro combo.

for (String string : fonts) {
fuenteTipo.addItem(string);
}
//Agregamos los tamaños de fuente, de 1 al 70

for (int i = 1; i < 71; i++) {
fuenteTam.addItem(i);
}
//Inicializamos el tamaño de fuente en 15.

fuenteTam.setSelectedIndex(14);
}
//Método para agregar texto al área de texto.

//Verificamos que el campo de texto no este vacío
if(!jT.getText().isEmpty()){
//Para agregar textos se utiliza append. "\n" indica salto de línea.
jTex.append(jT.getText() + "\n");
//Limpiamos el campo JTextField.
jT.setText(null);
}
}
//Método para manejar los cambios de fuente y tamaño

private void tipoFuente(){
//Obtenemos tipo y tamaño.
String toString = fuenteTipo.getSelectedItem().toString();
int selectedIndex = fuenteTam.getSelectedIndex() + 1;
jTex.setFont(new Font(toString, Font.PLAIN, selectedIndex));
}
}
En relación a los eventos, tanto para el botón agregar como en los dos combos utilizaremos el “ActionPerformed” que permitirá ejecutar los métodos. En las primeras guías de
la serie vimos cómo se hacer para relacionar un evento con un objeto visual.

agregar();
}
private void fuenteTipoActionPerformed(java.awt.event.ActionEvent evt) {

tipoFuente();
}
private void fuenteTamActionPerformed(java.awt.event.ActionEvent evt) {

tipoFuente();
}
presionar “ejecutar archivo” ya que nuestro proyecto no tiene una clase principal definida)
Uso básico de elementos Swing con NetBeans – 35 – Uso de JToolBar, barra de herramientas.
En este ejemplo sencillo veremos la utilidad de un “JToolBar”, objeto que puede contener botones u otros elementos, tiene ciertas ventajas como la posibilidad de flotar de
forma libre o ubicarse fácilmente en cualquiera de los cuatro costados del formulario desplazando automáticamente otros elementos. En este ejemplo nuestra “Barra de
Herramientas” contendrá cinco botones, cada una al hacer clic sobre ellas agregará una línea de texto al “Área de texto” indicando la procedencia del clic. En modo diseño
podremos ver la distribución de los elementos. El nombre que le demos al formulario es a criterio de cada uno. Tomar en cuenta los nombres de variable de cada objeto, se
especifican los nombres en el diseño. Esto es muy importante ya que desde los métodos se utilizan estos nombres para referencia a cada objeto. Se puede cambiar el “Nombre
de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. (clic sobre la imagen para ampliar)
Para este ejemplo necesitamos una única importación y el método de inicio habitual.
import java.awt.Color;//Importación
/**
*
* @author Ariel
*/
public class UsoJToolBar extends javax.swing.JFrame {
/**
* Creates new form UsoJToolBar
*/
public UsoJToolBar() {
initComponents();
}
El único método que necesitamos es “inicio()” la cual inicializará ciertas propiedades del área de texto como ya veremos.

//Pequeños ajuste para el Area de Texto.
//Los ajustes para la barra de herramientas se hacen en modo diseño.
jTextA.setEditable(false);
jTextA.setBackground(Color.lightGray);
jTextA.setForeground(Color.BLUE);
}
Para los botones se utiliza el evento “ActionPerformed” que permitirá ejecutar los métodos. En las primeras guías de la serie vimos cómo se hacer para relacionar un evento
con un objeto visual.
private void btn01ActionPerformed(java.awt.event.ActionEvent evt) {

jTextA.append("Clic botón Abrir..." + "\n");
}

jTextA.append("Clic botón Buscar..." + "\n");
}

jTextA.append("Clic botón Consultar..." + "\n");
}

jTextA.append("Clic botón Imprimir..." + "\n");
}

jTextA.append("Clic botón Ayuda..." + "\n");
}
presionar “ejecutar archivo” ya que nuestro proyecto no tiene una clase principal definida).
Aplicación de Stock con Java. Hibernate – MySQL – JPA.
001 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. Introducción.

Conceptos previos.
Hibernate.
Es una herramienta de Mapeo objeto-relacional (ORM) para la plataforma que facilita el mapeo de atributos entre una base de datos relacional tradicional y el modelo de
objetos de una aplicación, mediante archivos declarativos (XML) o anotaciones en los beans de las entidades que permiten establecer estas relaciones.
Java Persistence API
Java Persistence API, más conocida por sus siglas JPA, es la API de persistencia desarrollada para la plataforma Java EE. Es un framework del lenguaje de programación
Java que maneja datos relacionales en aplicaciones usando la Plataforma Java en sus ediciones Standard y Enterprise.
MySQL
MySQL es un sistema de gestión de bases de datos relacional, multihilo y multiusuario con más de seis millones de instalaciones.
JasperReports con iReport.
JasperReports es una herramienta de creación de informes que tiene la habilidad de entregar contenido enriquecido al monitor, a la impresora o a ficheros PDF, HTML, XLS,
CSV y XML. Está escrito completamente en Java y puede ser usado en gran variedad de aplicaciones de Java, incluyendo J2EE o aplicaciones web, para generar contenido
dinámico. Su propósito principal es ayudar a crear documentos de tipo páginas, preparados para imprimir en una forma simple y flexible. JasperReports se usa comúnmente
con iReport, un front-end gráfico de código abierto para la edición de informes. Se encuentra bajo licencia libre GNU, por lo que es Software libre. Forma parte de la iniciativa
apilada open source Lisog. (Wikipedia)
Herramientas necesarias para el desarrollo.
 JDK.: Java Development Kit o (JDK), es un software que provee herramientas de desarrollo para la creación de programas en Java.
 NetBeans IDE. Es un entorno de desarrollo integrado libre, hecho principalmente para el lenguaje de programación Java.
 MySQL.
 MySQL Workbench (GUI Tool).
 iReport. -- Descarga: Instalador-Librerias iReport-4.7.0.zip
 Hibernate: Utilizaremos el que se incluye con el Netbeans.
002 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. Creando nuevo proyecto.
Empezamos creando nuevo proyecto.
Abrimos nuestro NetBeans IDE, que ya tendríamos que tener instalado.
Vamos en el menú Archivo – Proyecto Nuevo. En “Categorías” seleccionamos “Java”, en “Proyectos” indicamos “Aplicación Java” y clic en siguiente. (Img. 1)
Nombre de proyecto indicamos el que mejor nos parezca, “proyectoJava” en este caso para el tutorial.
Podemos desmarcar “Crear clase principal” y “Configurar proyecto como principal”. (Img. 2)
Paso siguiente crear paquetes, realizar la conexión y configurar HibernateUtil e hibernate.cfg.
003 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. Creando paquetes, Base de Datos,
realizando la conexión y configuración de HibernateUtil e hibernate.cfg.
Creando paquetes.
(Paquetes: Un Paquete en Java es un contenedor de clases que permite agrupar las distintas partes de un programa cuya funcionalidad tienen elementos comunes.
Wikipedia…)
Para crear un paquete hacemos clic derecho sobre “Paquetes de fuentes” que esta dentro del proyecto desplegado. Clic en “Nuevo” y seleccionando “Paquete Java…” le
especificamos el nombre. Abajo la lista de paquetes a utilizar. (Img. 1)
 com.app
Para almacenar los formularios y clases ejecutables y de apoyo.
 com.entidades
Para almacenar las clases persistentes.
 com.img
Para almacenar las imágenes que utilizaremos para el proyecto.
 com.informe
Para almacenar los informes.
 ultil
Para almacenar la clase HibernateUtil. (Img. 2)
Creando la Base de Datos, realizando la conexión y configuración de HibernateUtil e hibernate.cfg.
Creando Base de Datos.
Abrimos nuestro MySQL Workbench, que ya tendríamos de tener instalado junto con el MySQL y la instancia ya creada. Accedemos a “Local MySQL” como “root” indicando
contraseña si tenemos configurado de esa forma.
Ya dentro de la sesión hacemos clic sobre el icono de “Create a New Shema”, damos un nombre a la Base de Datos, en este caso “proyecto”, clic en “Apply”, nuevamente
“Apply” y listo, ya tenemos nuestra Base de Datos. Las tablas las creará el Hibernate. (Img. db 1).
Realizando la conexión y configuración de hibernate.cfg.
Al configurar el hibernate.cfg también configuramos la conexión con la Base de Datos. Lo cual quiere decir que la misma queda a cargo del Hibernate. Desplegamos el
proyecto, hacemos clic sobre “Paquetes de fuentes – Nuevo – Otros”. Dentro de categorías seleccionamos “Hibernar”, en “Tipos de Archivos” indicamos “Asistente de
configuración de Hibernate” y clic en “Siguiente” (Img. 3).
En la pantalla que aparece dejamos todo como está “Nombre de archivo: hibernate.cfg” “Carpeta: src”, este último indica que se guarda dentro del paquete predeterminado y
no dentro de las que hemos creado. (Img. 4)
Pantalla siguiente “Selecciones Data Source”. Dentro de “Conexión con base de datos” indicamos “Nueva Conexión de Base de Datos…” y se despliega la ventana “New
Connection Wizard”. En este apartado indicamos “MySQL (Connector/J driver)” y clic en siguiente. (Img. 5)
Pantalla siguiente “Customize Connection” rellenamos como indica la imagen, “Base de Datos: proyecto” “Nombre de Usuario: root” “Contraseña:“ la que hayamos
establecido al crear la instancia de MySQL. Hacemos clic en “Test Connection” y si todo ha ido bien el mensaje será “Connection Succeeded”. Clic en “Siguiente” y a la
pantalla siguiente “Terminar”. (Img. 6)
Todo este proceso nos crea el archivo “hibernate.cfg” la cual iremos modificando según las necesidades.
Por último hacemos una pequeña edición al “hibernate.cfg” que nos agrega dos líneas de código más. Quedando como se muestra en la imagen. Esto lo hacemos dentro de
“Propiedades varias” y clic en “Agregar”. (Img. 7)
Creando la clase HibernateUtil.java.
Esta clase es la que nos crea sesiones a la nuestra fuente de datos, en este caso MySQL. Para esto utiliza el “hibernate.cfg” que creamos con anterioridad.
Pasos: Hacemos clic derecho sobre “Paquetes de fuentes – Nuevo – Otros”. Dentro de categorías seleccionamos “Hibernar”, en “Tipos de Archivos” indicamos
“HibernateUtil.java” y clic en “Siguiente” (Img. 8).
Siguiente paso configuramos “Nombre y Ubicación”, “Nombre de Clase: HibernateUtil”, “Paquete: util” que creamos anteriormente (Img. 9).
Clic en “Terminar”, nos abre la clase con los códigos prestablecidos, no hay nada para modificar: ej.
package util;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.SessionFactory;
/**
* Hibernate Utility class with a convenient method to get Session Factory object.
*
* @author Ariel
*/
public class HibernateUtil {
private static final SessionFactory sessionFactory;
static {
try {
// Create the SessionFactory from standard (hibernate.cfg.xml)
// config file.
sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();
} catch (Throwable ex) {
// Log the exception.
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}
public static SessionFactory getSessionFactory() {

return sessionFactory;
}
}
004 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. Creando clases persistentes.
En la siguiente imagen pueden ver el modelo de datos que utilizaremos para nuestra aplicación. Este modelo los traduciremos en clases persistentes que utilizaremos para
manejar todo tipo de transacciones. (Mod. 1)
Empezamos por lo fácil, creando la clase persistente “Tipo”. Este representa la tabla “tipo” del modelo de datos, cada registro de esta representa un grupo de artículos
filtrados por; como su nombre índica “tipo” de artículos. La relación entre “Tipo” y “Articulo” es de “Uno a Muchos bidireccional”. Con esto podemos navegar de ambas tabla
viendo esto desde la perspectiva de MySQL, ej., podemos obtener un registro “Tipo” y a través de esta utilizando listas de todos los “Articulos” relacionadas a la misma. Las
clases las crearemos de a uno, por tanto mientras no estén todas Java indicaré ciertos errores, esto por la relación que hay entre las clases persistentes. Empecemos.
Pasos previos. Estas serán iguales para crea cada una de las clases persistentes.
Debemos hacer clic derecho sobre el paquete “com.entidades” que hemos creado con anterioridad, clic en “Nuevo” y en “Clase Java…” (Img. 01).
En la pantalla siguiente indicamos el “Nombre de Clase”; si creamos la clase como se indica, en “Paquete” no mostrará el nombre “com.entidades”. Por último clic en
“Terminar” (Img. 02).
Esta nos crea una plantilla con el paquete a la que pertenece la clase y nombre de esta. (Img. 03) Esta plantilla es la que modificaremos para que funcione como clase
persistente.
Clase persistente “Tipo.java”.
package com.entidades;
import java.io.Serializable;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
/**
* @author ariel
*/
@Entity
public class Tipo implements Serializable {
private List<Articulo> articulos = new ArrayList<Articulo>();

private int id;
private String des;
@Column(length=50)
public String getDes() {
return des;
public void setDes(String des) {
this.des = des;
@Id
@GeneratedValue(strategy= GenerationType.IDENTITY)
return id;
this.id = id;
}
@OneToMany(mappedBy = "tipo",cascade= CascadeType.ALL)
public List<Articulo> getArticulos() {
return articulos;
public void setArticulos(List<Articulo> articulos) {
this.articulos = articulos;
Explicación de algunos detalles.
Imagen(04)
 (1) Nos indica el paquete a la que pertenece la clase.
 (2) Muestra la lista de importaciones que requiere la clase para que funcione.
Imagen(05)
Antes que nada debemos saber que cada variable privada de la clase debe tener un par de “Setters y Getters” para tener acceso a ellas. Todas las anotaciones JPA se
realizan sobre las líneas de los “Getters”.
 (1) “@Entity” es una anotación con JPA, la cual indica que la clase representa una entidad.
 (2) Toda clase que sea persistente debe implementar la interfaz “Serializable”. Es lo que indicamos en esta línea.
 (3) En esta línea indicamos una variables de tipo “List”, ya que la clase “Tipo” como tiene relación con la clase “Articulo” (que la crearemos) de “Uno-a-Mucho”
bidireccional debe crea una variable de tipo “java.util.List” lo cual nos indica que una clase “Tipo” puede relacionarse con una lista de clases “Articulo”.
 (4) “@Column(length=50)” con esta anotación indicamos que la columna “des” que esta debajo posee una extensión de 50 caracteres.
 (5) “@Id” anotación que indica que la columna, en este caso “id” es la que será la llave primaria dentro de la tabla.
 (6) “@GeneratedValue(strategy= GenerationType.IDENTITY)” estamos indicando con esta anotación que el “Id” se va ha generar de forma automática o mejor
dicho de tipo autoincremental. Con esto no tendremos que preocuparnos del valor que pueda tomar la llave primaria. Es importante ya que los valores se generan de forma
secuencial por tanto no hay posibilidad que se repitan. Como sabemos las llaves primarias deben ser únicas.
 (7) “@OneToMany(mappedBy = "tipo",cascade= CascadeType.ALL)” en esta línea estamos indicando expresamente el tipo de relación que va tener la clase
“Tipo” con la clase “Artículo” y que variable del otro lado (Articulo) va representar a la clase “Tipo” (mappedBy = "tipo"). También indicamos el tipo de actualización de la
relación con la línea (cascade= CascadeType.ALL), esto quiere decir que si eliminamos un registro del lado de “Tipo” también se eliminan todos los registro del lado de
“Artículo” que estén relacionado con esta. Es importante para no dejar registros huérfanos o similares.
Clase persistente “Articulo.java”.
import javax.persistence.ManyToOne;
/**
*
* @author Toshiba
*/
@Entity
public class Articulo implements Serializable {
private int id;
private String des;
private int pco;
private int por;
private int pve;
private int can;
private Tipo tipo;
public int getCan() {
return can;
public void setCan(int can) {
this.can = can;
return des;
}
this.des = des;
@Id
return id;
this.id = id;
public int getPco() {
return pco;
public void setPco(int pco) {
this.pco = pco;
}
public int getPor() {
return por;
public void setPor(int por) {
this.por = por;
public int getPve() {
return pve;
public void setPve(int pve) {
this.pve = pve;
@ManyToOne
public Tipo getTipo() {
return tipo;
}
public void setTipo(Tipo tipo) {
this.tipo = tipo;
Solo explicaremos algunas de las anotaciones que sean diferentes a las anotaciones de la anterior “Clase” que ya hemos explicado o que puedan ser de interés especial.
Imagen(06)
 (1) Declaramos una variable privada de “Tipo” con nombre “tipo” la cual representa a la clase “Tipo” con la cual esta clase “Articulo” posee una relación. Como del lado de
“Articulo” varios registros pueden relacionarse con un solo registro “Tipo” esta no se representa como una lista, como se hizo en la clase anterior.
Imagen(07)
 (1) “@ManyToOne” con esta anotación indicamos que del lado la Clase “Articulo” serán muchos registros relacionados con una del lado de la Clase “Tipo”. Como vemos
no se ha indicado la anotación ((mappedBy = "tipo",cascade= CascadeType.ALL) que teníamos en la clase “Tipo”. Esto es porque siempre del lado
del (OneToMany) se toma el control de la relación, quedando el (ManyToOne) como dependiente.
Clase persistente “Cliente.java”.
/**
* @author Ariel
*/
@Entity
public class Cliente implements Serializable {
private List<VentaCab> ventaCabs = new ArrayList<VentaCab>();
private int id;
private String des;
private String dir;
private String tel;
private String ruc;
return des;
this.des = des;

return dir;
this.dir = dir;
@Id
return id;
this.id = id;
public String getRuc() {
return ruc;
public void setRuc(String ruc) {

this.ruc = ruc;
public String getTel() {
return tel;
public void setTel(String tel) {
this.tel = tel;
@OneToMany(mappedBy = "cliente")
public List<VentaCab> getVentaCabs() {
return ventaCabs;
public void setVentaCabs(List<VentaCab> ventaCabs) {
this.ventaCabs = ventaCabs;
}
Como podemos ver esta clase posee una única relación de tipo (OneToMany), que ya se ha explicado con anterioridad. La diferencia sería que no posee la
anotación (cascade= CascadeType.ALL) ya que la relación es con la Clase que representa “Venta”, cuyos registro no deberían eliminarse.
Clase persistente “Funcionario.java”.
/**
* @author Ariel
*/
@Entity
public class Funcionario implements Serializable {
private List<CompraCab> compraCabs = new ArrayList<CompraCab>();

private List<VentaCab> ventaCabs = new ArrayList<VentaCab>();
private int id;
private String nombres;
private String apellidos;
private String dir;
private String tel;
private String cargo;
public String getApellidos() {
return apellidos;
public void setApellidos(String apellidos) {
this.apellidos = apellidos;
public String getCargo() {
return cargo;
public void setCargo(String cargo) {
this.cargo = cargo;
}
return dir;
this.dir = dir;
@Id
return id;
this.id = id;
public String getNombres() {
return nombres;
}
public void setNombres(String nombres) {
this.nombres = nombres;
return tel;
this.tel = tel;
@OneToMany(mappedBy = "funcionario")
public List<VentaCab> getVentaCabs() {
return ventaCabs;
public void setVentaCabs(List<VentaCab> ventaCabs) {
this.ventaCabs = ventaCabs;
}
@OneToMany(mappedBy = "funcionario")
public List<CompraCab> getCompraCabs() {
return compraCabs;
public void setCompraCabs(List<CompraCab> compraCabs) {
this.compraCabs = compraCabs;
Esta clase a diferencia de “Cliente” posee relación de tipo (OneToMany), con dos Clases que son las que representan “Compra” y “Venta”.
Clase persistente “Proveedor.java”.
/**
* @author Ariel
*/
@Entity
public class Proveedor implements Serializable {
private List<CompraCab> compraCabs = new ArrayList<CompraCab>();
private int id;
private String des;
private String dir;
private String tel;
return des;
}
this.des = des;
return dir;
this.dir = dir;
@Id
return id;
this.id = id;
}
return tel;
this.tel = tel;
@OneToMany(mappedBy = "proveedor")
public List<CompraCab> getCompraCabs() {
return compraCabs;
public void setCompraCabs(List<CompraCab> compraCabs) {
this.compraCabs = compraCabs;
Esta clase posee una relación de tipo (OneToMany) con la Clase que representa “Compra”. Tipo de relación que ya explicamos.
Clase persistente “VentaCab.java”.
import javax.persistence.Temporal;
/**
* @author Ariel
*/
@Entity
public class VentaCab implements Serializable {
private List<VentaDet> ventaDets = new ArrayList<VentaDet>();
private int num;
private Cliente cliente;
private Funcionario funcionario;
private Calendar fecha;
private String hora;
private long total;
public long getTotal() {
return total;
public void setTotal(long total) {
this.total = total;
@ManyToOne
public Cliente getCliente() {
return cliente;
}
public void setCliente(Cliente cliente) {
this.cliente = cliente;
@Temporal(javax.persistence.TemporalType.DATE)
public Calendar getFecha() {
return fecha;
public void setFecha(Calendar fecha) {
this.fecha = fecha;
@ManyToOne
public Funcionario getFuncionario() {
return funcionario;
public void setFuncionario(Funcionario funcionario) {
this.funcionario = funcionario;
}
public String getHora() {
return hora;
public void setHora(String hora) {
this.hora = hora;
@Id
public int getNum() {
return num;
public void setNum(int num) {
this.num = num;
@OneToMany(mappedBy = "ventaCab",cascade= CascadeType.ALL)
public List<VentaDet> getVentaDets() {
return ventaDets;
}
public void setVentaDets(List<VentaDet> ventaDets) {
this.ventaDets = ventaDets;
Clase que representa la cabecera de la Clase “Venta”. Como sabemos una transacción normalmente posee una tabla de tipo cabecera y otra de tipo detalle. En este caso la
diferencia es que estas son clases y nada más. Algo importante de mencionar es la línea que incluye el objeto tipo Calendar que declaramos (private Calendar fecha;). La
anotación para Calendar si utilizamos de ella fecha es como se indica (@Temporal(javax.persistence.TemporalType.DATE)). Si no indicamos como esta, podría
dar pie a errores.
Imagen(08)
 (1) “private List ventaDets = new ArrayList();” estamos indicando una relación a través de una variable de tipo “List” con una Clase que se llama “VentaDet”.
Esta relación es de tipo (OneToMany), con lo cual queremos decir que una venta cabecera puede contener varios detalles; las cuales almacenaremos en una lista.
 (2) Indicamos que hay una relación con la clase “Cliente”. Dicho de otra forma, cada venta se debe realizar a un cliente y nada más.
 (3) Indicamos que hay una relación con la clase “Funcionario”. Lo que vemos es que un funcionario debe ser responsable de realizar la venta.
Clase persistente “VentaDet.java”.
/**
* @author Ariel
*/
@Entity
public class VentaDet implements Serializable {
private int num;
private Articulo articulo;
private int cant;

private int importe;
private VentaCab ventaCab;
@ManyToOne
public Articulo getArticulo() {
return articulo;
public void setArticulo(Articulo articulo) {
this.articulo = articulo;
public int getImporte() {
return importe;
public void setImporte(int importe) {
this.importe = importe;
public int getCant() {
return cant;
}
public void setCant(int cant) {
this.cant = cant;
@Id
return num;
this.num = num;
@ManyToOne
public VentaCab getVentaCab() {
return ventaCab;
public void setVentaCab(VentaCab ventaCab) {
this.ventaCab = ventaCab;
}
En la Clase “VentaDet” vemos que hay una relación de tipo (ManyToOne) unidireccional con la clase “Articulo”. Con esto indicamos que un artículo puede relacionarse
como muchas clases “VentaDet”, pero que no hace falta indicar una relación desde la Clase “Articulo”. También vemos que hay una relación de
tipo (ManyToOne) bidireccional con la Clase “VentaCab”. Como indicamos más arriba una clase “VentaCab” puede contener varias Clases de tipo “VentaDet” y esta última
puede relacionarse con una sola Clase “VentaCab”. Como vemos hay una relación de dependencia.
Clase persistente “CompraCab.java”.
import javax.persistence.Temporal;
/**
* @author Ariel
*/
@Entity
public class CompraCab implements Serializable {
private List<CompraDet> compraDets = new ArrayList<CompraDet>();
private int id;
private int num;
private Proveedor proveedor;
private Funcionario funcionario;
private Calendar fecha;
private String hora;
private long total;
return num;
}
this.num = num;
@Temporal(javax.persistence.TemporalType.DATE)
public Calendar getFecha() {
return fecha;
public void setFecha(Calendar fecha) {
this.fecha = fecha;
@ManyToOne
public Funcionario getFuncionario() {
return funcionario;
public void setFuncionario(Funcionario funcionario) {

public String getHora() {
return hora;
public void setHora(String hora) {
this.hora = hora;
@Id
return id;
this.id = id;
}
@ManyToOne
public Proveedor getProveedor() {
return proveedor;
public void setProveedor(Proveedor proveedor) {
this.proveedor = proveedor;
public long getTotal() {
return total;
public void setTotal(long total) {
this.total = total;
@OneToMany(mappedBy = "cabecera",cascade= CascadeType.ALL)
public List<CompraDet> getCompraDets() {
return compraDets;
}
public void setCompraDets(List<CompraDet> compraDets) {
this.compraDets = compraDets;
Al igual que “VentaCab” la clase “CompraCab” representa la cabecera que corresponde a la transacción “Venta”. La Clase como se ve se relaciona con las Clases
“Funcionario” (ManyToOne), “Proveedor” también (ManyToOne) y con “VentaDet” que es de tipo (OneToMany). Al igual que en “VentaCab” para la fecha se utiliza el objeto
Calendar.
Clase persistente “CompraDet.java”.
/**
* @author Ariel
*/
@Entity
public class CompraDet implements Serializable {
private int id;
private CompraCab cabecera;
private Articulo articulo;
private int cantidad;
private long importe;
@ManyToOne
public Articulo getArticulo() {
return articulo;
public void setArticulo(Articulo articulo) {
}
@ManyToOne
public CompraCab getCabecera() {
return cabecera;
public void setCabecera(CompraCab cabecera) {
this.cabecera = cabecera;
public int getCantidad() {
return cantidad;
public void setCantidad(int cantidad) {
this.cantidad = cantidad;
@Id
return id;
}
this.id = id;
public long getImporte() {
return importe;
public void setImporte(long importe) {
La estructura de esta clase es prácticamente igual que la de “VentaDet”, la diferencia es que “CompraDet” tiene que realizar una actualización positiva del stock, dicho de
otra forma, se suman las cantidades a diferencia de la anterior.
Con esto último terminamos la creación de las clases persistentes. Lo siguiente será empezar a crear formularios y almacenar datos.
Al terminar de elaborar nuestras clases persistentes, tendremos que modificar el “hibernate.cfg” desde “Vista XML”, agregando las clases persistentes que hemos creado. El
“hibernate.cfg” deberá quedar de la siguiente forma. Imagen(09).
Imagen(09)
005 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. Datos importantes antes de crear
formularios.
Agregar bibliotecas.
Img. 1
Para el caso hacemos clic derecho sobre la carpeta “Bibliotecas” dentro del proyecto, y “Agregar biblioteca…”. Paso siguiente solo seleccionamos la que necesitemos y clic
en “Añadir biblioteca”.
Img. 2
A lo que corresponde a Hibernate, la misma biblioteca se agrega al crear el archivo “hibernate.cfg”. El “mysql-connector-java-5.1.13-bin.jar” en mi caso se
agrega también al crear la conexión con el DB, en casos especiales solamente debemos agregar el “jar” desde la carpeta de instalación del Netbeans.
Crear nuevas bibliotecas.
Para esto debemos dirigirnos a menú superior, clic en “Herramientas” y en “Bibliotecas”.
Img. 3
Se nos abre la ventana de “Administrador de bibliotecas”. Hacemos clic en “Nueva biblioteca…”. En la venta “Nueva biblioteca” establecemos “Nombre de Biblioteca”,
normalmente el nombre debería ser una que describa a la perfección su función o procedencia. “Tipo de biblioteca” queda sin cambios. Clic en “Aceptar”.
Img. 4
Ahora debemos agregar los “jar”, para eso seleccionamos nuestra Biblioteca desde la lista “Bibliotecas”, clic en “Agregar archivo JAR/Carpeta…”, seleccionamos las que
correspondan y las agregamos. Todo se ira mostrando dentro de la lista “Ruta de clases de la biblioteca”. Por último clic en “Aceptar”. Desde ahora podremos utilizar y
también podremos dado el caso agregar o eliminar “jar” de la biblioteca creada.
Img. 5
En cualquier proyecto, dado la extensión de la misma podremos agregar gran cantidad de bibliotecas. En la imagen las que corresponden a nuestro proyecto. Las cuales
iremos agregando según necesitemos.
Img. 6
Obs.: Resulta difícil explicar todo el proceso y función de cada línea de código por tanto pueden realizar un comentario con sus dudas.
006 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. Formulario referencial TipoApp.
Para crea un formulario que no sea principal recurriremos al “JDialog”, que es un tipo de formulario dependiente a diferencia del “JFrame”. Para ello hacemos clic derecho
sobre el paquete en donde almacenaremos los formularios, en este caso “com.app”, clic en “Otros” y rellenamos los datos y selección como se indica en la imagen (JDialog
1). En la siguiente pantalla, le damos un nombre en este caso “TipoApp” para diferenciar de la clase persistente “Tipo”. Clic en “Terminar” y empezamos a diseñar.
(JDialog 1)
Seguimos viendo el diseño del formulario y los componentes que incluyen.(img. 1)

(Img. 1)
Componentes.
 (1) JLabel que utilizamos para indicar con letras grandes y junto con un icono (se puede incluir iconos junto con el texto) una descripción del formulario.
 (2) JPanel para agrupar los JLabels y JTextFields importantes para el usuario.
 (3) JTextField para mostrar el id de la Clase Persistente “Tipo”, que ya se ha creado anteriormente. El usuario no requiere indicar un “id” ya que esta al crear la Clase
“Tipo” le indicamos al Hibernate que es auto-numérico.
 (4) JTextField para que el usuario indique una descripción para el tipo de articulo nuevo de desea crear. También según el caso el usuario podrá editar los datos de
registros ya almacenados.
 (5) JTable que nos permitirá visualizar los datos ya almacenados indicando por columnas “Código” y “Descripción”. “Código” corresponde al “Id” que en esencia son lo
mismo. También la tabla permite seleccionar registros específicos para poder editarlos como veremos.
 (6) JButtons que serían los botones de comando, las cuales como se ve en la imagen cumplen; cada una, un rol específico. Estos botones están dentro de un JPanel, ya
que esta permite manejarlas como un grupo.
 (7) “Fuente” y “Diseño”, las dos pestañas que nos permiten alternar entre “Vista de Diseño” y “Vista de Fuente”. En “Vista de Fuente” iremos agregando los métodos y
funciones que utilizaremos.
Lo siguiente es ver la distribución y nombre de cada uno de los componentes dentro del diseño. (img. 2)
(Img. 2)
Componentes.
 (1) JDialog que sería como el objeto padre que almacena todas las demás y sobre la que diseñamos.
 (2) JPanel la cual incluye todos los paneles y componentes que se agregan al formulario. Esto permite mover o copiar grupo de objetos de forma fácil.
 (3) JPanel que agrupa los JLabels y JTextFields.
 (4) jScrollPane para utilizar Scroll en la tabla, es automática. Al agregar la tabla se suele agregar también.
 (5) JPanel que nos permite agrupar los botones de comando del formulario.
 (6) JButtons dentro del JPanel.
Cambiar nombre de variables y textos visibles de objetos. (img. 3)
(Img. 3)
El menú se despliega haciendo clic derecho sobre el objeto específico.
 (1) Editar Texto esto nos permite cambiar el texto visible, como se ve en la imagen el nombre para cada JButton.
 (2) Cambiar nombre de variable… esta opción nos permite cambiar el nombre de variable de un objeto, la cual es la que utilizamos para llamarla desde cualquier método o
función que creemos. Por tanto es importante elegir un nombre de variable que sea definitorio de la función del objeto. (img. 4)
(Img. 4)
Como se ve en la imagen, se indican los nombres de variable que utilizaremos para los objetos con las que estaremos trabajando desde los métodos que crearemos. Esto
es importante para hacer los códigos más legibles.
Llamar métodos desde objetos específicos.
Para ello hacemos clic derecho sobre el objeto específico (JButton, JTextFields, etc), seleccionamos “Eventos”, y del menú desplegado la que estemos necesitando. Cada
evento funciona de una manera específica. Solo explicaremos las que vayamos utilizando dentro del proyecto. (img. 5)
(Img. 5)
Al seleccionar un “Evento”, NetBeans nos crea un método relacionado al objeto y evento específico; dentro de la cual agregaremos nuestro código o llamaremos métodos
para que se ejecuten. (img. 6)
(Img. 6)
También podremos ver los “Eventos” relacionado a un objeto específico, haciendo clic derecho sobre el objeto y en “Propiedades” y pestaña “Eventos”. Desde este lugar
podremos eliminar también los eventos que hayamos creado, seleccionado y “Suprimir”. Desde “Vista de Fuentes” no se pueden eliminar “Eventos”. (img. 7)
(Img. 7)
Importaciones necesarias.
La lista.
import com.entidades.Tipo;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.JasperReport;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
import net.sf.jasperreports.engine.util.JRLoader;
import net.sf.jasperreports.view.JasperViewer;
import org.hibernate.Session;
import util.HibernateUtil;
Esquema del código fuente a tomar en cuenta. (img. 8).

(Img. 8)
Los método que se muestran, las iremos creando, esto es para ver su desde que lugar de Código Fuente tendremos que llamarlos.
 (1) Lista de importaciones necesaria, se ubican en la zona de forma automática. Normalmente debe ir debajo del package.
 (2) (sessionHibernate();) Un método que llamamos dentro del “Método Constructor” del JDialog para que se ejecute al crearse el objeto “JDialog”. Este método no
permite crear lo que llamamos el “SessionFactory()” del Hibernate.
 (3) (arranque();) Al igual que la anterior se ejecuta al crease el objeto. Ya explicaremos su función.
 (4) (setLocationRelativeTo(null);) Método llamado también en el “Constructor”. Es un método que permite ubicar el JDialog en la pantalla, al pasarle “null”, la
deja centrado.
 (5) (private Session st;) Creamos una variable de clase tipo “Session” que nos permitirá guardar nuestra sesión del Hibernate y utilizarla en cualquiera de los
métodos que creemos.
 (6) (private DefaultTableModel model;) Variable de clase tipo “DefaultTableModel”, que ya explicaremos su función.
 (7) Zona en la que se ubican todos los “Eventos” que vayamos implementando.
 (8) (nuevo();) Ejemplo de cómo llamamos un “Método” desde un “Evento”.
La consideración importante es que cualquier método que queramos que se ejecute al crearse el formulario debemos de llamarlos desde el “Método Constructor”. Pero
siempre después del método “initComponents();” por regla.
Otras zonas de la “Vista de fuentes” importantes de mencionar. (img. 9)

(Img. 9)
 (1) Zona donde se declaran las variables de los objetos que creemos en el formulario. No se pueden modificar desde “Vista de Fuentes” solo desde “Vista de Diseño”.
 (2) Zona en la que de preferencia personal suelo ubicar los métodos que creo. Según tengo entendido con que sea fuera del “Método Constructor” se considera método de
clase. En un formulario nuevo, debemos desplazar la llave “}“ de cierre y empezar a escribir nuestro método que podremos utilizar en cualquier parte del código. Creando
Método y utilizando Eventos.
Método “sessionHibernate()”. (Recuerden que el nombre del método es relativo, con que sea un nombre definitorio, para diferenciar de otras.)
public void sessionHibernate(){

st = HibernateUtil.getSessionFactory().openSession();
}
Este método asigna a la variable “st” una “SessionFactory”, la cual utilizaremos para guardar, actualizar, recuperar y eliminar registros. Este método debemos llamar
desde el “Método Constructor” del JDialog.
Método “arranque()”.
public void arranque(){

this.des.setEnabled(false);
this.des.setText(null);
this.guardar.setEnabled(false);
this.informe.setEnabled(true);
this.guardar.setText("Guardar");
defaultTableModel();
cargarTabla();
}
Este método nos permite establecer que objeto del “Formulario” estarán habilitadas para su uso y que valores tendrán por defecto. Este método se llama desde el “Método
Constructor” y desde el “Botón Cancelar” utilizando el “Evento” “ActionPerformed” (img. 10). Un punto importante es que para los objetos JButton normalmente se utilizar el
“Evento” “ActionPerformed”. Para nuestro proyecto se sigue este esquema para todos los “JButton”. Más arriba explicamos como llamar métodos desde objetos específicos.
Este método también incluye los métodos “defaultTableModel()” y “cargarTabla()” que ya crearemos y explicaremos su función.
(Img. 10)
Método “defaultTableModel()”
public void defaultTableModel(){

model = (DefaultTableModel) this.jTable1.getModel();
}
Este método nos permite configurar el “DefaultTableModel”, la cual nos da la posibilidad de introducir y recuperar datos de la tabla. Se llama desde el
método “arranque()”.
Método “nuevo()”.

this.nuevo.setEnabled(false);
this.guardar.setEnabled(true);
this.des.setEnabled(true);
this.id.setText("Auto");
}
Es un método que llamamos desde el botón “Nuevo”, la cual nos habilita los campos necesarios para cargar datos. Recuerden que para botones siempre utilizamos el
“Evento” “ActionPerformed”.
Método cargarTabla();

st.beginTransaction();
List<Tipo> lista = (List<Tipo>)st.createQuery("From Tipo").list();
for (Iterator<Tipo> it = lista.iterator(); it.hasNext();) {
Tipo tipo = it.next();
tipo.getId(),tipo.getDes()
});
En este método utilizamos el “st.beginTransaction()”, la cual nos posibilita iniciar una transacción para almacenar o recuperar datos del MySQL. En la siguiente línea
vemos el procedimiento que se utiliza normalmente para recuperar datos de una tabla, utilizando “List”. Con un “for” accedemos a esos datos y con la
variable “model” del “DefaultTableModel”utilizando el método “addRow” agregamos registros en la tabla. Se llama desde el método “arranque()”.
Método “guardar()”.
public void guardar(){

if(this.des.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Imposible guardar campo vacio.");
}
else{
if(this.guardar.getText().equals("Guardar")){
Tipo t = new Tipo();
t.setDes(this.des.getText());
st.save(t);
st.getTransaction().commit();
JOptionPane.showMessageDialog(null, "Registro guardado.");
arranque();
}
else{
int selectedRow = this.jTable1.getSelectedRow();
Object valueAt = model.getValueAt(selectedRow, 0);
int idTipo = Integer.parseInt(valueAt.toString());
Tipo t = (Tipo) st.load(Tipo.class, idTipo);
t.setDes(this.des.getText());
st.update(t);
JOptionPane.showMessageDialog(null, "Registro actualizado.");
arranque();
}
}
}
Hacemos una captura para poder explicar a mayor detalle, ya que este método es la que nos permitirá almacenar y actualizar datos dentro del MySQL. (img. 11)
(Img. 11)
 (1) Comprobamos que el “JTextFields” cuyo nombre de variable es “des”, no este vacía.
 (2) Comprobamos que el “caption” del botón guardar sea “Guardar”, pues esta puede tomar dos valores, “Actualizar” y “Guardar” según el caso.
 (3) Iniciamos una transacción.
 (4) Creamos un objeto de la clase Tipo. “Tipo” es un clase persistente, al crear una instancia y asignarle valor a sus variables estamos creando un registro en MySQL.
 (5) Asignamos valor a la variable “des” de la clase persistente “Tipo” con el “método setter” de la misma.
 (6) Usamos el método “save()” de la Sesión pasando como argumento la clase Tipo que instanciamos.
 (7) Hacemos un “st.getTransaction().commit();” para confirmar la transacción. Como vieron el procedimiento es totalmente orientado a objetos. No recurrimos al SQL, pues
el Hibernate se encarga de negociar con la Base de Datos.
 (8) Le decimos al usuario que los datos fueron guardados.
 (9) Llamamos al “método arranque()” para restablecer el formulario y poder iniciar el proceso nuevamente.
 (10) Utilizamos el “else” en caso que no se den las condiciones del “if”.
 (11) Las siguientes líneas nos permiten recuperar el “id”, pues como indicamos arriba, en caso que de que el “caption” del botón guardar no sea “Guardar” querrá decir
que es “Actualizar”. Como sabemos solamente los registros que ya estén guardados se pueden actualizar.
 (12) Para recuperar un registro normalmente utilizamos el método “load”, pasándole como argumente la clase y el “id” de la misma, que recuperamos más arriba.
 (13) Asignamos valor nuevo a la variable “des” de la clase persistente “Tipo” con el “método setter” de la misma.
 (14) Utilizamos un “update” a diferencia de la anterior.
 (15) Confirmamos la transacción.
 (16) Indicamos al usuario que el proceso fue exitoso.
El método “guardar” se llama desde el botón “Guardar” con el “Evento” “ActionPerformed”.
Método “obtenerTabla()”.
public void obtenerTabla(){

int selectedRow = this.jTable1.getSelectedRow();//Obtenemos la fila seleccionada...
Object valueAt = model.getValueAt(selectedRow, 0);//Obtenemos el valor de esa fila...
int idTipo = Integer.parseInt(valueAt.toString());//Convertimos el valor en entero...
Tipo t = (Tipo) st.load(Tipo.class, idTipo);//Hacemos un load pasando como argumento la clase Tipo y el Id del mismo...
this.id.setText(String.valueOf(t.getId()));//Asignamos valor al JTextField id.
this.des.setText(t.getDes());//Asignamos valor al JTextField des.
this.editar.setEnabled(true);//Activamos el botón editar...
this.eliminar.setEnabled(true);//Activamos el botón eliminar...
this.nuevo.setEnabled(false);//Desactivamos el botón nuevo...
this.guardar.setText("Actualizar");//Cambiamos el de guardar...
}
Este método la llamamos desde el “Evento Mouse” – “MouseClicked” del JTable1. Con esto cada vez que el usuario haga clic sobre una de las fila de la tabla se pueda
recuperar el valor y pasarlos a los “JTextFields” correspondientes. Las explicaciones desde ahora, dentro de código fuente de forma comentada.
Método “editar()”.

this.guardar.setEnabled(true);//Activamos botón gurdar...
this.des.setEnabled(true);//Activamos JTextField des...
this.eliminar.setEnabled(false);//Desactivamos botón eliminar
this.jTable1.setEnabled(false);//Desactivamos el JTable
}
El método “guardar” se llama desde el botón “Editar” con el “Evento” “ActionPerformed”.
Método “eliminar()”.

int seleccion = JOptionPane.showConfirmDialog(null,"Desea eliminar el Registro.", "Eliminación de Registro.",
JOptionPane.YES_NO_OPTION);//Obtnemos la selección del usuario
if(seleccion == 1){//Comparamos la selección del usuario igual a 1 no eliminamos, si es diferente se elimina.
JOptionPane.showMessageDialog(null, "Registro no Eliminado...");
arranque();//Si no se elimina se llama al metodo arranque() para limpiar campos
}
else{//Opción eliminar seleccionada
st.beginTransaction();//Iniciamos transacción
int selectedRow = this.jTable1.getSelectedRow();//Obtenemos selección
Object valueAt = model.getValueAt(selectedRow, 0);//Recuperamos valor
int idTipo = Integer.parseInt(valueAt.toString());//Convertimos valor en entero
Tipo t = (Tipo) st.load(Tipo.class, idTipo);//Hacemos un load pasando como argumento la clase Tipo y el Id del
mismo...
st.delete(t);//Utilizamos delete pasando como argumento el objeto Tipo que cargamos con load...
st.getTransaction().commit();//Confirmamos la transacción...
JOptionPane.showMessageDialog(null, "Registro Eliminado...");//Indicamos al usuario que el proceso fue exitoso...
arranque();//Limpiamos campos con el metodo arranque()...
}
}
El método “eliminar” se llama desde el botón “Eliminar” con el “Evento” “ActionPerformed”.
Observación: El método para informe, lo dejamos para lo último del proyecto, ya que requiere utilizar el iReport.
En esta última imagen vemos el formulario en ejecución y funcionando. (Img. 12)
(Img. 12)
007 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. Formulario referencial
ArticuloApp.
En la imagen siguiente (img. 01) podemos ver el diseño de nuestro formulario para manejar Artículos. Las letras de color azul son anotaciones para indicar nombre de
variable del objeto específico, no se incluyen el diseño, es para referencia. Anteriormente ya vimos cómo cambiar nombre de variable de objetos.
(img. 01)
La imagen siguiente vemos las lista de importaciones necesaria. Estas siempre van después del "package". (import)
(import)
En la imagen siguiente (img. 02) se distinguen dos partes:
 1) nos indica los nombres de variables para los objetos que hemos agregado al formulario. Solo cambiamos las que tendremos que llamar en nuestros métodos.
 2) Lugar en la codificaremos nuestros métodos. En clase anterior vimos los lugares en las que ubicamos nuestros códigos personales.
(img. 02)
En la imagen siguiente (img. 03) podemos ver la lista de “Eventos” que vamos a utilizar para hacer funcionar nuestro formulario. En clase anterior vimos cómo utilizar
“Eventos”. Para cada evento se identifican tres partes importantes que tendremos que conocer:
 1) Nombre de variable del objeto al que está vinculado el “Evento”, (img. 01) nos indica los nombre de variables que le dimos a cada objeto, por lo tantos ya sabemos
desde donde se llama el “Evento”.
 2) Tipo de “Evento” que utilizamos para enlazar con el objeto. En este caso vemos que es un “ActionPerformed” la cual normalmente se utiliza con “Botones”.
 3) Ubicación de los códigos personalizados que aremos que se ejecuten al iniciarse el “Evento” generado por el objeto en particular.
(img. 03)
En la siguiente imagen (img. 04) vemos los métodos que llamamos desde el “Método Constructor” del formulario y la declaración de algunos variables de clase. La ubicación
de códigos personalizados ya vimos en clase anteriores.
(img. 04)
A continuación los métodos que utilizaremos para nuestro formulario. Cada uno posee un nombre particular que da una idea de la función que cumple, no hace falta mayor
explicación. La ubicación de los métodos y códigos personalizados ya vimos en clase anterior.
public void hibernateSession(){

}
cargarCombo();
this.tipo.setSelectedIndex(-1);
this.tipo.setEnabled(false);
this.pco.setText(null);
this.pco.setEnabled(false);
this.pve.setText(null);
this.por.setEnabled(false);
this.por.setText(null);
this.can.setText(null);
this.can.setEnabled(false);
tableModel();
cargarTabla();
}
}
public void cargarCombo(){
this.tipo.removeAllItems();
for(Tipo tipoList : lista){
this.tipo.addItem(tipoList.getDes());
}
}
List<Articulo> lista = (List<Articulo>)st.createQuery("From Articulo").list();
for(Articulo articuloList : lista){
articuloList.getId(),articuloList.getDes(),articuloList.getTipo().getDes(),articuloList.getPve()
});
}
}
this.tipo.setSelectedIndex(-1);
this.tipo.setEnabled(true);
this.pco.setEnabled(true);
this.por.setEnabled(true);
this.por.setText(null);
this.can.setEnabled(true);
}
JOptionPane.showMessageDialog(null, "Rellene Descripcion del Artículo.");
}
else{
if(this.tipo.getSelectedIndex()==-1){
JOptionPane.showMessageDialog(null, "Rellene Tipo de Articulo,");
}
else{
if(this.pco.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Indique el precio de compra.");
}
else{
if(this.por.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Rellene porcentaje de ganancia.");
}
else{
if(this.pve.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Rellene precio de venta.");
}
else{
if(this.can.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Rellene la cantidad.");
}
else{
try {
String desArt = this.des.getText();
Object selectedItem = this.tipo.getSelectedItem();
Tipo retornoTipo = retornoTipo(selectedItem.toString());
int pCompra = 0;
try {
pCompra = Integer.parseInt(this.pco.getText());
JOptionPane.showMessageDialog(null, "Precio de compra debe ser numérico.");
}
int pVenta = 0;
try {
pVenta = Integer.parseInt(this.pve.getText());
JOptionPane.showMessageDialog(null, "Precio de venta debe ser numérico.");
}
int porcentaje = 0;
try {
porcentaje = Integer.parseInt(this.por.getText());
JOptionPane.showMessageDialog(null, "Porcentaje debe ser numérico.");
}
int cantidad = 0;
try {
cantidad = Integer.parseInt(this.can.getText());
JOptionPane.showMessageDialog(null, "Cantidad debe ser numérico.");
}
Articulo art = new Articulo();
art.setDes(desArt);
art.setTipo(retornoTipo);
art.setPco(pCompra);
art.setPve(pVenta);
art.setPor(porcentaje);
art.setCan(cantidad);
retornoTipo.getArticulos().add(art);
st.save(art);
st.update(retornoTipo);
JOptionPane.showMessageDialog(null, "Artículo guardado correctamente.");
arranque();
JOptionPane.showMessageDialog(null, "Error guardando");
}
}
else{
String desArt = this.des.getText();
Object selectedItem = this.tipo.getSelectedItem();
Tipo retornoTipo = retornoTipo(selectedItem.toString());
int pCompra = 0;
try {
JOptionPane.showMessageDialog(null, "Precio de compra debe ser numérico.");
}
int pVenta = 0;
try {
JOptionPane.showMessageDialog(null, "Precio de venta debe ser numérico.");
}
int porcentaje = 0;
try {
porcentaje = Integer.parseInt(this.por.getText());
JOptionPane.showMessageDialog(null, "Porcentaje debe ser numérico.");
}
int cantidad = 0;
try {
cantidad = Integer.parseInt(this.can.getText());
JOptionPane.showMessageDialog(null, "Cantidad debe ser numérico.");
}
int parseInt = Integer.parseInt(this.id.getText());
Articulo art =(Articulo) st.load(Articulo.class, parseInt);
art.setDes(desArt);
art.setTipo(retornoTipo);
art.setPco(pCompra);
art.setPve(pVenta);
art.setPor(porcentaje);
art.setCan(cantidad);
retornoTipo.getArticulos().add(art);
st.update(art);
st.update(retornoTipo);
JOptionPane.showMessageDialog(null, "Artículo actualizado correctamente.");
arranque();
}
}
}
}
}
}
}
}
public Tipo retornoTipo(String desT){
Tipo tipRet = null;
String desTipo = desT;
try {
Query query = st.createQuery("From Tipo t Where t. des = ?");
query.setParameter(0, desTipo);
try {
tipRet = (Tipo)query.uniqueResult();
JOptionPane.showMessageDialog(null, "Hay más articulos de tipo: " + desTipo);
}
}
return tipRet;
}
public void auxiliarCalculoDos(){

int total = 0;
int pCompra = 0;
int porcent = 0;
if(this.pco.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "No se ha establecido precio de compra.");
this.pco.setRequestFocusEnabled(true);
}
else{
if(!this.por.getText().isEmpty()){
try {
JOptionPane.showMessageDialog(null,this.pco.getText() + " No es numérico.");
}
try {
porcent = Integer.parseInt(this.por.getText());
JOptionPane.showMessageDialog(null,this.por.getText() + " No es numérico.");
}
try {
total = (pCompra + ((pCompra*porcent)/100));
this.pve.setText(String.valueOf(total));
JOptionPane.showMessageDialog(null, "Error: Datos incorrectos.");
}
}
}
}
public void retornarArticulo(){
if(this.jTable1.isEnabled()){
int idArt = Integer.parseInt(valueAt.toString());
Articulo art = (Articulo)st.load(Articulo.class, idArt);
this.id.setText(String.valueOf(art.getId()));
this.des.setText(art.getDes());
this.tipo.setSelectedItem(art.getTipo().getDes());
this.pco.setText(String.valueOf(art.getPco()));
this.pve.setText(String.valueOf(art.getPve()));
this.por.setText(String.valueOf(art.getPor()));
this.can.setText(String.valueOf(art.getCan()));
this.editar.setEnabled(true);
this.eliminar.setEnabled(true);
}
}
this.tipo.setEnabled(true);
this.pco.setEnabled(true);
this.pve.setEnabled(true);
this.por.setEnabled(true);
this.can.setEnabled(true);
this.guardar.setText("Actualizar");
this.jTable1.setEnabled(false);
}
int showConfirmDialog = JOptionPane.showConfirmDialog(null, "Eliminación de Registro", "Desea eliminar este registro.",
if(showConfirmDialog == 1){
JOptionPane.showMessageDialog(null, "Registro no eliminado.");
}
else{
Articulo art = (Articulo)st.load(Articulo.class, idArt);
st.delete(art);
JOptionPane.showMessageDialog(null, "Registro eliminado.");
arranque();
}
Imagen de formulario en ejecusión.(img. 05)

(img. 05)
008 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. Formulario referencial ClienteApp.
Empezamos viendo el diseño del formulario y con letras en rojo el nombre de variable que tendrán los objetos indicados. En clase anterior vimos como indicar nombre de
variables específico a objetos. (img. 01)
(img. 01)
En la siguiente imagen vemos la lista de importaciones necesarias. Siempre va después del “package”. También vemos los métodos que tendremos que llamar desde el
constructor y las variables de clase que necesitamos declarar. (img. 02)
(img. 02)
Siguiente imagen (img. 03) vemos los eventos que tendremos que utilizar. La forma de utilizar “Eventos” ya vimos anteriormente. Ejemplo: el evento “nuevoActionPerformed”
se divide en dos partes “nuevo” que es el nombre de variable del objeto en particular y “ActionPerformed” el evento que estamos utilizando.
(img. 03)
A continuación vemos los “Métodos” que vamos a crear para hacer funcionar nuestro programa. Como siempre, el nombre de cada uno nos da una idea de la función que
cumple.

}
this.tel.setEnabled(false);
this.tel.setText(null);
this.ruc.setEnabled(false);
this.ruc.setText(null);
tableModel();
cargarTabla();
}
}
List<Cliente> lista = (List<Cliente>)st.createQuery("From Cliente").list();
for(Cliente clie : lista){
clie.getId(),clie.getDes(),clie.getDir(),clie.getTel(),clie.getRuc()
});
}
}
this.tel.setEnabled(true);
this.ruc.setEnabled(true);
this.ruc.setText(null);
}
public void guardarUno(){
JOptionPane.showMessageDialog(null, "Falta descripción del cliente.");
}
else{
if((this.dir.getText().isEmpty()) || (this.tel.getText().isEmpty() || (this.ruc.getText().isEmpty()))){
this.dir.setText("-");
this.tel.setText("-");
this.ruc.setText("-");
guardarDos();
}
else{
guardarDos();
}
}
}
public void guardarDos(){
Cliente clie = new Cliente();
clie.setDes(this.des.getText());
clie.setDir(this.dir.getText());
clie.setTel(this.tel.getText());
clie.setRuc(this.ruc.getText());
st.save(clie);
JOptionPane.showMessageDialog(null, "Registro de cliente guardado.");
cargarTabla();
arranque();
}
else{
int idClie = Integer.parseInt(String.valueOf(model.getValueAt(selectedRow, 0)));
Cliente clie = (Cliente)st.load(Cliente.class, idClie);
clie.setDes(this.des.getText());
clie.setDir(this.dir.getText());
clie.setTel(this.tel.getText());
clie.setRuc(this.ruc.getText());
st.update(clie);
JOptionPane.showMessageDialog(null, "Registro de cliente actualizado.");
cargarTabla();
arranque();
}
}
public void cargarCliente(){
int idClie = Integer.parseInt(String.valueOf(model.getValueAt(selectedRow, 0)));
Cliente clie = (Cliente)st.load(Cliente.class, idClie);
this.id.setText(String.valueOf(clie.getId()));
this.des.setText(clie.getDes());
this.dir.setText(clie.getDir());
this.tel.setText(clie.getTel());
this.ruc.setText(clie.getRuc());
}
}
this.ruc.setEnabled(true);
}
}
else{
Cliente clie = (Cliente)st.load(Cliente.class, idArt);
st.delete(clie);
arranque();
}
}
Por último vemos el formulario en ejecución y funcionando. (img. 4)
(img. 04)
009 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. Formulario referencial
FuncionarioApp.
Como siempre lo primero será diseñar el formulario. La imagen siguiente podemos ver cómo queda la misma y en letra roja en nombre de variable para cada objeto
designado. (img. 01)
(img. 01)
Un punto importante será rellenar el “JComboBox” al cual le dimos como nombre de variable “cargo” y será lo que contenga, la lista de cargos que puede poseer un
empleado, esto según nuestro criterio. Esto podemos hacerlo modificando la propiedad “model” del objeto, como nos indica la imagen; agregando ítems entre “comas”, cada
ítem representa una opción en la lista desplegable. (img. 02)
(img. 02)
En la imagen siguiente (img. 03) podemos ver las importaciones que agregamos para hacer funcionar nuestro formulario. También vemos los métodos que llamamos desde
el constructor de la clase, que como sabemos se ejecutan al crear el formulario. Y las variables de clase que necesitaremos.
(img. 03)
En la imagen siguiente (img. 04) vemos los eventos que utilizaremos. Como ya vimos en anteriores tutoriales, debemos de saber cómo implementarlas y sobre que objetos.
(img. 04)
Lo siguiente es el código fuente de todos los métodos que utilizaremos para darle vida a nuestro formulario. Cada cual se ejecuta para cumplir una función ya sea desde el
constructor, eventos o desde otros métodos. El nombre asignado a cada método da una idea de la función que cumplen. En tutoriales anterior pudimos ver el funcionamiento
de algunas líneas de código de forma más detallada, que normalmente son similares en cada formulario, por tanto ya tendremos una idea de las mismas.

}
this.nombres.setText(null);
this.nombres.setEnabled(false);
this.apellidos.setText(null);
this.apellidos.setEnabled(false);
this.cargo.setEnabled(false);
this.cargo.setSelectedIndex(-1);
tableModel();
cargarTabla();
}
}
List<Funcionario> lista = (List<Funcionario>)st.createQuery("From Funcionario").list();
for(Funcionario func : lista){
String nomApe = func.getNombres()+ " " + func.getApellidos();
func.getId(),nomApe,func.getDir(),func.getTel(),func.getCargo()
});
}
}
this.nombres.setEnabled(true);
this.apellidos.setEnabled(true);
this.cargo.setEnabled(true);
}
if(this.nombres.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Falta nombre/s del Funcionario.");
}
else{
if(this.apellidos.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Falta apellido/s del Funcionario.");
}
else{
if(this.dir.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Falta direccion del Funcionario.");
}
else{
if(this.tel.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Falta teléfono del Funcionario.");
}
else{
if(this.cargo.getSelectedIndex()==-1){
JOptionPane.showMessageDialog(null, "Falta cargo del Funcionario.");
}
else{
Funcionario func = new Funcionario();
func.setNombres(this.nombres.getText());
func.setApellidos(this.apellidos.getText());
func.setDir(this.dir.getText());
func.setTel(this.tel.getText());
func.setCargo(String.valueOf(this.cargo.getSelectedItem()));
st.save(func);
arranque();
JOptionPane.showMessageDialog(null, "Registro guardado correctamente.");
}
else{
int idFunc = Integer.parseInt(String.valueOf(model.getValueAt(selectedRow, 0)));
Funcionario func = (Funcionario)st.load(Funcionario.class, idFunc);
func.setNombres(this.nombres.getText());
func.setApellidos(this.apellidos.getText());
func.setDir(this.dir.getText());
func.setTel(this.tel.getText());
func.setCargo(String.valueOf(this.cargo.getSelectedItem()));
st.update(func);
arranque();
JOptionPane.showMessageDialog(null, "Registro actualizado correctamente.");
}
}
}
}
}
}
}
public void obtenerFuncionario(){
int idFunc = Integer.parseInt(String.valueOf(model.getValueAt(selectedRow, 0)));
Funcionario func = (Funcionario)st.load(Funcionario.class, idFunc);
this.id.setText(String.valueOf(func.getId()));
this.nombres.setText(func.getNombres());
this.apellidos.setText(func.getApellidos());
this.dir.setText(func.getDir());
this.tel.setText(func.getTel());
this.cargo.setSelectedItem(func.getCargo());
}
}
this.nombres.setEnabled(true);
this.apellidos.setEnabled(true);
this.cargo.setEnabled(true);
}
}
else{
Funcionario func = (Funcionario)st.load(Funcionario.class, idArt);
st.delete(func);
arranque();
}
Por último el formulario en ejecución. (img. 05)

(img. 05)
010 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. Formulario transaccional
VentaApp.
La primera imagen (img. 01), nos muestra el diseño que tendrán nuestro formulario de Ventas. Indicada en letras rojas, el nombre de variable que le asignamos a cada
objeto, esto es importante para ajustarlas los más posible a los métodos que presentaremos más adelante. Se indica cómo cambiar nombre de variables de objetos en los
primeros tutoriales.
Obs.: En los primeros tutoriales ya vimos cómo crear formularios y demás.
La segunda imagen (img. 02) nos muestra las importaciones necesarias, los métodos que se ejecutan al arrancar el formulario y las variables de clase necesarias para tener
acceso a datos desde cualquier método del formulario.
En forma de código vemos los “Eventos” que utilizaremos y los objetos a los que están encadenados. Utilizamos el evento “ActionPerformed” para llamar los métodos desde
los botones. Para los campos de texto utilizamos el evento “KeyPressed”, específicamente se ejecuta la acción al presionar la tecla “Enter” o “Intro”. Para utilizar un “Evento”
hacemos clic derecho sobre el objeto y seleccionamos “Eventos” de la lista utilizamos la que podamos aplicar al objeto. En la lista de evento vemos los comentarios
especificando a que objetos se aplican.
nuevo();// Evento ActionPerformed para botón nuevo.
}

arranque();// Evento ActionPerformed para botón cancelar.
}

agregar();// Evento ActionPerformed para botón agregar.
private void idKeyPressed(java.awt.event.KeyEvent evt) {

//Uso del Evento KeyPressed dentro del campo de texto "id".
if(evt.getKeyCode()== KeyEvent.VK_ENTER){
buscarFuncionario();
}
}
private void idClieKeyPressed(java.awt.event.KeyEvent evt) {

//Uso del Evento KeyPressed dentro del campo de texto "idClie".
if(evt.getKeyCode() == KeyEvent.VK_ENTER){
buscarCliente();
}
}
private void idArtKeyPressed(java.awt.event.KeyEvent evt) {

//Uso del Evento KeyPressed dentro del campo de texto "idArt".
buscarArticulo();
}
}
private void cantidadKeyPressed(java.awt.event.KeyEvent evt) {

//Uso del Evento KeyPressed dentro del campo de texto "cantidad".
calcularParcial();
}
}

eliminar();// Evento ActionPerformed para botón eliminar.
}
guardar();// Evento ActionPerformed para botón guardar.
}
Vemos más abajo la lista de métodos que le dan vida al formulario, el nombre de cada método nos da una idea del funcionamiento que cumplen. En los primeros tutoriales
indicamos el funcionamiento en profundidad de algunos métodos comunes que se utilizan en un ABM como en transacciones.

}
this.fecha.setText(null);
this.hora.setText(null);
this.idClie.setText(null);
this.idClie.setEnabled(false);
this.idArt.setText(null);
this.idArt.setEnabled(false);
this.desArt.setText(null);
this.cantidad.setText(null);
this.cantidad.setEnabled(false);
this.total.setText(null);
this.totalGeneral.setText(null);
tableModel();
}
}
obtenetID();
this.id.setEnabled(true);
this.idClie.setEnabled(true);
this.idArt.setEnabled(true);
this.cantidad.setEnabled(true);
this.id.requestFocus();
String calString = retornarString(cal);
String calHora = retornarStringHora(cal);
this.fecha.setText(calString);
this.num.setText(String.valueOf(numVenta));
this.hora.setText(calHora);
}
public void obtenetID(){
numVenta = 0;
List<VentaCab> lista = (List<VentaCab>)st.createQuery("From VentaCab").list();
for (Iterator<VentaCab> it = lista.iterator(); it.hasNext();) {
VentaCab ventaCab = it.next();
numVenta = ventaCab.getNum() + 1;
}
if(numVenta==0){
numVenta=1;
}
}
public void buscarArticulo(){
int idArti = 0;
try {
try {
idArti = Integer.parseInt(this.idArt.getText());
JOptionPane.showMessageDialog(null, "ID debe ser numérico.");
}
Articulo art = (Articulo)st.load(Articulo.class, idArti);
this.desArt.setText(art.getDes());
this.pve.setText(String.valueOf(art.getPve()));
this.cantidad.requestFocus();
JOptionPane.showMessageDialog(null, "No hay artículo con ID: " + idArti);
}
}
public void calcularParcial(){
int canVent = 0;
int pVenta = 0;
int stock = 0;
int totalParcial = 0 ;
try {
canVent = Integer.parseInt(this.cantidad.getText());
stock = Integer.parseInt(this.can.getText());
if(stock < canVent){
JOptionPane.showMessageDialog(null, "Stock insuficiente.");
}
else{
totalParcial = canVent * pVenta;
this.total.setText(String.valueOf(totalParcial));
this.agregar.requestFocus();
}
JOptionPane.showMessageDialog(null, "Se requiere datos numérico.");
}
}
public void buscarFuncionario(){
int idFunc = 0;
try {
try {
idFunc = Integer.parseInt(this.id.getText());
}
Funcionario funcio = (Funcionario)st.load(Funcionario.class, idFunc);
this.nombres.setText(funcio.getNombres());
this.apellidos.setText(funcio.getApellidos());
this.idClie.requestFocus();
JOptionPane.showMessageDialog(null, "No hay funcionario con ID: " + idFunc);
}
}
public void buscarCliente(){
int idCl = 0;
try {
try {
idCl = Integer.parseInt(this.idClie.getText());
}
Cliente clie = (Cliente)st.load(Cliente.class, idCl);
this.des.setText(clie.getDes());
this.ruc.setText(clie.getRuc());
this.idArt.requestFocus();
JOptionPane.showMessageDialog(null, "No hay cliente con ID: " + idCl);
}
}
if(this.id.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Seleccione un funcionario.");
}
else{
if(this.idClie.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Seleccione un cliente.");
}
else{
if(this.idArt.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Seleccione un articulo.");
}
else{
if(this.cantidad.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Indique una cantidad.");
}
else{
verificar();
if(var>=1){
int showConfirmDialog = JOptionPane.showConfirmDialog(null, "Artículo ya Agregado. Desea sumar la
cantidad.", "Mensaje del Sistema.", JOptionPane.YES_NO_OPTION);
if(showConfirmDialog==0){
sumarRepetido();
calcular();
confimAgregar();
limpiar();
}
else{
limpiar();
}
}
else{
this.idArt.getText(),this.desArt.getText(),this.pve.getText(),this.cantidad.getText(),this.total.getText()
});
calcular();
confimAgregar();
limpiar();
}
}
}
}
}
}
public void confimAgregar(){
int showConfirmDialog = JOptionPane.showConfirmDialog(null, "Agregar más Articulos.", "Mensaje del Sistema.",
}
else{
this.guardar.requestFocus();
}
}
this.idClie.setEnabled(false);
}
int totalG = 0;
totalG += Integer.parseInt(valueAt.toString());
}
this.totalGeneral.setText(String.valueOf(totalG));
}
public void verificar(){
var = 0;
int idAr = Integer.parseInt(this.idArt.getText());
if(this.jTable1.getRowCount()>=1){
int parseInt = Integer.parseInt(valueAt.toString());
if(idAr == parseInt){
var = 1;
idArtt = i;
}
}
}
}
public void sumarRepetido(){
int artCant = Integer.parseInt(this.cantidad.getText());
int artTotal = Integer.parseInt(this.total.getText());
Object valueAt = model.getValueAt(idArtt, 3);
Object valueAt1 = model.getValueAt(idArtt, 4);
int cantArt = Integer.parseInt(valueAt.toString());
int totalArt = Integer.parseInt(valueAt1.toString());
int x = artCant + cantArt;
int y = artTotal + totalArt;
int t = Integer.parseInt(this.can.getText());
if(t>=x){
model.setValueAt(x, idArtt, 3);
model.setValueAt(y, idArtt, 4);
}
else{
JOptionPane.showMessageDialog(null, "Stock de artículos insuficiente.");
}

}
return retorno;
}
}
return retorno;
}
try {
}
return cal;
}
if(this.jTable1.getSelectedRow()==-1){
JOptionPane.showMessageDialog(null, "No ha seleccionado ninguna fila de la tabla.");
}
else{
int showConfirmDialog = JOptionPane.showConfirmDialog(null, "Eliminar fila seleccionada.", "Mensaje del Sistema.",
int sel = this.jTable1.getSelectedRow();
}
else{
}
}
}
if(this.id.getText().isEmpty() ||this.idClie.getText().isEmpty() ){
JOptionPane.showMessageDialog(null, "Faltan datos para guardar. Verifique.");
}
else{
if(this.jTable1.getRowCount()==0){
JOptionPane.showMessageDialog(null, "No hay datos para guardar.");
}
else{
int showConfirmDialog = JOptionPane.showConfirmDialog(null, "Desea guardar esta venta.", "Mensaje del Sistema.",
try {
VentaCab venta = new VentaCab();
int idFun = Integer.parseInt(this.id.getText());
int idCli = Integer.parseInt(this.idClie.getText());
long totalVenta = Long.parseLong(this.totalGeneral.getText());
Funcionario funcionario = (Funcionario)st.load(Funcionario.class, idFun);
Cliente cliente = (Cliente)st.load(Cliente.class, idCli);
Calendar fechaVenta = retornarCalendar(this.fecha.getText());
String horaVenta = this.hora.getText();
venta.setCliente(cliente);
venta.setFuncionario(funcionario);
venta.setFecha(fechaVenta);
venta.setHora(horaVenta);
venta.setTotal(totalVenta);
funcionario.getVentaCabs().add(venta);
cliente.getVentaCabs().add(venta);
int[] idArti = new int[rowCount];
int[] cantVenta = new int[rowCount];
VentaDet detalleVenta = new VentaDet();
int idArticulo = Integer.parseInt(String.valueOf(model.getValueAt(i, 0)));
idArti[i] = idArticulo;
Articulo ventaArticulo = (Articulo)st.load(Articulo.class, idArticulo);
int cantidadVenta = Integer.parseInt(String.valueOf(model.getValueAt(i, 3)));
cantVenta[i]= cantidadVenta;
int importeVenta = Integer.parseInt(String.valueOf(model.getValueAt(i, 4)));
detalleVenta.setArticulo(ventaArticulo);
detalleVenta.setCant(cantidadVenta);
detalleVenta.setImporte(importeVenta);
detalleVenta.setVentaCab(venta);
venta.getVentaDets().add(detalleVenta);
}
st.save(venta);
for (int i = 0; i < idArti.length; i++) {
actualizarStrock(cantVenta[i], idArti[i]);
}
arranque();
JOptionPane.showMessageDialog(null, "Venta guardada correctamente.");
JOptionPane.showMessageDialog(null, "Error guardando venta. Verifique.");
}
}
else{
}
}
}
}
public void actualizarStrock(int cantidadVendida, int idArticulo){
Articulo actualizar = (Articulo)st.load(Articulo.class, idArticulo);
int temp = actualizar.getCan() - cantidadVendida;
actualizar.setCan(temp);
st.update(actualizar);
}
En la última imagen vemos el formulario en ejecución. (img. 03)
011 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. Formulario referencial Proveedor.
Primeramente vemos el diseño final del formulario (img. 01), que como siempre es un “jDialog”. Ponemos en letra roja como referencia los nombre de variable para cada
objeto del diseño, esto es importante para que se ajusten a los métodos y eventos que vayamos creando. Se puede cambiar el “Nombre de variable” de cada objeto
haciendo clic derecho sobre el mismo y en el menú desplegable seleccionar “Cambiar nombre de variable…”.
"Clic, ampliar imagen..."
el constructor de la clase, que como sabemos se ejecutan al crear el formulario. Y las variables de clase que necesitaremos. Se agregan comentario para facilitar la
comprensión de ciertas líneas de código.
En la imagen siguiente (img. 03) vemos los eventos que utilizaremos. Como ya vimos en anteriores tutoriales, debemos de saber cómo implementarlas y sobre que objetos.
Obs.: Utilizamos el evento “ActionPerformed” para llamar los métodos desde los botones. Se utiliza el evento “MouseClicked” para el jTable. Para utilizar un “Evento”
hacemos clic derecho sobre el objeto y seleccionamos “Eventos” de la lista utilizamos la que podamos aplicar al objeto. En la mayoría de los casos se utiliza el
“ActionPerformed”. Se agregan comentarios para tratar de facilitar el entendimiento.
A continuación vemos los métodos que utilizaremos para hacer funcionar a nuestro formulario. A cada método le asignamos un nombre que nos indica la función que está
cumpliendo, esto facilita entender en qué lugar la aplicamos. En partes específicas se agregan comentarios para facilitar el entendimiento de ciertas líneas de código.

//Abrimos una sesión, como la variable es de clase, podremos utilizarla
//desde cualquier método.
}
//Limpiamos campos, configuramos objetos.
defaultTableModel();
cargarTable();
}
public void defaultTableModel(){
//Configuramos nuestra tabla de la forma siguiente.
//La variable model es de clase, podremos utilizar en cualquier método.
//Nos permitira agregar, editar y eliminar datos de la tabla.
model = (DefaultTableModel) this.jTable1.getModel();
}
public void cargarTable(){
//Llamamos a la variable "st" para iniciar una transacción con la DB.
//Obtenemos una lista de todos los registros de la tabla proveedor de la siquiente forma.
List<Proveedor> list = (List<Proveedor>)st.createQuery("from Proveedor").list();
//Con Iterator podremos navegar por la lista anterior creada.
for (Iterator<Proveedor> it = list.iterator(); it.hasNext();) {
//Casteo a clase Proveedor de la lista para poder utilizar los get y set.
Proveedor proveedor = it.next();
//Cada ciclo carga un fila nueva a la tabla con registros del DB.
proveedor.getId(),proveedor.getDes(),proveedor.getDir(),proveedor.getTel()
});
}
}
//Habilitamos campos y objetos para cargar un nuevo registro a la DB.
}
//Antes de proceder a guardar comprobamos que no hayan campos vacios.
this.des.setText("-");
guardar();
}
else{
if(this.dir.getText().isEmpty()){
this.dir.setText("-");
guardar();
}
else{
if(this.tel.getText().isEmpty()){
this.tel.setText("-");
guardar();
}
else{
//Tendremos dos posibles casos, un nuevo registro o actualización.
//Si el botón guardar muestra la etiqueta "Guardar", se creará un nuevo registro.
Proveedor prov = new Proveedor();
prov.setDes(this.des.getText());
prov.setDir(this.dir.getText());
prov.setTel(this.tel.getText());
//save para nuevo registro
st.save(prov);
//El commit permite confirmar la transacción y procesarla
arranque();
JOptionPane.showMessageDialog(null, "Proveedor guardado correctamente.");
}
else{
//Caso contrario a la anterior, se cargará el registro seleccionado
//y se podra actualizar los cambios.
int idProv = Integer.parseInt(this.id.getText());
//Para cargar un registro se utiliza un load con los parámetros de clase e "id"
Proveedor prov = (Proveedor)st.load(Proveedor.class, idProv);
prov.setDes(this.des.getText());
prov.setDir(this.dir.getText());
prov.setTel(this.tel.getText());
//Para el caso será un update.
st.update(prov);
arranque();
JOptionPane.showMessageDialog(null, "Proveedor actualizado correctamente.");
}
}
}
}
}
public void cargarProveedor(){
//Lo siguiente permite rellenar los campos con los datos que se obtengan
//de la fila seleccionada del jTable1
//Se obtiene la fila seleccionada
//Se obtiene el "id" del registro que esta en la columna "0"
int idProv = Integer.parseInt(String.valueOf(model.getValueAt(selectedRow, 0)));
//Se utiliza un load para cargar el objeto.
//Cargado el objeto se pueden utilizar los "get".
this.id.setText(String.valueOf(prov.getId()));
this.des.setText(prov.getDes());
this.dir.setText(prov.getDir());
this.tel.setText(prov.getTel());
}
}
//Activa campos para edición.
}
//Forma de confirmar una eliminación de registro.
}
else{
//Iniciamos una transacción
//Obtenemos la fila seleccionada de la tabla.
//Obtenemos el "id" del registro de la columna "0" de la tabla.
int idProv = Integer.parseInt(String.valueOf(model.getValueAt(selectedRow, 0)));
//Cargamos el objeto.
//Eliminamos con delete
st.delete(prov);
//Confirmamos la transacción
arranque();
}
}
Por último, (img. 04) vemos el resultado ejecutando el formulario.
012 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. Formulario transaccional Compra.
Primeramente vemos el diseño final del formulario (img. 01, clic para ampliar), que como siempre es un “jDialog”. Ponemos en letra roja como referencia los nombre de
variable para cada objeto del diseño, esto es importante para que se ajusten a los métodos y eventos que vayamos creando. Los objetos sombreados están deshabilitadas
para la edición, esto es importante y se puede aplicar desde “propiedades” de cada objeto, específicamente la propiedad “editable”. Se puede cambiar el “Nombre de
variable” de cada objeto haciendo clic derecho sobre el mismo y en el menú desplegable seleccionar “Cambiar nombre de variable…”. El formulario de compras es similar a
la de ventas, es posible reutilizar ese formulario modificando los datos que cambian, en este caso sacando cliente y agregando proveedor; además de otros puntos
importantes.
el constructor de la clase, que como sabemos se ejecutan al crear el formulario. Y las variables de clase que necesitaremos. Se agregan comentario para facilitar la
comprensión de ciertas líneas de código.
Ahora debemos agregar los eventos necesarios. Como ya vimos en anteriores tutoriales, debemos de saber cómo implementarlas y sobre que objetos. Obs.: Utilizamos el
evento “ActionPerformed” para llamar los métodos desde los botones. Se utiliza el evento “MouseClicked” para el jTable. Los eventos “KeyPressed” para los campos de
texto, este último se activa al presionar una tecla específica, en este caso lo configuramos con la tecla “Intro”. Para utilizar un “Evento” hacemos clic derecho sobre el objeto
y seleccionamos “Eventos” de la lista utilizamos la que podamos aplicar al objeto. En la mayoría de los casos se utiliza el “ActionPerformed”. Se agregan comentarios para
tratar de facilitar el entendimiento.

nuevo();// Evento ActionPerformed para botón nuevo.
}
arranque();// Evento ActionPerformed para botón cancelar.
}

agregar();// Evento ActionPerformed para botón agregar.
private void idKeyPressed(java.awt.event.KeyEvent evt) {

//Uso del Evento KeyPressed dentro del campo de texto "id".
if(evt.getKeyCode()== KeyEvent.VK_ENTER){
buscarFuncionario();
}
}
private void idProvKeyPressed(java.awt.event.KeyEvent evt) {

//Uso del Evento KeyPressed dentro del campo de texto "idProv".
buscarProveedor();
}
}
private void idArtKeyPressed(java.awt.event.KeyEvent evt) {

//Uso del Evento KeyPressed dentro del campo de texto "idArt".
buscarArticulo();
}
}
private void cantidadKeyPressed(java.awt.event.KeyEvent evt) {

//Uso del Evento KeyPressed dentro del campo de texto "cantidad".
calcularParcial();
}
}

eliminar();// Evento ActionPerformed para botón eliminar.
}

guardar();// Evento ActionPerformed para botón guardar.
}
A continuación vemos los métodos que utilizaremos para hacer funcionar a nuestro formulario. A cada método le asignamos un nombre que nos indica la función que está
cumpliendo, esto facilita entender en qué lugar la aplicamos. En partes específicas se agregan comentarios para facilitar el entendimiento de ciertas líneas de código.

//Abrimos una session y la guardamos en una variable de clase.
}
//Configuramos objetos para el arranque.
this.fecha.setText(null);
this.hora.setText(null);
this.idProv.setText(null);
this.idProv.setEnabled(false);
this.dirProv.setText(null);
this.idArt.setEnabled(false);
this.cantidad.setEnabled(false);
this.totalGeneral.setText(null);
tableModel();
}
//Configuramos el jTable utilizando DefaultTableModel
}
//Configuramos acciones, habilitamos campos al precionar el botón nuevo
obtenetID();
this.id.setEnabled(true);
this.idProv.setEnabled(true);
this.idArt.setEnabled(true);
this.cantidad.setEnabled(true);
this.id.requestFocus();
String calString = retornarString(cal);
String calHora = retornarStringHora(cal);
this.fecha.setText(calString);
this.num.setText(String.valueOf(numCompra));
this.hora.setText(calHora);
}
public void obtenetID(){
//Utilizamos el método siguiente para conseguir en número de compra...
//correspondiente
numCompra = 0;
List<CompraCab> lista = (List<CompraCab>)st.createQuery("From CompraCab").list();
for (Iterator<CompraCab> it = lista.iterator(); it.hasNext();) {
CompraCab compraCab = it.next();
numCompra = compraCab.getNum() + 1;
}
if(numCompra==0){
numCompra=1;
}
}
public void buscarArticulo(){
//Utilizamos el método siguiente para buscar artículos por el "ID",
//este método se llama desde un evento KeyPressed.
int idArti = 0;
try {
try {
idArti = Integer.parseInt(this.idArt.getText());
}
Articulo art = (Articulo)st.load(Articulo.class, idArti);
this.desArt.setText(art.getDes());
this.pco.setText(String.valueOf(art.getPco()));
this.cantidad.requestFocus();
JOptionPane.showMessageDialog(null, "No hay artículo con ID: " + idArti);
}
}
public void calcularParcial(){
//Lo siguiente nos permite calcular el total para cada artículo,
//esto tomando en cuenta total de compra y precio de compra.
int canCompra = 0;
int pCompra = 0;
int totalParcial = 0 ;
try {
canCompra = Integer.parseInt(this.cantidad.getText());
totalParcial = canCompra * pCompra;
this.total.setText(String.valueOf(totalParcial));
this.agregar.requestFocus();
JOptionPane.showMessageDialog(null, "Se requiere datos numérico.");
}
}
public void buscarFuncionario(){
//Utilizamos el método siguiente para buscar funcionario por el "ID",
int idFunc = 0;
try {
try {
idFunc = Integer.parseInt(this.id.getText());
}
Funcionario funcio = (Funcionario)st.load(Funcionario.class, idFunc);
this.nombres.setText(funcio.getNombres());
this.apellidos.setText(funcio.getApellidos());
this.idProv.requestFocus();
JOptionPane.showMessageDialog(null, "No hay funcionario con ID: " + idFunc);
}
}
public void buscarProveedor(){
//Utilizamos el método siguiente para buscar proveedor por el "ID",
int idPrv = 0;
try {
try {
idPrv = Integer.parseInt(this.idProv.getText());
}
Proveedor proveedor = (Proveedor)st.load(Proveedor.class, idPrv);
this.desProv.setText(proveedor.getDes());
this.dirProv.setText(proveedor.getDir());
JOptionPane.showMessageDialog(null, "No hay proveedor con ID: " + idPrv);
}
}
//Método llamado desde el botón agregar, primeramente comprobamos que los datos sean correctos,
//que los campos no esten vacios, que no se repitan datos.
if(this.id.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Seleccione un funcionario.");
}
else{
if(this.idProv.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Seleccione un proveedor.");
}
else{
if(this.idArt.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Seleccione un articulo.");
}
else{
if(this.cantidad.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Indique una cantidad.");
}
else{
verificar();
if(var>=1){
int showConfirmDialog = JOptionPane.showConfirmDialog(null, "Artículo ya Agregado. Desea sumar la
cantidad.", "Mensaje del Sistema.", JOptionPane.YES_NO_OPTION);
if(showConfirmDialog==0){
sumarRepetido();
calcular();
confimAgregar();
limpiar();
}
else{
limpiar();
}
}
else{
this.idArt.getText(),this.desArt.getText(),this.pco.getText(),this.cantidad.getText(),this.total.getText()
});
calcular();
confimAgregar();
limpiar();
}
}
}
}
}
}
public void confimAgregar(){
//Método que pregunta al usuario si desea agregar más artículo a la lista.
int showConfirmDialog = JOptionPane.showConfirmDialog(null, "Agregar más Articulos.", "Mensaje del Sistema.",
}
else{
this.guardar.requestFocus();
}
}
//Limpia campo de datos..
this.idProv.setEnabled(false);
}
//Método para calcular el total de la compra, obteniendo datos del jtable.
int totalG = 0;
totalG += Integer.parseInt(valueAt.toString());
}
this.totalGeneral.setText(String.valueOf(totalG));
}
public void verificar(){
//Método para verificar que no se duplique el mismo artículo en la tabla,
//para ello se comprueba el id del artículo.
var = 0;
int idAr = Integer.parseInt(this.idArt.getText());
if(this.jTable1.getRowCount()>=1){
int parseInt = Integer.parseInt(valueAt.toString());
if(idAr == parseInt){
var = 1;
idArtt = i;
}
}
}
}
public void sumarRepetido(){
//Si se repite el ingreso de un artículo específico,se puede obtar por sumar la cantidad de compra,
//este método localizar el id del artículo específico y aumenta la cantidad de la
//compra sumandola.
int artCant = Integer.parseInt(this.cantidad.getText());
int artTotal = Integer.parseInt(this.total.getText());
Object valueAt = model.getValueAt(idArtt, 3);
Object valueAt1 = model.getValueAt(idArtt, 4);
int cantArt = Integer.parseInt(valueAt.toString());
int totalArt = Integer.parseInt(valueAt1.toString());
int x = artCant + cantArt;
int y = artTotal + totalArt;
model.setValueAt(x, idArtt, 3);
model.setValueAt(y, idArtt, 4);
}

//Médodo que se le para un objeto calendar y la combierte en formato String-Fecha
}
return retorno;
}
//Médodo que se le para un objeto calendar y la combierte en formato String-hora
}
return retorno;
}
//Se le pasa como argumento un String-Fecha y la combierte en objeto calendar.
try {
}
return cal;
}
//Permite al usuario seleccionar una fila específica de la table y eliminarla.
if(this.jTable1.getSelectedRow()==-1){
JOptionPane.showMessageDialog(null, "No ha seleccionado ninguna fila de la tabla.");
}
else{
int showConfirmDialog = JOptionPane.showConfirmDialog(null, "Eliminar fila seleccionada.", "Mensaje del Sistema.",
int sel = this.jTable1.getSelectedRow();
}
else{
}
}
}
//Metodo que nos permite almacenar los datos intruducidos en la base de datos,
//los datos se guardan en la tabla CompraCab y CompraDet.
//la primera almacena la cabecera de compra y la segunda los detalles.
if(this.id.getText().isEmpty() ||this.idProv.getText().isEmpty() ){
JOptionPane.showMessageDialog(null, "Faltan datos para guardar. Verifique.");
}
else{
if(this.jTable1.getRowCount()==0){
JOptionPane.showMessageDialog(null, "No hay datos para guardar.");
}
else{
int showConfirmDialog = JOptionPane.showConfirmDialog(null, "Desea guardar esta compra.", "Mensaje del
Sistema.", JOptionPane.YES_NO_OPTION);
try {
CompraCab compra = new CompraCab();
int idFun = Integer.parseInt(this.id.getText());
int idPrv = Integer.parseInt(this.idProv.getText());
long totalCompra = Long.parseLong(this.totalGeneral.getText());
Funcionario funcionario = (Funcionario)st.load(Funcionario.class, idFun);
Proveedor proveedor = (Proveedor)st.load(Proveedor.class, idPrv);
Calendar fechaCompra = retornarCalendar(this.fecha.getText());
String horaCompra = this.hora.getText();
compra.setNum(Integer.valueOf(this.num.getText()));
compra.setProveedor(proveedor);
compra.setFuncionario(funcionario);
compra.setFecha(fechaCompra);
compra.setHora(horaCompra);
compra.setTotal(totalCompra);
funcionario.getCompraCabs().add(compra);
proveedor.getCompraCabs().add(compra);
int[] idArti = new int[rowCount];
int[] cantCompra = new int[rowCount];
CompraDet detalleCompra = new CompraDet();
int idArticulo = Integer.parseInt(String.valueOf(model.getValueAt(i, 0)));
idArti[i] = idArticulo;
Articulo ventaArticulo = (Articulo)st.load(Articulo.class, idArticulo);
int cantidadCompra = Integer.parseInt(String.valueOf(model.getValueAt(i, 3)));
cantCompra[i]= cantidadCompra;
int importeVenta = Integer.parseInt(String.valueOf(model.getValueAt(i, 4)));
detalleCompra.setArticulo(ventaArticulo);
detalleCompra.setCantidad(cantidadCompra);
detalleCompra.setImporte(importeVenta);
detalleCompra.setCabecera(compra);
compra.getCompraDets().add(detalleCompra);
}
st.save(compra);
for (int i = 0; i < idArti.length; i++) {
actualizarStrock(cantCompra[i], idArti[i]);
}
arranque();
JOptionPane.showMessageDialog(null, "Compra guardada correctamente.");
JOptionPane.showMessageDialog(null, "Error guardando compra. Verifique.");
}
}
else{
}
}
}
}
public void actualizarStrock(int cantidadCompra, int idArticulo){
//Despúes que el proceso de guardado se de de forma correcta,
//se actualizar el stock de los artículos comprados.
Articulo actualizar = (Articulo)st.load(Articulo.class, idArticulo);
int temp = actualizar.getCan() + cantidadCompra;
actualizar.setCan(temp);
st.update(actualizar);
}
Por último, (img. 03) vemos el resultado ejecutando el formulario.
013 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. iReport. Introducción para crear
informes.
Antes de empezar a trabajar con reportes es necesario crear una biblioteca con los “JARs” necesarios para manejar los informes.
1).- Creando bibliotecas: Pueden ver el proceso en el enlace siguiente del blog Datos importantes antes de crear formularios. En este caso, crearemos una biblioteca para
trabajar con los reportes. El nombre de la biblioteca será “JasperReports”.
2) Lista de JARs que debemos agregar para la creación de la Biblioteca “JasperReports”. Puede variar la versión dependiendo justamente de la versión del iReport.
Estos JARs se pueden obtener de la carpeta de instalación del iReport.
 commons-beanutils-1.8.0
 commons-collections-2.1.1
 commons-digester-2.1
 commons-javaflow-20060411
 commons-logging-1.1.1
 groovy-all-1.7.5
 iText-2.1.7
 jasperreports-4.7.0
 jasperreports-fonts-4.7.0
 jasperreports-javaflow-4.7.0
 png-encoder-1.5
 poi-3.7-20101029
3) Cargando biblioteca, será cosa de agregar la misma a la carpeta biblioteca de nuestro proyecto. El proceso en el enlace siguiente Datos importantes antes de crear
formularios.
.
4) Datos básicos sobre el manejo de iReport. Creando nuevo archivo: Como se ve en la imagen, seleccionamos “Report”, seleccionamos tipo de hoja y orientación, por
último abrimos la plantilla. Para completar especificamos el nombre y la ubicación del archivo.
Secciones importantes de la pantalla de iReport: 1) Datasource o fuente de datos: para nuestros reportes esta tendrá que estar en “Empty datasource” pues utilizaremos
listas ya filtradas. 2) Inspector de Reportes: De esta la que mayormente utilizaremos son los parámetros, campos y variables. 3) Modo diseño del iReport: En esta vemos las
diferentes bandas que pueden cumplir cada cual una función específica, que detallaremos al realizar los reportes. 4) Paleta: Con los diferentes elementos que podremos
agregar el reporte. 5) Propiedades: Cada elemento seleccionado despliega una serie de propiedades que pueden ser o no modificadas.
5) Como se agregan los diferentes elementos.
Label.
Estas podemos utilizar para agregar títulos al reporte, descripciones de columnas. Se puede agregar seleccionándola de la paleta y arrastrando al lugar correspondiente. Se
puede modificar tipo de letra, tamaño, color, alineación, etc., en “Properties” o “Propiedades” del objeto.
Fields.
Fields o capos; almacenan los datos que recibirá el reporte de una lista o base de datos. Se agregar en la banda correspondiente a “Detalles”. Estas se crean haciendo clic
derecho sobre “Field” en el “Inspector de Reporte” a la izquierda y seleccionando “Agregar Field”. Se la puede agregar al reporte haciendo clic sobre la misma y
arrastrándola al lugar correspondiente. Se pueden modificar las diferentes propiedades en el apartado “Properties” o “Propiedades” del objeto.
Parameters.
Parameters o parámetros; corresponden a datos individuales e independiente que se pueden agregar al reporte. Suele ser una variable que le pasa la aplicación que llama
al reporte. Por ejemplo un nombre o dato específico que el usuario escribe en un campo de texto. Estas se crean haciendo clic derecho sobre “Parameters” en el “Inspector
de Reporte” a la izquierda y seleccionando “Agregar Parameters”. Se la puede agregar al reporte haciendo clic sobre la misma y arrastrándola al lugar correspondiente. Se
pueden modificar las diferentes propiedades en el apartado “Properties” o “Propiedades” del objeto.
Variable.
Como se ve en la imagen (01) una variable puede contener cálculos con condiciones, número de páginas, numero de columnas etc. El potencial de la misma está en la
agregación de cálculos específicos con condiciones específicas. En la imagen (2) se puede ver el agregado de una variable para realizar sumas, el procedimiento de
creación de la misma es igual a la creación de “Campos” y “Parámetros”; la parte más importante está en propiedades, la misma nos permite especificar el tipo de datos, tipo
de cálculos, tipo de agrupación y el origen de los datos para el cálculo. En este caso particular el cálculo se realizar en “Pie de Grupo”.
IMG 01
IMG 02
6) Para verificar nuestro trabajo podemos utilizar el botón “Preview” como se indica en la imagen, es posible especificar algunos datos de entrada para la vista previa del
reporte. Por último debemos compilar el reporte haciendo clic en el botón “Compile Report”. Esta compilación nos genera dos archivos con extensión “.jasper” y “.jrxml” que
se almacena en la carpeta de iReport en Documentos de usuario; debemos copiar ambas en nuestra carpeta de “informes” del Proyecto Java. Teniendo ambos archivos ya
podremos utilizarlas desde el formulario correspondiente.
7) Ejemplo de reporte: Más abajo podemos ver una imagen de la elaboración de un reporte utilizando principalmente elementos como líneas, etiquetas, rectángulos,
campos, parámetros y variables. El iReport tiene la capacidad necesaria para realizarse reportes complejos y sofisticados. La información presentada más arriba es bastante
básica, pero suficiente para empezar a trabajar con reportes.
014 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. iReport. Reporte para referencial
Tipo.
Iniciamos la creación del reporte para “Tipo” de artículos creando un nuevo archivo, el nombre del archivo será “TipoReport”. Para entender más sobre el proceso de
creación de informes se puede consultar iReport. Introducción para crear informes. La configuración de la hoja normal es el A4.
Abajo podemos ver una imagen de cómo queda el diseño del reporte completado, es bastante sencillo pero suficiente. En la imagen se indican los objetos que se agregan.
Más abajo se explica de forma básica cada objeto agregado.
El reporte en si contiene estos elementos: 1) Un “Label” como descripción del reporte. 2) Una “Variable” para el número de páginas. 3) “Labels” para describir datos de
columnas. 4) “Fields” o campos para la banda de detalles. Para los bordes y divisores se utiliza “Line” de la paleta. En ”iReport. Introducción para crear informes.” vimos
cómo trabajar con cada elemento. Un detalle importante a tener en cuenta es el nombre para cada “Field” ya que serán iguales a las que le pasaremos desde Java; las
designadas para este reporte son “id” y “des” que nos mostraran el “ID” y la “Descripción” de cada tipo de artículo que tengamos.
Una vez terminado el diseño podremos ver una vista previa del reporte o compilarla y obtener los dos archivos, en este caso “TipoReport.jasper” y “TipoReport.jrxml”. Estos
archivos las copiamos en la carpeta “Informes”.
El siguiente paso es crear un método para ejecutar el reporte y llamarla desde el botón informe que está incluido en el formulario “TipoApp”.
Abajo el método “informe()” para ejecutar el reporte. Los comentarios explican que función cumple cada línea de código. Este método la llamamos desde el botón “Informe”
utilizando el evento “ActionPerformed”.
public void informe(){

//try - para controlar las excepciones.
try {
//Creamos una lista de los datos de la table "Tipo" utilizando "List".
//Utilizamos el método siguiente para cargar el reporte "TipoReport.jasper"
//El "JRLoader.loadObject" es el cargador.
JasperReport report =
(JasperReport)JRLoader.loadObject(ClassLoader.getSystemResource("com/informes/TipoReport.jasper"));
//El método siguiente nos permite pasarle los datos al reporte utilizando JRBeanCollectionDataSource y como
argumento la lista que creamos más arriba.
//La lista posee dos campos por registro: "id" y "des", los nombres se corresponden con las agregadas en el reporte
diseñado.
JasperPrint fillReport = JasperFillManager.fillReport(report, null,new JRBeanCollectionDataSource(lista));
//El JasperViewer para visualizar, le pasamos como argumento nuestro "fillReport" de arriba.
JasperViewer jviewer = new JasperViewer(fillReport,false);
//Le damos un título al reporte.
jviewer.setTitle("Lista de Tipos de Artículos.");
jviewer.setVisible(true);
JOptionPane.showMessageDialog(null, "Error cargando reporte.");
}
}
En caso de que el IDE indique error de sintaxis, verificar si tenemos todas las importaciones necesarias. A continuación la lista.
Por último el formulario en ejecución junto con el reporte. En caso que el reporte aparezca detrás del formulario, modificar la propiedad “modalityType”
indicando que sea “DOCUMENT_MODAL”.
Artículo.
Iniciamos la creación del reporte para “Articulo” creando un nuevo archivo, el nombre del archivo será “ArticuloReport”. Para entender más sobre el proceso de creación de
informes se puede consultar iReport. Introducción para crear informes. La configuración de la hoja normal es el A4.
En la imagen de más abajo se puede ver el diseño del reporte terminado, con los “Fields” correspondientes, “Variables” y demás.
El reporte en si contiene estos elementos: 1) Un “Label” como descripción del reporte. 2) Una “Variable” para el número de páginas. 3) “Labels” para describir datos de
columnas. 4) “Fields” o campos para la banda de detalles. Para el borde se utiliza “Rectangle” de fondo y sin borde. En ”iReport. Introducción para crear informes” vimos
cómo trabajar con cada elemento. Un detalle importante a tener en cuenta es el nombre para cada “Field” ya que serán iguales a las que le pasaremos desde Java con
nuestra lista creada. Estos campos son "id", "des" "tipo", "pve" y "can".
Completado el diseño debemos de compilar el reporte y obtener los archivos necesarios “ArticuloReport.jasper” y “ArticuloReport.jrxml” respectivamente. Estos archivos de
reporte debemos de copiar en nuestra carpeta “informes”, que creamos al inicio del proyecto.
En algunos casos se da que debemos obtener datos de dos o más tablas, como por ejemplo “Articulo” y “Tipo”, pues debemos de obtener la lista de artículos al igual que el
tipo correspondiente. Esto lo podemos hacer utilizando una clase de soporte que nos permitirá combinar ambas tabla en una sola lista. El nombre de la clase para este
informe es “ArticuloR” y la tendremos que guardar en la carpeta de “informes” al igual que los dos archivos de obtenidos del iReport. A continuación la clase “ArticuloR”.
package com.informes;
/**
*
* @author Ariel
*/
public class ArticuloR {
private int id;
private String des;
private String tipo;
private int pve;
private int can;
public ArticuloR(int id, String des, String tipo, int pve, int can) {
this.id = id;
this.des = des;
this.tipo = tipo;
this.pve = pve;
this.can = can;
}
public int getCan() {

return can;
}
public void setCan(int can) {

this.can = can;
}

return des;
}
this.des = des;
}

return id;
}

this.id = id;
}
public int getPve() {

return pve;
}
public void setPve(int pve) {

this.pve = pve;
}
public String getTipo() {

return tipo;
}
public void setTipo(String tipo) {

this.tipo = tipo;
}
El siguiente paso es crear un método para ejecutar el reporte. Abajo el método “informe()” para ejecutar el reporte. Los comentarios explican que función cumple cada línea
de código. Este método la llamamos desde el botón “Informe” de nuestro formulario “ArticuloApp” utilizando el evento “ActionPerformed”.

try {
//Utilizamos un Lista para almacenar los datos combinados de Articulo y Tipo.
List articuloList = new ArrayList();
//Obtenemos una lista de artículos
List<Articulo> lista = (List<Articulo>)st.createQuery("From Articulo").list();
//utilizamos Iterator para acceder a los datos
for (Iterator<Articulo> it = lista.iterator(); it.hasNext();) {
Articulo articulo = it.next();
//Llenamos nuestro "articuloList", la diferencia con la lista original es que obtenemos las descripción del tipo
con "articulo.getTipo().getDes()"
//de otra forma no traería un objeto "Tipo" no un String con el nombre específico que necesitamos.
articuloList.add( new ArticuloR(articulo.getId(), articulo.getDes(), articulo.getTipo().getDes(),
articulo.getPve(), articulo.getCan()));
}
//Utilizamos el método siguiente para cargar el reporte "ArticuloReport.jasper"
(JasperReport)JRLoader.loadObject(ClassLoader.getSystemResource("com/informes/ArticuloReport.jasper"));
//La lista posee los siguiente campos: "id" "des" "tipo" "pve" "can" en coincidencia con los de nuestro archivo de
reporte.
JasperPrint fillReport = JasperFillManager.fillReport(report, null,new JRBeanCollectionDataSource(articuloList));
jviewer.setTitle("Lista de Artículos.");
}
}
import com.entidades.Articulo;
import com.informes.ArticuloR;
import org.hibernate.Query;
Por último el formulario en ejecución junto con el reporte. En caso que el reporte aparezca detrás del formulario, modificar la propiedad “modalityType” indicando que sea
“DOCUMENT_MODAL”.
Cliente.
Iniciamos la creación del reporte para “Cliente” creando un nuevo archivo, el nombre del archivo será “ClienteReport”. Para entender más sobre el proceso de creación de
informes se puede consultar iReport. Introducción para crear informes. La configuración de la hoja normal es el A4.
Elementos del diseño del reporte: 1) Un “Label” como descripción del reporte. 2) Una “Variable” para el número de páginas. 3) “Labels” para describir datos de columnas. 4)
“Fields” o campos para la banda de detalles. Para el borde se utiliza “Rectangle” de fondo y sin borde. En ”iReport. Introducción para crear informes” vimos cómo trabajar
con cada elemento. Un detalle importante a tener en cuenta es el nombre para cada “Field” ya que serán iguales a las que le pasaremos desde Java con nuestra lista
creada. Estos campos son "id", "des" "dir", "tel" y "ruc".
Completado el diseño debemos de compilar el reporte y obtener los archivos necesarios “ClienteReport.jasper” y “ClienteReport.jrxml” respectivamente. Estos archivos de
reporte debemos de copiar en nuestra carpeta “informes”, que creamos al inicio del proyecto.
de código. Este método la llamamos desde el botón “Informe” de nuestro formulario “ClienteApp” utilizando el evento “ActionPerformed”.

try {
//Creamos una lista de los datos de la tabla "Cliente" utilizando "List".
List<Cliente> lista = (List<Cliente>)st.createQuery("From Cliente").list();
//Utilizamos el método siguiente para cargar el reporte "ClienteReport.jasper"
(JasperReport)JRLoader.loadObject(ClassLoader.getSystemResource("com/informes/ClienteReport.jasper"));
//La lista posee dos campos por registro: "id", "des" "dir", "tel" y "ruc", los nombres se corresponden con las
agregadas en el reporte diseñado.
jviewer.setTitle("Lista de Clientes.");
}
}
import com.entidades.Cliente;
Funcionario.
Como en todas las anteriores iniciamos la creación del reporte para “Funcionario” creando un nuevo archivo, el nombre del archivo será “FuncionarioReport”. Para entender
más sobre el proceso de creación de informes se puede consultar iReport. Introducción para crear informes. La configuración de la hoja normal es el A4.
“Fields” o campos para la banda de detalles. Para el borde se utiliza “Rectangle” de fondo y sin borde. En ”iReport. Introducción para crear informes” vimos cómo trabajar
creada. Estos campos son "id", "nombres" "apellidos", "dir" y "cargo".
Completado el diseño debemos de compilar el reporte y obtener los archivos necesarios “FuncionarioReport.jasper” y “FuncionarioReport.jrxml” respectivamente. Estos
archivos de reporte debemos de copiar en nuestra carpeta “informes”, que creamos al inicio del proyecto.
de código. Este método la llamamos desde el botón “Informe” de nuestro formulario “FuncionarioApp” utilizando el evento “ActionPerformed”.

try {
//Obtenemos una lista de funcionario
List<Funcionario> lista = (List<Funcionario>)st.createQuery("From Funcionario").list();
//Utilizamos el método siguiente para cargar el reporte "FuncionarioReport.jasper"
(JasperReport)JRLoader.loadObject(ClassLoader.getSystemResource("com/informes/FuncionarioReport.jasper"));
//La lista posee los siguiente campos: "id" "nombres" "apellidos" "dir" "cargo" en coincidencia con los de nuestro
archivo de reporte.
jviewer.setTitle("Lista de Funcionarios");
}
}
import com.entidades.Funcionario;
018 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. iReport. Reporte para transacción
Venta.
Para los que son transacciones se requiere de un formulario que servirá como base para lanzar los reportes, estos reportes pueden ser generales, especificando rangos de
fechas (inicio –fin); o específicos, esto es indicando en este caso las ventas de un funcionario en cierto rango de fecha o compras de un cliente también tomando en cuenta
rangos de fechas. Para esto debemos de crear un formulario utilizando un “jDialog”.
En primer lugar vemos el diseño del formulario, este formulario lanza dos reportes diferente, una de tipo general y otra tomando como variable un funcionario y los rangos de
fechas inicio y fin. En el diseño se especifican los nombres de variable para los campos y botones (están en letra roja como etiqueta), esto es importante ya que a través de
estas se llaman los objetos desde los métodos. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre
de variable…”. Para la introducción de fechas utilizamos “JFormattedTextField” o “Cuadro formateado” si el IDE está en español, en esta entrada del blog se trata sobre la
utilización de un cuadro formateado ((Fecha y Hora con objeto Calendar). La “Lista desplegable” o “jComboBox” va almacenar los nombres de funcionarios.
Cuando se habla de transacciones se suelen utilizar varias tablas para obtener datos de referencia y trabajar con ellas. En este caso “VentaCab”, “VentaDet”, “Funcionario”,
“Cliente” y “Articulo” respectivamente, para confeccionar una lista única con los datos que necesitamos debemos de crear una clase que servirá como plantilla para nuestros
reportes. El nombre de la clase será “VentaR”, y tendrá los siguientes elementos. Tomar en cuenta que esta clase debe ir almacenada dentro del paquete que corresponde a
informes.
/**
*
* @author Ariel
*/
public class VentaR {
private int id;
private String funcionario;
private String cliente;
private String fecha;
private String articulo;
public VentaR(int id, String funcionario, String cliente, String fecha, String articulo, int cantidad, long importe) {
this.id = id;
this.fecha = fecha;
}
public String getArticulo() {

return articulo;
}
public void setArticulo(String articulo) {

}

return cantidad;
}

}
public String getCliente() {

return cliente;
}
public void setCliente(String cliente) {

}
public String getFecha() {

return fecha;
}
public void setFecha(String fecha) {

this.fecha = fecha;
}
public String getFuncionario() {

return funcionario;
}
public void setFuncionario(String funcionario) {

}

return id;
}

this.id = id;
}
return importe;
}

}
Continuamos viendo el diseño del primer reporte que será de tipo general, el nombre del archivo será “ReportVenta”. Se puede consultar este enlace del blog si hay dudas
sobre algunos elementos (iReport. Introducción para crear informes). La configuración de la hoja es el A4 tipo vertical.
Elementos del diseño del reporte: 1) Un “Label” como descripción del reporte. 2) Una “Variable” para el número de páginas. 3) “Labels” para describir datos de columnas.
4) “Fields” o campos para la banda de detalles. Para el borde se utiliza “Rectangle” de fondo y sin borde. 5) Una “Variable” para indicar la suma total de ventas, en la imagen
se especifica los parámetros necesarios para que funcione correctamente. Es importante respetar los nombres de los “Fields” ya que deben de coincidir con las que le
pasaremos desde la lista más arriba creada.
Ahora vemos el segundo reporte que será de tipo específico, utilizando como tercera variable el nombre de un funcionario para ver las ventas que le corresponden. El
nombre del archivo será “ReportVentaDos”. La configuración de la hoja es también A4 tipo vertical. Los elementos del diseño son iguales que la anterior, la diferencia se ve
en que ubicamos el nombre del funcionario en “Column Header” ya que será única para el reporte.
Completado el diseño debemos de compilar cada uno de los reportes y obtener los archivos necesarios que tienen la extensión “*.jasper” y “*.jrxml” respectivamente. Estos
El siguiente paso es crear un método que lance cada uno de los reportes creados y también los métodos que harán funcionar nuestro formulario. Más abajo tenemos los
métodos creados, el nombre de cada una específica su función. Los comentarios explican que función cumple cada línea de código. Cada método de informe se llama desde
su respectivo botón utilizando el evento “ActionPerformed”. Botón “verG” le corresponde el método “informeGeneral()” y el botón “verF” le corresponde el método
“informeFuncionario()”.
private void hibernateSession(){

//Método para abri una sesión hibernate.
}
//Metodo para configurar los elementos de arranque
String fecha = retornarString(cal);
inicioG.setText(fecha);
finG.setText(fecha);
inicioF.setText(fecha);
finF.setText(fecha);
//Creamos una lista de funcionarios para llenar nuestro lista desplegable o comboBox.
List<Funcionario> listF = (List<Funcionario>)st.createQuery("From Funcionario").list();
//Otra forma de navegar por una lista a diferencia de Iterator.
for (int i = 0; i < listF.size(); i++) {
Funcionario f = listF.get(i);
listaF.addItem(f.getNombres());
}
}
//Métodos para trabajar con objeto Calendar.
//Método que retorna un String de fecha pasándole como argumento un objeto Calendar.
}
return retorno;
}
//Método que retorna un objeto Calendar pasando un String de fecha preformateado.
try {
}
return cal;
}
public void informeGeneral(){
//Método para nuestro informe general
try {
//Utilizamos un Lista para almacenar los datos combinados.
//Inicializamos nuestra lista como ArrayList().
List ventaList = new ArrayList();
//Creamos una Query utilizando nuestra sesión y HQL (Hibernate Query Language)
//Las condiciones son - fecha de inicio y fin.
Query query = (Query) st.createQuery("From VentaCab v Where v. fecha>=? and v. fecha<=?");
//A diferencia de SQL, las condiciones se pasan como parámetros.
query.setParameter(0, retornarCalendar(inicioG.getText()));
query.setParameter(1, retornarCalendar(finG.getText()));
//Obtenemos la lista de "VentaCab"
List<VentaCab> lista = query.list();
int id=0;
//Navegamos la lista utilizando Iterator.
String funcionario = ventaCab.getFuncionario().getNombres();
String cliente = ventaCab.getCliente().getDes();
String fecha = retornarString(ventaCab.getFecha());
List<VentaDet> ventaDets = ventaCab.getVentaDets();
//Navegamos por la lista de detalles utilizando también iterator.
for (Iterator<VentaDet> it1 = ventaDets.iterator(); it1.hasNext();) {
id++;
VentaDet ventaDet = it1.next();
//Llenamos nuestro lista creada más arriba con los elementos necesarios.
ventaList.add(new VentaR(id, funcionario, cliente, fecha, ventaDet.getArticulo().getDes(),
ventaDet.getCant(), ventaDet.getImporte()));
}
}
//Utilizamos el método siguiente para cargar el reporte "*.jasper"
(JasperReport)JRLoader.loadObject(ClassLoader.getSystemResource("com/informes/ReportVenta.jasper"));
JasperPrint fillReport = JasperFillManager.fillReport(report, null,new JRBeanCollectionDataSource(ventaList));
jviewer.setTitle("Ventas Generales.");
JOptionPane.showMessageDialog(null, "Error cargando reporte." + e);
}
}
public void informeFuncionario(){
//Este método es similar al de más arriba, por tanto se saltan algunos comentarios.
try {
//Utilizamos un Lista para almacenar los datos.
List ventaList = new ArrayList();
Query query = (Query) st.createQuery("From VentaCab v Where v. fecha>=? and v. fecha<=?");
query.setParameter(0, retornarCalendar(inicioF.getText()));
query.setParameter(1, retornarCalendar(finF.getText()));
List<VentaCab> lista = query.list();
int id=0;
String funcionario = ventaCab.getFuncionario().getNombres();
String cliente = ventaCab.getCliente().getDes();
String fecha = retornarString(ventaCab.getFecha());
List<VentaDet> ventaDets = ventaCab.getVentaDets();
for (Iterator<VentaDet> it1 = ventaDets.iterator(); it1.hasNext();) {
id++;
VentaDet ventaDet = it1.next();
//Una condición para filtrar la lista, obteniendo solo la de un funcionario en específico.
if( funcionario.equals(listaF.getSelectedItem().toString())){
ventaList.add(new VentaR(id, funcionario, cliente, fecha, ventaDet.getArticulo().getDes(),
ventaDet.getCant(), ventaDet.getImporte()));
}
}
}
(JasperReport)JRLoader.loadObject(ClassLoader.getSystemResource("com/informes/ReportVentaDos.jasper"));
JasperPrint fillReport = JasperFillManager.fillReport(report, null,new JRBeanCollectionDataSource(ventaList));
jviewer.setTitle("Lista de Ventas por Funcionarios.");
}
}
Obs.: Se anexa una imagen con elementos a tomar en cuenta al crear el formulario al igual que los códigos que corresponden a los eventos para los botones.
private void verGActionPerformed(java.awt.event.ActionEvent evt) {

//Condición agregada para ejecutar el informe.
if(!inicioG.getText().isEmpty() && !finG.getText().isEmpty()){
informeGeneral();
}
else{
JOptionPane.showMessageDialog(null, "Especifique una fecha correcta.");
}
}
private void verFActionPerformed(java.awt.event.ActionEvent evt) {

if(!inicioF.getText().isEmpty() && !finF.getText().isEmpty() && !listaF.getSelectedItem().toString().isEmpty()){
informeFuncionario();
}
else{
JOptionPane.showMessageDialog(null, "Especifique los datos necesarios. -Fecha- y -Funcionario-");
}
}
import com.entidades.Funcionario;
import com.entidades.VentaCab;
import com.entidades.VentaDet;
import com.informes.VentaR;
Proveedor.
Iniciamos el diseño para nuestro reporte, debemos de crear un archivo nuevo en nuestro iReport, el nombre del archivo será “ProveedorReport”. Para tener más datos sobre
los diferentes elementos de un reporte podemos consultar el siguiente enlace (iReport. Introducción para crear informes). La configuración de la hoja normal es el A4.
En la imagen de más abajo se puede ver el diseño del reporte terminado, con los “Fields” correspondientes, “Variables” y demás. Hay que respetar el nombre para cada
“Field”, como también tipo de datos, este último se puede cambiar consultando las propiedades de cada “Field”. Se puede ampliar la imagen haciendo clic en ella.
“Fields” o campos para la banda de detalles. Para el borde se utiliza “Rectangle” de fondo y sin borde. En (iReport. Introducción para crear informes) vimos cómo trabajar
creada.
Completado el diseño debemos de compilar el reporte y obtener los archivos necesarios “ProveedorReport.jasper” y “ProveedorReport.jrxml” respectivamente. Estos
de código. Este método la llamamos desde el botón “Informe” de nuestro formulario “ProveedorApp” utilizando el evento “ActionPerformed”.
try {
//Creamos una lista de los datos de la tabla "Proveedor" utilizando "List".
//Iniciamos una transacción.
List<Proveedor> lista = (List<Proveedor>)st.createQuery("From Proveedor").list();
//Utilizamos el método siguiente para cargar el reporte "ProveedorReport.jasper"
(JasperReport)JRLoader.loadObject(ClassLoader.getSystemResource("com/informes/ProveedorReport.jasper"));
//La lista posee todos los campos necesarios para pasarle datos al reporte.
jviewer.setTitle("Lista de Proveedores");
}
}
import com.entidades.Proveedor;
Por último el formulario en ejecución junto con el reporte. En caso que el reporte aparezca detrás del formulario, modificar la propiedad “modalityType” del “JDialog”
indicando que sea “DOCUMENT_MODAL”. (clic para ampliar imagen)
020 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. iReport. Reporte para transacción
Compra.
Como vimos anteriormente al trabajar con reportes para “Ventas”; las transacciones requieren de un formulario que servirá como base para lanzar los reportes, estos
reportes pueden ser generales o específicos utilizando diferentes variables, como fechas, funcionarios, clientes, proveedores u otros. El diseño para reportes de compras es
similar al de ventas, por tanto se puede utilizar el mismo diseño y procedimiento.
En primer lugar vemos el diseño del formulario, este formulario lanza dos reportes diferente, una de tipo general y otra tomando como variable un proveedor y los rangos de
fechas inicio y fin. En el diseño se especifican los nombres de variable para los campos y botones (están en letra roja como etiqueta), esto es importante ya que a través de
estas se llaman los objetos desde los métodos. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre
de variable…”. Para la introducción de fechas utilizamos “JFormattedTextField” o “Cuadro formateado” si el IDE está en español, en esta entrada del blog se trata sobre la
utilización de un cuadro formateado ((Fecha y Hora con objeto Calendar). La “Lista desplegable” o “jComboBox” va almacenar los nombres de proveedores.
En las transacciones se suelen utilizar varias tablas para obtener datos de referencia y trabajar con ellas. En este caso “CompraCab”, “CompraDet”, “Funcionario”,
“Proveedor” y “Articulo” respectivamente, para confeccionar una lista única con los datos que necesitamos, debemos de crear una clase que servirá como plantilla para
nuestros reportes. El nombre de la clase será “CompraR”, la única diferencia con el de “Ventas” será que está en vez de cliente tendrá proveedores, por tanto la misma nos
sirve como referencia, y tendrá los siguientes elementos. Tomar en cuenta que esta clase debe ir almacenada dentro del paquete que corresponde a informes.
package com.informes;
/**
*
* @author Ariel
*/
public class CompraR {
private int id;
private String funcionario;
private String proveedor;
private String fecha;
private String articulo;
public CompraR(int id, String funcionario, String proveedor, String fecha, String articulo, int cantidad, long importe)
{
this.id = id;
this.fecha = fecha;
}
public String getArticulo() {

return articulo;
}
public void setArticulo(String articulo) {

}

return cantidad;
}

}
public String getFecha() {
return fecha;
}
public void setFecha(String fecha) {

this.fecha = fecha;
}
public String getFuncionario() {

return funcionario;
}
public void setFuncionario(String funcionario) {

}

return id;
}

this.id = id;
}

return importe;
}

}
public String getProveedor() {

return proveedor;
}
public void setProveedor(String proveedor) {

}
}
Vemos el diseño del primer reporte que será de tipo general, el nombre del archivo será “ReportCompra”. Se puede consultar este enlace del blog si hay dudas sobre
algunos elementos que componen el reporte …(iReport. Introducción para crear informes). La configuración de la hoja es el A4 tipo vertical.
“Fields” o campos para la banda de detalles. Para el borde se utiliza “Rectangle” de fondo y sin borde. 5) Una “Variable” para indicar la suma total de ventas, en la imagen se
especifica los parámetros necesarios para que funcione correctamente. Es importante respetar los nombres de los “Fields” al igual que los tipos de datos correspondientes
ya que deben de coincidir con las que le pasaremos desde la lista más arriba creada.(clic para ampliar imagen)
Ahora vemos el segundo reporte que será de tipo específico, utilizando como filtro un proveedor especificado desde el combo. El nombre del archivo será
“ReportCompraDos”. La configuración de la hoja es también A4 tipo vertical.
Los elementos del diseño son iguales que la anterior, la diferencia se ve en que ubicamos el nombre del proveedor en “Column Header” ya que será única para el
reporte.(clic para ampliar imagen)
Completado el diseño debemos de compilar cada uno de los reportes y obtener los archivos necesarios que tienen la extensión “*.jasper” y “*.jrxml” respectivamente. Estos
El siguiente paso es crear un método que lance cada uno de los reportes creados y también los métodos que harán funcionar nuestro formulario. Más abajo tenemos los
métodos creados, el nombre de cada una específica su función. Los comentarios explican que función cumple cada línea de código. Cada método de informe se llama desde
su respectivo botón utilizando el evento “ActionPerformed”. Botón “verG” le corresponde el método “informeGeneral()” y el botón “verF” le corresponde el método
“informeProveedor()”.
private void hibernateSession(){

//Método para abrir una sesión hibernate.
}
//Metodo para configurar los elementos de arranque
String fecha = retornarString(cal);
inicioG.setText(fecha);
finG.setText(fecha);
inicioF.setText(fecha);
finF.setText(fecha);
//Creamos una lista de proveedores para llenar nuestro lista desplegable o comboBox.
List<Proveedor> listF = (List<Proveedor>)st.createQuery("From Proveedor").list();
//Otra forma de navegar por una lista a diferencia de Iterator.
for (int i = 0; i < listF.size(); i++) {
Proveedor p = listF.get(i);
listaP.addItem(p.getDes());
}
}
//Métodos para trabajar con objeto Calendar.
//Método que retorna un String de fecha pasándole como argumento un objeto Calendar.
}
return retorno;
}
//Método que retorna un objeto Calendar pasando un String de fecha preformateado.
try {
}
return cal;
}
public void informeGeneral(){
//Método para nuestro informe general
try {
//Utilizamos un Lista para almacenar los datos combinados.
//Inicializamos nuestra lista como ArrayList().
List compraList = new ArrayList();
//Creamos una Query utilizando nuestra sesión y HQL (Hibernate Query Language)
//Las condiciones son - fecha de inicio y fin.
Query query = (Query) st.createQuery("From CompraCab c Where c. fecha>=? and c. fecha<=?");
//A diferencia del SQL, las condiciones se pasan como parámetros.
//El primer parámetro indica el orden que empieza de "0", el segundo la variable.
query.setParameter(0, retornarCalendar(inicioG.getText()));
query.setParameter(1, retornarCalendar(finG.getText()));
//Obtenemos la lista de "CompraCab"
List<CompraCab> lista = query.list();
int id=0;
//Navegamos la lista utilizando Iterator.
String funcionario = compraCab.getFuncionario().getNombres();
String proveedor = compraCab.getProveedor().getDes();
String fecha = retornarString(compraCab.getFecha());
List<CompraDet> compraDets = compraCab.getCompraDets();
//Navegamos por la lista de detalles utilizando también iterator.
for (Iterator<CompraDet> it1 = compraDets.iterator(); it1.hasNext();) {
id++;
CompraDet compraDet = it1.next();
//Llenamos nuestro lista creada más arriba con los elementos necesarios.
compraList.add(new CompraR(id, funcionario, proveedor, fecha, compraDet.getArticulo().getDes(),
compraDet.getCantidad(),compraDet.getImporte()));
}
}
(JasperReport)JRLoader.loadObject(ClassLoader.getSystemResource("com/informes/ReportCompra.jasper"));
JasperPrint fillReport = JasperFillManager.fillReport(report, null,new JRBeanCollectionDataSource(compraList));
jviewer.setTitle("Compras Generales.");
JOptionPane.showMessageDialog(null, "Error cargando reporte." + e);
}
}
public void informeProveedor(){
//Este método es similar al de más arriba, por tanto se saltan algunos comentarios.
try {
//Utilizamos un Lista para almacenar los datos.
List compraList = new ArrayList();
Query query = (Query) st.createQuery("From CompraCab c Where c. fecha>=? and c. fecha<=?");
query.setParameter(0, retornarCalendar(inicioF.getText()));
query.setParameter(1, retornarCalendar(finF.getText()));
List<CompraCab> lista = query.list();
int id=0;
String funcionario = compraCab.getFuncionario().getNombres();
String proveedor = compraCab.getProveedor().getDes();
String fecha = retornarString(compraCab.getFecha());
List<CompraDet> compraDets = compraCab.getCompraDets();
for (Iterator<CompraDet> it1 = compraDets.iterator(); it1.hasNext();) {
id++;
CompraDet compraDet = it1.next();
//Una condición para filtrar la lista, obteniendo solo la de un proveedor en específico.
if( proveedor.equals(listaP.getSelectedItem().toString())){
compraList.add(new CompraR(id, funcionario, proveedor, fecha, compraDet.getArticulo().getDes(),
compraDet.getCantidad(),compraDet.getImporte()));
}
}
}
(JasperReport)JRLoader.loadObject(ClassLoader.getSystemResource("com/informes/ReportCompraDos.jasper"));
JasperPrint fillReport = JasperFillManager.fillReport(report, null,new JRBeanCollectionDataSource(compraList));
jviewer.setTitle("Lista de Compras por Proveedores.");
}
}
Obs.: Se anexa una imagen con elementos a tomar en cuenta al crear el formulario al igual que los códigos que corresponden a los eventos para los botones. (clic para
ampliar imagen)
private void verGActionPerformed(java.awt.event.ActionEvent evt) {

if(!inicioG.getText().isEmpty() && !finG.getText().isEmpty()){
informeGeneral();
}
else{
JOptionPane.showMessageDialog(null, "Especifique una fecha correcta.");
}
}
private void verFActionPerformed(java.awt.event.ActionEvent evt) {

if(!inicioF.getText().isEmpty() && !finF.getText().isEmpty() && !listaP.getSelectedItem().toString().isEmpty()){
informeProveedor();
}
else{
JOptionPane.showMessageDialog(null, "Especifique los datos necesarios. -Fecha- y -Proveedor-");
}
}
import com.entidades.CompraCab;
import com.entidades.CompraDet;
import com.entidades.Proveedor;
import com.informes.CompraR;
Por último el formulario en ejecución junto con el reporte. En caso que el reporte aparezca detrás del formulario, modificar la propiedad “modalityType” del “JDialog”,
indicando que sea “DOCUMENT_MODAL”. (clic para ampliar imagen)
021 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. Creando pantalla principal.
Después de haber diseñado todos los formularios de referencia, movimientos y reportes, debemos de crear un formulario tipo “JFrame” que servirá de pantalla principal o
acceso para cada módulo de nuestro sistema. La pantalla principal estará compuesta por una “Barra de Menú” y una “Barra de Herramientas”. El nombre del JFrame será
“Principal”. A continuación una imagen con la descripción general del diseño. (Clic sobre la imagen para ampliar).
Imagen con la especificación de cada elemento. Estos elementos como cualquier otro con las que se haya trabajado, se agregan desde la paleta con “arrastrar y soltar” al
lugar correspondiente. (Clic sobre la imagen para ampliar).
La “Barra de Menú” está compuesta por los siguientes “Menús”: Archivos, Referenciales, Transacciones, Informes y Ayuda. Cada elemento se agrega arrastrando y soltando
al lugar correspondiente desde la paleta y modificando el nombre por defecto del elemento. A su vez cada “menú” tiene sus elementos que se van a desplegar al hacer clic
sobre el ella. Una imagen con los elementos desplegados para entender mejor. (Clic sobre la imagen para ampliar).
A continuación vemos una imagen con ciertos métodos agregados en el constructor de formulario “Principal” que hay que tener en cuenta y las importaciones que
necesitamos. También hay que tener en presente el “LookAndFeel”, normalmente para que no se deforme el formulario utilizamos el "Windows". (Clic sobre la imagen para
ampliar).
Completado la parte del diseño debemos de crear los métodos que nos permitirán ejecutar cada uno de los formularios que hemos creada hasta ahora. Abajo todos los
métodos que estaremos utilizando en el formulario “Principal”.
private void llamarVentas(){
//Creamos una instancia del formulario VentaApp en este caso.
//Se le pasan dos parámetros (this, true), el primero indica el formulario padre, en este caso "Principal".
//El segundo si es modal o no.
VentaApp v = new VentaApp(this, true);
//Indicamos que se muestren las opciones "minimizar", "maximizar" y "cerrar"
v.setTitle("Formulario de Ventas");
v.setVisible(true);
}
//Los pasos para llamar cada formulario son iguales a la anterior.
private void llamarCompras(){
CompraApp c = new CompraApp(this, true);
c.setDefaultCloseOperation(HIDE_ON_CLOSE);
c.setTitle("Formulario de Compras");
c.setVisible(true);
}
private void llamarTipo(){

TipoApp t = new TipoApp(this, true);
t.setDefaultCloseOperation(HIDE_ON_CLOSE);
t.setTitle("Formulario de Tipos de Artículos");
t.setVisible(true);
}
private void llamarArticulo(){

ArticuloApp a = new ArticuloApp(this, true);
a.setDefaultCloseOperation(HIDE_ON_CLOSE);
a.setTitle("Formulario de Artículos");
a.setVisible(true);
}
private void llamarCliente(){

ClienteApp cl = new ClienteApp(this, true);
cl.setDefaultCloseOperation(HIDE_ON_CLOSE);
cl.setTitle("Formulario de Clientes");
cl.setVisible(true);
}
private void llamarFuncionario(){

FuncionarioApp f = new FuncionarioApp(this, true);
f.setDefaultCloseOperation(HIDE_ON_CLOSE);
f.setTitle("Formulario de Funcionarios");
f.setVisible(true);
}
private void llamarProveedor(){

ProveedorApp p = new ProveedorApp(this, true);
p.setDefaultCloseOperation(HIDE_ON_CLOSE);
p.setTitle("Formulario de Proveedores");
p.setVisible(true);
}
private void llamarReporteVenta(){

ReporteVenta rv = new ReporteVenta(this, true);
rv.setDefaultCloseOperation(HIDE_ON_CLOSE);
rv.setTitle("Reportes de Ventas");
rv.setVisible(true);
}
private void llamarReporteCompra(){

ReporteCompra rc = new ReporteCompra(this, true);
rc.setDefaultCloseOperation(HIDE_ON_CLOSE);
rc.setTitle("Reportes de Compras");
rc.setVisible(true);
}
El siguiente paso es agregar eventos a nuestros “Menús” y “Botones”. El tipo de evento que utilizaremos es el “ActionPerformed”. Los métodos que creamos más arriba,
cada una tiene el nombre bien especificado para saber a que formulario llama, por tanto será cuestión de enlazar con cada menú y botón correspondiente. Abajo una imagen
de referencia para manejar los eventos y la lista de “Eventos” respectivos.
//Evento para menú "Salir"
System.exit(0);
}
llamarVentas();
}

llamarCompras();
}

llamarVentas();
}

llamarCompras();
}

llamarTipo();
}

llamarArticulo();
}

llamarCliente();
}

llamarFuncionario();
}

llamarProveedor();
}

llamarReporteVenta();
}

llamarReporteCompra();
}
Completado todo lo anterior podremos ejecutar nuestro “Principal”. El último punto que veremos en otra entrada del blog será como compilar y obtener el “Executable Jar File
(.jar)”. (Clic en la imagen para ampliar).
022 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. Compilando Proyecto.
Llegado a este punto lo que nos resta es compilar el proyecto y obtener el ejecutable “.jar”. El primer paso es configurar ciertas propiedades del proyecto. En la imagen
siguiente se especifican los pasos. (Clic para ampliar imagen).
Ya configurado las propiedades específicas, ahora nos resta compilar el proyecto. Para esto debemos hacer clic derecho sobre la carpeta del proyecto, como en la imagen
más arriba y seleccionar “Limpiar y construir”. Si no se han encontrado errores, se crearán las carpetas necesaria y el archivo “.jar”. (Imagen de referencia, clic para ampliar).
Por último, el proyecto completo para descargar. Tomar en cuenta que hay que tener todas las bibliotecas necesarias para trabajar con el proyecto. En relación a la base de
datos, tener instalado y configurado el MySQL. Verificar que el “hibernate.cfg” este configurado de forma correcta, principalmente en relación al nombre de base de datos y
contraseña.
https://codigo--java.blogspot.pe/2013/12/022-aplicacion-de-stock-con-java.html

Tutoriales JAVA

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Tutoriales JAVA

Hochgeladen von

Copyright:

Verfügbare Formate

Tutoriales JAVA

Java Básico - Consola.

Palabras reservadas en Java.

Java. Tipos Primitivos de Variables.

Boolean 1 byte. Valores true y false

Char 2 bytes. Unicode. Comprende el código ASCII

Byte 1 byte. Valor entero entre -128 y 127

Int 4 bytes. Valor entero entre -2.147.483.648 y 2.147.483.647

Long 8 bytes. Valor entre -9.223.372.036.854.775.808 y 9.223.372.036.854.775.807

8 bytes (unas 15 cifras decimales equivalentes). De -1.79769313486232E308 a

//Inicio del método main que ejecuta la aplicación

public static void main(String[] arg){

System.out.print("Ingresa el primer número: ");

System.out.print("Ingresa el segundo número: ");

suma = (numUno + numDos);//realiza la suma

System.out.println("La Suma es: " + suma);//imprime el resultado

> > x>y x es mayor que y

< < x<y x es menor que y

≥ ≥ x >= y x es mayor o igual que y

≤ ≤ x <= y x es menor o igual que y

System.out.print( "Escriba el primer entero: " ); // indicador

System.out.print( "Escriba el segundo entero: " ); // indicador

if ( numUno < numDos ){

if ( numUno > numDos ){

if ( numUno <= numDos ){

if ( numUno >= numDos ){

Java básico 001. Condicional if-else.

public static void main(String[] arg){

Java básico 002. Uso de Scanner(System.in)

public static void main(String[] arg){

Scanner dato = new Scanner(System.in);

System.out.print("Ingrese el nombre: ");

System.out.print("Ingrese el sexo (Másculino - Femenino): ");

System.out.print("Ingrese edad: ");

System.out.println("* Nombre: " + nombre);

Java básico 003. Uso de Scanner(System.in), condicional “if”.

public static void main(String[] arg){

Scanner dato = new Scanner(System.in);

System.out.print("Ingrese el Nombre: ");

Java básico 004. Uso de Scanner(System.in) condicional “if-else”.

public static void main(String[] arg){

Scanner dato = new Scanner(System.in);

System.out.print("Ingrese el Nombre: ");

if(edad >= 18){

Java básico 005. Uso de Scanner(System.in), condicional “if-else”, Math.sqrt().

public static void main (String[] arg){

Scanner numero = new Scanner(System.in);

Java básico 006. Uso de Scanner(System.in), condicional “if”.

public static void main(String[] arg){

Scanner num = new Scanner(System.in);

System.out.print("Ingrese el primer número: ");

System.out.print("Ingrese el segundo número: ");

if(numUno >= 0){

Java básico 007. Uso de Scanner(System.in), condicional “if”, operador “&&”.

public static void main(String[] arg){

Scanner num = new Scanner(System.in);

System.out.print("Ingrese el primer número: ");

System.out.print("Ingrese el segundo número: ");

if(numUno >= 0 && numDos >= 0){

 '!=' : Niega el operando que se le pasa. Diferente de...

public static void main(String[] arg){

Scanner num = new Scanner(System.in);

System.out.print("Ingrese el primer número: ");

System.out.print("Ingrese el segundo número: ");