Está en la página 1de 147

Tutorial: Como crear y ejecutar un proyecto Java en NetBeans

Dandole seguimiento a la situación escolar, me he puesto manos a la obra y traigo ante ustedes un
breve pero completo tutorial, manual o guía para crear un proyecto Java en NetBeans.
Acontinuación las capturas de los pasos a seguir y sus explicaciones:
 Ejecutamos el IDE NetBeans.
Ya saben doble clic sobre el ícono en el escritorio o Inicio > Todos los programas > NetBeans >
NetBeans IDE 6.7.1. Y esperamos a que cargue completamente.

Con el programa en pantalla vamos al menú principal y seleccionamos File > New Project.

Tendremos una ventana como en la siguiente figura dónde seleccionamos el tipo de proyecto: Java >
Java Application y damos clic en el botón Next.
Categories: Java
Projects: Java Application
 En este paso vamos a escribir el nombre del proyecto que por convención Java, las primeras
letras de las palabras que contenga serán en mayúsculas: ProyectoPrueba.
Project Name: ProyectoPrueba
También deseleccionamos las casillas: Create Main Class y Set as Main Proyect.
Damos clic en el botón Finish.

 Teniendo el proyecto creado, ahora agregaremos(creamos) un paquete diferente al predefinido.


Damos clic derecho sobre <default package>: New > Java Package.
 Definimos el nombre del paquete, de misma forma que con los proyectos, por convención Java, el
nombre de los paquetes debe estar totalmente en minúsculas: proyectoprueba.
Package Name: proyectoprueba

 Creamos(agregamos) una clase a nuestro proyecto dando clic derecho sobre el paquete del paso
anterior: New > Java Class.
 Definimos el nombre de nuestra clase, que por convención Java, las letras iniciales de cada palabra
que contenga el nombre estarán en mayúsculas y sin espacios.
Class Name: Main.

 Ahora vamos a agregar o añadir codigo a nuestra clase para que tenga algún comportamiento en su
ejecución.
Método main()
1 public static void main(String[] args) {
2 System.out.println("Proyecto en NetBeans terminado(:");
3 }
 Para ejecutar un proyecto Java en NetBeans tenemos dos opciónes:
Clic en el botón Run Project, el cúal ejecutará la clase que contenga el método main().
Seleccionamos la clase que contenga el método main() y deseemos ejecutar, damos clic derecho
sobre dicha clase y seleccionamos Run File.

 Esperamos que se termine la ejecución y veremos el resultado que nos ha mostrado nuestra clase. En
este caso sólo imprimimos un mensaje por consola.

Fuente: http://mikengel.com/tutorial-como-crear-y-ejecutar-un-proyecto-java-en-netbeans
Java the Hutt

Objetivo
Aprender a utilizar Java y NetBeans para crear nuestra primera aplicación.
Producto a Entregar
Un archivo comprimido con el programa generado en la actividad.
Forma de Trabajo
Individual
Tiempo estimado
1 hora
Forma de Entrega
Por Blackboard
Recomendaciones
 Sigue las instrucciones de la actividad y ejercita la lectura crítica.
 Intenta familiarizarte con la herramienta ya que te ayudará a trabajar menos
 NetBeans te permtie trabajar escribiendo menos código. Recuerda utilizar la ayuda y el
autocompletado
 Realiza otros ejercicios para obtener más práctica

Instrucciones
Paso 1:
Antes de empezar veamos un poco de contexto sobre el lengauje de programación y el IDE que vamos
a utilizar.
Java es un lenguaje de programación orientado a objetos que comaprte gran parte de su sintaxis con C y
C++. Java es uno de los lenguajes más poderosos que existen actualmente y desde la versión 6 es un
proyecto open source, por lo que tiene el soporte de toda una comunidad de programadores, además de
Sun Microsystems que fueron los creadores originales. En 2005 Java se utilizaba en uno de cada cuatro
proyectos, casi diez por ciento por encima de su siguiente competidor(C++) y ha seguido creciendo. Se
estima que un noventa porciento de las computadoras cuentan con una máquina virtual de Java, además
de que todos los celulares y una gran cantidad de dispositivos móviles también cuentan con Java.
NetBeans es un entorno de desarrollo integrado(IDE por sus siglas en inglés). Esto quiere decir que
integra todas las herramientas que necesitamos para poder desarrollar. Originalmente la programación
en Java era algo complicada porque Java cuenta con una enorme cantidad de librearías y funciones que
era preciso aprenderse de memoria, viendo esto muchas compañías construyeron diferentes entornos de
programación para facilitar la tarea del programador. Entre los más populares surgió Eclipse que reinó
como el único y más importante IDE de Java durante varios años. Sun Microsystems desarrollo su
propio IDE, que tenía la ventaja de que fue creado por las mismas personas que crearon Java años
antes, este IDE fue NetBeans y después de varios años de desarrollo ha llegado a ser tan útil y poderoso
como Eclipse o quizás un poco más.
Paso 2:
Lo primero que debemos hacer es descargar el kit de desarrollo de Java y el entorno de programación
NetBeans. Podemos conseguir estas dos herramientas en el site oficial de Sun Microsystems. Dentro de
la página de descargas debemos descargar el JDK con NetBeans.
Una vez que hayamos descargado el paquete debemos correr el instalador. Después de aceptar la
licencia nos pregunta dónde queremos instalar y al final instala todos los componentes necesarios. Una
vez terminado de instalar debemos buscar el ícono de NetBeans en el escritorio o en el menú inicio.

Corremos el programa haciendo doble click y nos lleva a la pantalla principal que es similar a esta:

El editor gráfico de ventanas en NetBeans es parte de un proyecto llamado Matisse. Desde que salió
NetBeans 5.5 han habido varias mejoras importantes que hacen que sea mucho más fácil de utilizar y
estas mejoras van a ser implementadas en la versión 6.0 de NetBeans. Si estás utilizando una versión
anterior a la 6.0 puedes seguir los siguientes pasos para instalarlo:
1. Descarga el archivo con los módulos de matisse y extraelos en alguna carpeta.
2. Abre NetBeans
3. Selecciona el menú Tools -> Update Center
4. Selecciona Install Manually Downloaded Modules
En la ventana de seleccionar módulos presiona el botón Add y selecciona los módulos que se
encontraban dentro del archivo que descargaste en el primer paso.

5. Acepta el contrato de licencia y reinicia el IDE. Un IDE es una herramienta que nos permite escribir
código y compilar, en este caso se refiere a NetBeans.
Paso 3:
Ahora vamos a continuar con la creación del proyecto en sí. En esta pantalla podemos encontrar todas
las herramientas necesarias para crear y manejar nuestros proyectos hechos en Java. Por el momento
presiona el botón de nuevo proyecto. En la ventana que aparece selecciona un nuevo proyecto de Java.

En la segunda ventana ponle como nombre de proyecto HelloWorld. Es importante que en esta ventana
revises el directorio en el que se guarda el proyecto para que más adelante puedas acceder a tus
archivos o puedas agregar imágenes y sonidos.

Al terminar aparecerá la ventana de código en la que podemos comenzar a codificar nuestra aplicación.
Esto es lo que se llama una Clase en Java(esta clase en particular se llama Main, eso es un dato
importante porque lo vamos a utilizar más adelante). Las clases son el fundamento de la programación
orientada a objetos y podríamos decir que son el molde con el que hacemos nuevos objetos. Las clases
tienen atributos y métodos. Los atributos son lo que nos dice cómo es esa clase, por ejemplo, los
atributos de una persona son el color de ojos y el alto(entre muchos otros), los métodos son las acciones
que puede realizar una clase, por ejemplo correr.
En el código que se genera automaticamente por NetBeans tenemos dos métodos, el método Main()
que también se conoce como el constructor de la clase y el método main() que es el punto de inicio del
programa(por las mayúsculas y minúsculas Main es diferente de main).
Paso 4:
Dentro del método main() escribe el siguiente código:

Una vez que lo hayas escrito presiona el botón de compilar (o F11). En la ventana de compilación
deben aparecerte varios mensajes de compilación y debe terminar en BUILD SUCCESSFUL(total
time: 7 seconds). Esto quiere decir que nuestra aplicación compiló de manera adecuada y estamos listos
para correrla. Presiona el botón correr (o presiona F6). En la parte inferior de la pantalla debe
aparecer el letrero "Hola!".

¡Felicidades! Has creado tu primera aplicación Java con NetBeans, pero esto no es lo que queremos
que vea un cliente final. Para que un programa sea útil para cualquier persona es necesario que tenga
una interfaz gráfica así que vamos a utilizar Swing para crear una interfaz gráfica que nos muestre el
mismo mensaje.
Swing es un conjunto de librerías con las que cuenta Java para crear y mostrar una interfaz gráfica.
Dentro de estas librerías hay varias clases(recuerda, una clase es como un molde con el que podemos
hacer objetos) que nos permiten mostrar ventanas, mensajes, botónes, cajas de texto e incluso
imágenes, audio o video. Una de las clases más importantes de Swing es JFrame. Esta clase es una
ventana que tiene un contenedor en el que podemos poner controles.

Como podemos ver en la imagen un JFrame es una ventana normal de Windows. Dentro de un JFrame
existe algo llamado ContentPane. Un ContentPane es un contenedor de controles en el que podemos
agregar los elementos de la interfaz gráfica. Ahora veamos otro control importante en la generación de
interfaces gráficas. El JLabel es una etiqueta con la que podemos motrar texto en nuestras aplicaciones.
Un JLabel es una herramienta muy poderosa ya que nos permite agregar texto, cambiar el formato, la
posición, agregar imágenes y muchas cosas más. Vamos a crear una clase que sea un JFrame y después
vamos a agregarle un JLabel para mostrar nuestro mensaje.
Paso 5:
Vuelve al código de la clase Main. Como dijimos tenemos que convertir esta clase en un JFrame. Esto
es sencillo, lo único que debemos hacer es agregar la línea extends JFrame en la parte de arriba después
de dónde dice public class Main como se ve en la imágen.

Es importante notar que dejar un renglón entre el nombre de la clase y el extends no es necesario,
únicamente es para darle una mejor presentación al código, pero ustedes pueden seguir cualquier estilo
que ustedes consideren más claro. Después de escribir esta línea NetBeans la va a subrayar con una
línea roja, esto significa que el código tiene un error. Poniendo el mouse sobre el error podemos
obtener más información sobre él.

Paso 6:
El error que nos marca NetBeans es que no conoce el símbolo. Esto quiere decir que no sabe qué es un
JFrame, para resolver este tipo de errores debemos agregar la librería de la que hablaba hace unos
momentos, en estos momentos todavía no sabemos dónde está, pero por suerte NetBeans también nos
muestra un foquito a la izquierda en el que, al hacer click, nos brinda una solución. No siempre
podemos confiar en las soluciones que brinda NetBeans porque después de todo es una herramienta y
no una persona que nos está haciendo la recomendación, pero muchas veces su sugerencia es acertada,
como en este caso que dice que debe agregar un import(veremos más sobre este tema más adelante).
Selecciona la opción y debe aparecer una línea al principio de nuestra clase en la que resuelve el error.
Paso 7:
Como vimos en la parte de arriba el método Main(con mayúscula) es el constructor de la clase. Este es
el método con el que vamos a crear nuevos objetos de nuestra clase(que es una ventana). Dentro de este
método debemos escribir algunas líneas de código para darle un tamaño a la ventana y para que se
muestre. Copia el código que se muestra en la siguiente imágen:

En el código estamos utilizando la palabra clave this, que hace referencia a la misma clase que lo llama,
es decir, a nuestra ventana. La primera línea va a cambiar el tamaño de nuestra ventana a 200 x 200.
Escribe this.setS y espera unos momentos. Aparecerá una pantalla que te muestra opciónes de auto
completar. Esta pantalla es muy útil al programar ya que cuando no conocemos un método nos brinda
información sobre qué significan los parámetros y cómo utilizar el método.

Por ejemplo, en esta imágen nos indica que el método setSize() debe recibir dos números enteros(int
quiere decir número entero), y nos dice que el método va a cambiar el tamaño del componente(en este
caso nuestra ventana) para que tenga el ancho y alto especificados. Tambíen nos indica que podemos
conseguir más información viendo los métodos getSize(), setBounds() y setMinimumSize(). Utilizando
esta herramienta completa el código para mostrar la ventana.
La segunda línea nos permite cambiar el título de nuestra aplicación. Podemos utilizar cualquier título
que nos guste, lo único importante es pasarlo entre comillas porque es texto. La tercera línea le dice a
nuestra aplicación qué debe hacer cuando el programa termine. En este caso nuestro constructor es
únicamente una ventana, por lo que le indicamos que al cerrar la ventana la aplicación termine con
EXIT_ON_CLOSE. La cuarta línea le indica a la ventana que es visible, por lo tanto se dibuja en
pantalla.
Paso 8:
Por último debemos crear un nuevo objeto de nuestra ventana, esto es muy sencillo y lo logramos
agregando la línea que se ve en la imágen dentro del método main()(con minúscula).

Esta línea está creando un nuevo objeto de la clase Main mandando llamar el constructor que acabamos
de crear. Compila tu programa haciendo click en el botón compilar y luego córrelo haciendo click
en el botón correr .
Con esto se muestra una ventana vacía, ya casi hacemos el programa que queríamos, pero nos falta un
mensaje. Para eso vamos a utilizar otra clase de Swing que se llama JLabel. En la parte superior del
constructor escribe el código como se ve en la imagen:

Una vez más la primera línea va a ser subrayada en rojo porque nos falta importar una librería. Ahora
vamos a utilizar otra técnica para resolver este mismo error. Haz click derecho sobre el código y
selecciona la opción "Fix Imports". Con esto NetBeans revisará todo el código y automaticametne va a
agregar todas las librearías que necesitamos.
En el código lo que estamos haciendo es crear un nuevo JLabel. Su nombre será lblHola(por
convención todos los JLabel deben empezar su nombre con lbl) y este JLabel va a ser un nuevo JLabel
que diga "Hola". Después agregamos el JLabel al contenedor de la ventana.
¡Felicidaes, hemos terminado nuestra primera aplicación en NetBeans utilizando interfaz gráfica!
Una vez que hayas terminado tu programa debes comprimir el directorio de la aplicación que
seleccionaste en el paso 2 y mandarlo por blackboard.
Fuente: http://www.magusoft.net/compuv/01_Netbeans.html
Conexión a una base de datos en MySQL con Java
Para poder hacer una conexión a una base de datos, tendríamos que importar una librería, que por lo
generalmente se encuentra en NetBeans y se le conoce por mysql-connector-java-5.1.6-bin, buena para
el programa voy a utilizar de ejemplo un JFrame como el siguiente:
Lo que está utilizando son 1 JPanel, 4 JLabels, 2 JTextfields, 1jPasswordField(para la contraseña
claro).
Utilizaremos el siguiente código:
static String Exe3 = "";
static String Exe4 = "";
static String Exe5 = "";

/** Creates new form conx */

public conx() {
initComponents();
}

public void conex1() throws SQLException {


try {
Exe3 = this.jTextField1.getText();
Exe4 = this.jPasswordField1.getText();
Exe5 = this.jTextField2.getText();
String serverName = Exe5;
int port = 3306;

String dataBase = "ejem";


Class.forName("com.mysql.jdbc.Driver");
String url = "jdbc:mysql://" + serverName + ":" + port + "/" + dataBase;
Connection con = DriverManager.getConnection(url, Exe3, Exe4);
Statement stm = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
ResultSet.CONCUR_UPDATABLE);
if(con != null) {
usu ex= new usu();
ex.setVisible(true);
this.dispose();
}
if(con == null) {
this.jTextField1.setText("");
this.jPasswordField1.setText("");
this.jLabel4.setText("Error vuelve a intentarlo");
}

stm.close();
con.close();
}catch(ClassNotFoundException ex) {

System.out.println(ex);
System.out.println("error en la linea Entrada");
}
}
Como se puede observar un String para el nombre del servidor, otro para la base de datos, un entero
para el número del puerto(que por default el 3306 siempre es de MySQL).
Este JFrame sirve como la base de algún programa, pues como lleva Strings Estáticos no hay necesidad
de volverlo a crear solo de exportar, por ejemplo si alguno de ustedes necesita que invocar en otro
Frame el nombre del servidor lo único que debes de hacer es poner lo siguiente:
String url = "jdbc:mysql://" + conx.Exe5 + ":" + port + "/" + dataBase;
Fuente: http://www.taringa.net/posts/info/6407848.R/Conexion-a-una-base-de-datos-en-MySQL-con-
Java.html
TaT CambiarIconoJFrame
Cómo cambiar el ícono de un JFrame en cinco pasos.
Paso 1
El ícono debe ser una imagen de extensión PNG. Esto se hace más fácil, ya que conseguir una figura y
convertirlo en formato .ico es muy complicado. Los PNG nos ayudan bastante.
Paso 2
La imagen que será el ícono debe estar dentro del paquete de fuentes, como si fuera una clase más. Si
estuviera dentro de un paquete, sería mucho mejor.

Paso 3
En el código del JFrame que vamos a poner el ícono, sobreescribimos el método getIconImage()
conteniendo el siguiente código: (notar cómo se está llamando a la imagen .png)
@Override
public Image getIconImage() {
Image retValue = Toolkit.getDefaultToolkit().
getImage(ClassLoader.getSystemResource("resources/icono.png"));
return retValue;
}
Paso 4
En la vista de diseño del JFrame, lo seleccionamos y vamos sus propiedades, buscamos la propiedad
"iconImagen" y hacemos clic en el botón de puntos suspensivos. Se mostrará una ventana de diálogo
como esta:

De la lista desplegable, seleccionamos "Valor de componente existente". Esto hará que cambie la
ventana a la siguiente forma:
Seleccionamos la opción "Propiedad" y hacemos clic en el botón de puntos suspendidos. Aparecerá una
ventana de diálogo más pequeña, y seleccionamos la propiedad "iconImage" que aparece ahí.

Clic en Aceptar, y se verá así:


y nuevamente clic en "Aceptar" para cerrar la ventana de selección de imagen.
Ahora, veremos que las propiedades del JFrame ya tiene un nuevo valor

Paso 5
Ejecutamos la aplicación con el JFrame, y voila! nuestro JFrame con un ícono diferente

Fuente: http://wiki.netbeans.org/TaT_CambiarIconoJFrame
JFrame y JDialog
Cuándo usar JFrame y cuándo JDialog
En una aplicación java con ventanas debería haber un único JFrame, correspondiente a la ventana
principal de la aplicación. El resto de ventanas secundarias deberían ser JDialog.
Un JFrame en una ventana que en Windows crea, en la barra de herramientas, donde está el menú de
"inicio" y las aplicaciones que tenemos abiertas, un nuevo botón de aplicación abierta. En una
aplcación lo normal es que sólo haya un botón ahí. Si creamos varios JFrame en nuestra aplicación,
apareceran varios botónes, uno por cada JFrame.
El JDialog no muestra este botón. Por ello, el resto de las ventanas de nuestra aplicación deberías ser
JDialog.
Hay otro motivo más. Un JFrame no admite a ninguna otra ventana como padre. El JDialog sí admite
como padres un JFrame u otros JDialog. Esto es importante porque una ventana hija siempre quedará
por encima de su ventana padre. Si al crear los JDialog les pasamos el JFrame como padre, los
JDialog siempre estarán visibles por encima del JFrame. No se podrán ir "detrás" de él.
Si además, en el constructor del JDialog ponemos a true el flag que indica que es modal, además de
pasarle una ventana padre, entonces el JDialog impedirá el acceso a las otras ventanas hasta que se
cierre.
Puedes ver esto más detallado (y embarullado) en:
http://www.chuidiang.com/java/novatos/JFrame_JDialog.php
Cambiar el icono de la taza de café en JFrame y JDialog
Cambiar el icono de la taza de café que aparece en los JFrame, arriba a la izquierda, es fácil. Basta con
llamar al método setIconImage() del JFrame.
frame.setIconImage (new ImageIcon("fichero.gif").getImage());
Los JDialog no tienen este método, pero heredan el icono de su ventana padre. Por ello, basta con
crearlos pasándoles como padre en el constructor un JFrame que tenga el icono cambiado, o bien otro
JDialog que a su vez se le haya cambiado el icono
JDialog dialog = new JDialog (frame);
Abrir y cerrar ventanas secundarias (JDialog) desde la primaria (JFrame)
En el siguiente código de ejemplo, una ventana principal JFrame tiene un botón para abrir una ventana
secundaria JDialog.
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.WindowConstants;

public class DosVentanas {

private JFrame ventanaPrincipal;


private JDialog ventanaSecundaria;
/**
* @param args
*/
public static void main(String[] args) {
new DosVentanas();
}

public DosVentanas()
{
// Construcción de ventana principal
ventanaPrincipal = new JFrame("Ventana principal");
JButton botón = new JButton("Abre secundaria");
ventanaPrincipal.getContentPane().add(botón);
ventanaPrincipal.pack();

// Construcción de ventana secundaria


ventanaSecundaria = new JDialog(ventanaPrincipal,"Ventana secundaria");
JLabel etiqueta = new JLabel("Hola");
ventanaSecundaria.getContentPane().add(etiqueta);
ventanaSecundaria.pack();
// Hacer que el botón abra la ventana secundaria y cierre la
// principal
botón.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
ventanaPrincipal.setVisible(false);
ventanaSecundaria.setVisible(true);
}

});

// Hacer que al cerrarse la secundaria con la x de arriba a la


// derecha, se muestre la primaria
ventanaSecundaria.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
ventanaPrincipal.setVisible(true);
ventanaSecundaria.setVisible(false);
}

public void windowClosed(WindowEvent e) {


ventanaPrincipal.setVisible(true);
ventanaSecundaria.setVisible(false);
}
});

// Mostrar la ventana principal

ventanaPrincipal.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
ventanaPrincipal.setVisible(true);
}

}
En primer lugar se construyen la ventana primaria y secundaria, una con un botón y la otra con una
etiqueta.
Luego al botón se le añade un ActionListener para que oculte la principal y muestre la secundaria
cuando se pulsa.
Finalmente se añade un WindowAdapter a la ventana secundaria para enterarnos de cuándo se cierra
pulsando la x de arriba a la derecha. Cuando esto sucede, mostramos la ventana primaria y ocultamos la
secundaria.
Centrar una ventana en pantalla
Si queremos que una ventana nos salga centrada en la pantalla, antes del jdk 1.4 no nos quedaba más
remedio que echar unas cuentas. El código podía ser como este:
// Se da a la ventana el tamaño, con pack() o setSize()
v.pack();

// Se obtienen las dimensiones en pixels de la pantalla.


Dimension pantalla = Toolkit.getDefaultToolkit().getScreenSize();

// Se obtienen las dimensiones en pixels de la ventana.


Dimension ventana = v.getSize();

// Una cuenta para situar la ventana en el centro de la pantalla.


v.setLocation(
(pantalla.width - ventana.width) / 2,
(pantalla.height - ventana.height) / 2);

// Se visualiza la ventana.
v.setVisible(true);
Para que el método pack() dé un tamaño adecuado a la ventana es necesario que la ventana ya tenga
dentro los componentes y que estemos usando un Layout que no sea null.
Desde la versión 1.4 del JDK existe un método de la clase JWindow que realiza la operación de centrar
la ventana sobre otro componente especifico. Este método es setLocationRealtiveTo(JComponenet
otroComponente), donde otroComponente es cualquier componente sobre el que queremos que salga
centrada la ventana p.e: JFrame, JDialog, JButton, JTextField, etc...
// La ventana saldrá centrada sobre el botón unBotón.
v.setLocationRelativeTo (unBotón);
Si se pasa null como valor a este parámetro, entonces la ventana se centrara justo al centro de la
pantalla del PC...
// La ventana saldrá centrada en pantalla.
v.setLocationRelativeTo (null);
Fuente: http://chuwiki.chuidiang.org/index.php?title=JFrame_y_JDialog

Creación de la Clase SelectorColoresMarc


El selector de colores lo crearemos en una ventana siguiendo los siguientes pasos:
nos situamos en la ventana Projects y con el botón derecho del ratón seleccionamos el paquete paqawt.
Entonces elegimos New | Other...

se abre el cuadro de diálogo New File y abrimos las carpetas Java GUI Forms y AWT Forms. Entonces
elegimos Frame Form y hacemos clic sobre el botón .

se abre el cuadro de diálogo New Frame Form. En el campo de texto Class Name: introducimos el
nombre de la Clase SelectorColoresMarc y finalmente hacemos clic sobre el botón
Este Asistente (Wizard) nos ha creado una pestaña llamada SelectorColoresMarc, la cual contiene dos
botónes Design y Source.
Cuando el botón Design está activo entonces el IDE nos proporciona un entorno gráfico para diseñar
nuestras aplicaciones visuales. Si hacemos clic sobre el marco que tenemos en el área de diseño
podemos ver la ventana Properties que en el futuro nos será muy útil para cambiar las diferentes
propiedades de los componentes visuales Java.

Ahora vamos a hacer clic sobre el botón Source para ver el código fuente Java generado por el
Asistente
NetBeans, al igual que otros entornos de desarrollo Java, no permite que el desarrollador pueda
modificar código en algunos métodos que están relacionados con el entorno gráfico.
La causa de esta restricción es debido a la sincronización que el entorno de desarrollo tiene que realizar
cuando pasa de Diseño a Código fuente y viceversa.
Para evitar posibles errores en la escritura de código relacionado con la parte visual, NetBeans prefiere
que el trabajo visual se realice directamente en este caso en el entorno gráfico en vez de codificarlo
nososotros mismos.
NetBeans nos indica que no podemos modificar o añadir nuevo código con un fondo de color azul
Este es el código de la Clase SelectorColoresMarc creado por el Asistente
package paqawt;
public class SelectorColoresMarc extends java.awt.Frame {
public SelectorColoresMarc() {
initComponents();
}

private void initComponents() {


addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosing(java.awt.event.WindowEvent evt) {
exitForm(evt);
}
});

pack();
}
private void exitForm(java.awt.event.WindowEvent evt) {
System.exit(0);
}

public static void main(String args[]) {


java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new SelectorColoresMarc().setVisible(true);
}
});
}
}
new SelectorColoresMarc().setVisible(true);
se crea una instancia de la Clase SelectorColoresMarc
public SelectorColoresMarc() {
initComponents();
}
cuando se está creando el Objeto se llama al Constructor y éste a su vez realiza una invocación al
método initComponents()
en entornos de desarrollo como por ejemplo JBuilder, en vez de llamar a este método hubiera llamada
al método jbInit(). Estos IDEs se crean un método propio donde depositan el código Java referente a la
parte visual. Así cuando pasamos del entrono de codificación al entrono visual el parsing de código
java a entorno visual lo realizan de una forma más rápida y optimizada.
el código de este método ya lo estudiaremos más adelante.
new SelectorColoresMarc().setVisible(true);
como podemos observar el Asistente no nos ha creado un código con una variable de referencia como
por ejemplo
SelectorColoresMarc marco = new SelectorColoresMarc();
marco.setVisible(true);
por que en este caso ha considerado que la variable de referencia marc no la necesita. Simplemente crea
un Objeto de tipo SelectorColoresMarc y seguidamente en la misma línea de código ya habla con uno
de sus métodos sin necesidad de utilizar una variable de referencia.
el método setVisible(true) se utiliza para mostrar en pantalla el Objeto SelectorColoresMarc que ya está
instanciado en memoria. Más adelante ya veremos como las aplicaciones gráficas primero se
construyen en memoria y seguidamente cuando todos sus componentes ya están inicializados se
muestran dichos componentes en la pantalla.
Ahora ejecutamos esta Clase, y vemos una ventana sin dimensiones

Para que el Frame (marco, ventana) tenga dimensiones, vamos a modificar el código perteneciente al
método main(...)
package paqawt;
public class SelectorColoresMarc extends java.awt.Frame {
public SelectorColoresMarc() {
initComponents();
}
private void initComponents() {
addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosing(java.awt.event.WindowEvent evt) {
exitForm(evt);
}
});
pack();
}
private void exitForm(java.awt.event.WindowEvent evt) {
System.exit(0);
}
public static void main(String args[]) {
SelectorColoresMarc marco = new SelectorColoresMarc();
marco.setSize(300,200);
marco.setTitle("Selector de colores");
marco.setVisible(true);
}
}
Y ahora ya podemos ejecutar esta Clase para ver una ventana con dimensiones.
Fuente:
http://www.javadabbadoo.org/cursos/infosintesis.net/javase/paqawt/selectorcolores/paso01operativa.ht
ml

Comandos SQL desde NetBeans


Bueno es este unos de los casos en el que se puede acelerar las cosas teniendo una herramienta que te
permita hacer varias cosas a la vez.
En este caso con el NetBeans 6.5 podemos hacer nuestras consultas a BD.(aunque en las versiones
anteriores también lo hacían pero ahora hay mas opciónes de administración).
1.-Como siempre nos vamos a la opción Presentaciones(ejecución o RUNTIME). Seguidamente en le
icono de Base de datos(click derecho y buscar en Nueva Conexión)

2.-Al dar en nueva conexón nos saldrá la siguiente interfaz donde tendremos que colocar la
información de tu BD(en este caso MySql).
Adicionalmente decir que te piden el driver dependiendo de la conexion en este caso del mysql
conector.
3.-Al conectarte te saldrá el icono con el nombre de tu BD, para ejecutar comandos sólo ponemos click
derecho EJECUTAR COMANDO...

4.-Escribimos la sentencia y ejecutamos.


Como ven hay más opciónes que en las versiones anteriores como en el 5.5 sólo teniamos para ser
sentencia entre otras cosas.Pero ahora tenemos para limpiar Tabla,actualizar registros,insertar
registros,entre otros.
Fuente: http://javaycafe.blogspot.com/2009/01/comandos-sql-desde-netbeans.html
Conectando PostgreSQL con NETBEANS JAVA
En este pequeño tutorial enseñaré la forma de conectar nuestra base de datos PostgreSQL 8.3 con el
IDE Netbeans, es muy sencillo, antes que todo necesitamos bajar nuestro Driver, el cual nos permitira
conectarnos y hacer puente entre ambos DESCARGAR
Una vez ya descargado estaríamos en condiciones para poder conectarnos.
Abrimos NetBeans y vamos al Menú Herramientas (Tools) y luego a Librerías, ahí seleccionamos
“Nueva Librería” nos aparece “Nombre de librería” digitamos PostgreSQL y dejamos la opción por
default en el campo tipo de librería y presionamos el botón Ok.

Luego presionamos el Botón Add Jar/Folder, ahí seleccionamos nuestro driver que acabamos de
descargar, el cual se deberia llamar postgresql-8.3-603.jdbc4.jar y presionamos OK. y en la siguiente
ventana tambien OK.
Con esto estamos en condiciones de hacer nuestro primer programa que se conecte con la base de datos
desde java.
Ahora haremos la conexion con nuestra base de datos
package ejemplo;
import java.sql.*; // importamos java.sql para poder trabajar con SQL
public class Main {
public Main() {
}
public static void main(String[] args) {
String driver = “org.postgresql.Driver”; // el nombre de nuestro driver Postgres.
String connectString = “jdbc:postgresql://localhost:5432/ejemplo/”; // llamamos nuestra bd
String user = “postgres”; // usuario postgres
String password = ” “; // no tiene password nuestra bd.
try {
Class.forName(driver);
//Hacemos la coneccion.
Connection conn = DriverManager.getConnection(connectString, user, password);
//Si la conexion fue realizada con exito, muestra el sgte mensaje.
System.out.println(“Conexion a la base de datos Ejemplo realizada con exito! “);
//Cerramos la conexión
conn.close();
}
//Si se produce una Excepción y no nos podemos conectar, muestra el sgte. mensaje.
catch(SQLException e) {
System.out.println(“Se ha producido un error en la conexion a la base de datos Ejemplo! “);
}
}
Fuente: http://migue85.wordpress.com/2008/07/11/conectando-postgresql-con-netbeans-java/
Conectar Java con MySQL en NetBeans
Dentro de unas semanas tendré que desarrollar, junto con un equipo de trabajo, un sistema de un
almacen en Java bajo la plataforma de NetBeans. Es por eso que comenzaré a pubicar una serie de post
sobre cómo manejar bases de datos de MySQL con Java, y en los cuales poco a poco iré agregando
nuevas funcionalidades.
Por ahora solo mostraré cómo realizar la conexión a la base de datos de MySQL.
Para comenzar debemos de tener instalado NetBeans, en lo particular yo tengo instalada la versión 6.0.
Posteriormente debemos descargar un Driver o Conector para poder conectarnos a la base de datos. Se
puede decir que ese Driver sabe “cómo hablar con la base de datos”, yo descargué la versión 5.0.
Una vez descargado el archivo, extraemos los componentes, de estos el archivo que nos interesa es
mysql-connector-java-5.0.5-bin.jar, este jar es la clase o Driver que nos permitirá conectarnos a la
base de datos.
Ahora tenemos que hacer que esa clase esté accesible para nuestros proyectos, así que la vamos a
guardar en la carpeta <DIRECTORIO_DE_JAVA>/jre/lib/ext. Si has realizado una instalación por
defecto del NetBeans en Windows, entonces estará en:
C:\Archivos de programa\Java\jdk1.6.0_04\jre\lib\ext. En esta carpeta es donde se agregan los jar
adicionales, y así ya los tendremos disponibles para cuando necesitemos usarlos de nuevo.
Ahora que ya tenemos el conector a la base de datos pasaremos a la parte del NetBeans:
1. Creamos un nuevo proyecto: New Project -> Java -> Desktop Application (Basic application).
2. Agregamos un botón al formulario y le cambiamos su label a “Cargar datos”.
3. Agregamos una nueva clase llamada TestConnection
import java.sql.*;
public class TestConnection {
public String bd = "nombre_bd";
public String login = "usuario";
public String password = "contraseña";
public String url = "jdbc:mysql://localhost/"+bd;
public void conectar() {
Connection conn = null;
try {
Class.forName("org.gjt.mm.mysql.Driver");
conn = DriverManager.getConnection(url, login, password);
if (conn != null)
{
System.out.println("Conexión a base de datos "+url+" ... Ok");
conn.close();
}
}
catch(SQLException ex) {
System.out.println("Hubo un problema al intentar conectarse con la base de
datos "+url);
}
catch(ClassNotFoundException ex) {
System.out.println(ex);
}
}
}

4. Hacemos doble clic en el botón “Cargar datos” y colocamos el siguiente código:


sourcecode language=’java’ [
TestConnection conexion = new TestConnection();
conexion.conectar();
]

Y listo!!!. Con esto ya tenemos realizada la conexión a la base de datos de MySQL


Fuente: http://fragowb.wordpress.com/2008/05/01/conectar-java-con-mysql-en-netbeans/
Java - LLenar un JTable con ResultSet
1. Entorno
 JDK 6 Update 21
 Netbeans 6.9.1
 MySQL 5.1.

2. Introducción
Lo que se desea demostrar en este tutorial es como mostrar los datos de una consulta en un JTable.
Haciendo uso de la clase ResultSetMetaData que nos brinda la información de una tabla de la base de
datos y la clase ResultSet que nos devuelve la data producto de una consulta hacia la base de datos.
3. Desarrollo
3.1. Crear el proyecto
Primero debemos de crear un proyecto en Netbeans para eso nos vamos a "File->New Project" y
seleccionamos la opción de crear un "Java Application"

Y como nombre al proyecto le ponemos "LlenarJTable"


Al proyecto debemos de agregar un formulario (JFrameForm) que lo llamaremos "frmLlenarJtable".
Para hacemos clic derecho en el paquete que se llama "llenarjtable" de ahí seleccionamos New y
elegimos "JFrame Form"

3.2. Diseño del Formulario


Debemos de diseñar el siguiente formulario:

Donde:
El JTextBox: Recibe el nombre de txtQuery
El JTable: Recibe el nombre de jtQuery
El JButton: Recibe el nombre de btnConsultar
3.3. Crear base de datos en MySQL
Debemos de crear una base de datos en MySQL. A la base de la llamaremos "bdproductos" y también
crearemos una tabla que se llamara "producto"
3.4. Codificando el action del botón "Consultar"
Debemos de codificar la acción del botón "Consultar" que va a llenar al JTable con la data producto de
la consulta que vamos a hacer a la base de datos bdproductos que esta en MySQL. No olvidar agregar
el conector al Netbeans para poder comunicarnos con MySQL.

Para ir a la Action del botón debemos hacer clic derecho en el botón de ahí seleccionamos Events,
luego Action y finalmente ActionPerformed
Y luego dentro de ese evento ponemos el siguiente codigo
try {
//Para establecer el modelo al JTable
DefaultTableModel modelo = new DefaultTableModel();
this.jtQuery.setModel(modelo);
//Para conectarnos a nuestra base de datos
DriverManager.registerDriver(new com.mysql.jdbc.Driver());
Connection conexion = DriverManager.getConnection("jdbc:mysql://localhost/bdproductos",
"usuario", "clave");
//Para ejecutar la consulta
Statement s = conexion.createStatement();
//Ejecutamos la consulta que escribimos en la caja de texto
//y los datos lo almacenamos en un ResultSet
ResultSet rs = s.executeQuery(txtQuery.getText());
//Obteniendo la informacion de las columnas que estan siendo consultadas
ResultSetMetaData rsMd = rs.getMetaData();
//La cantidad de columnas que tiene la consulta
int cantidadColumnas = rsMd.getColumnCount();
//Establecer como cabezeras el nombre de las colimnas
for (int i = 1; i <= cantidadColumnas; i++) {
modelo.addColumn(rsMd.getColumnLabel(i));
}
//Creando las filas para el JTable
while (rs.next()) {
Object[] fila = new Object[cantidadColumnas];
for (int i = 0; i < cantidadColumnas; i++) {
fila[i]=rs.getObject(i+1);
}
modelo.addRow(fila);
}
rs.close();
conexion.close();
}catch (Exception ex) {
ex.printStackTrace();
}
4. Ejemplo de la aplicación
Sin poner etiquetas a la consulta
Con etiquetas a la consulta

Fuente: http://www.programandoconcafe.com/2010/11/java-llenar-un-jtable-con-resultset.html

Centrar un JFrame/JDialog en pantalla


Al crear un nuevo JFrame ó JDialog en Swing, al hacerlos visibles estos aparecerán arriba a la
izquierda de nuestra pantalla. Por ejemplo si realizamos:
import javax.swing.JFrame;
public class Prueba{
public static void main(String[] args){
JFrame frame = new JFrame("Prueba JFrame");
frame.setSize(500, 500);
frame.setDefaultCloseOperation(frame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}
al ejecutarlo, veremos como resultado así:
Si ahora especificamos por medio del método setLocationRelativeTo a null, la ventana se posicionará
en el medio de la pantalla. Por lo que si agregamos la siguiente linea:
import javax.swing.JFrame;

public class Prueba{


public static void main(String[] args){

JFrame frame = new JFrame("Prueba JFrame");


frame.setSize(500, 500);
frame.setLocationRelativeTo(null);
frame.setDefaultCloseOperation(frame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}
tendremos un resultado similar a este:

Fuente: http://lefunes.wordpress.com/2008/02/11/centrar-un-jframejdialog-en-pantalla/

Centrar JDialog en Jframe


Si lo que deseamos es centrar un JDialog en el JFrame “padre”, lo que hacemos es usar el mismo
método, pero esta vez especificando que la posicioón de apertura del JDialog será con respecta al
JFrame:
import javax.swing.JFrame;
public class Prueba{
public static void main(String[] args){

JFrame frame = new JFrame("Prueba JFrame");


frame.setSize(500, 500);
frame.setLocationRelativeTo(null);

final JButton botón = new JButton("Abrir Dialogo");


botón.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
JDialog dialogo = new JDialog(frame);
dialogo.setSize(100, 100);
dialogo.setLocationRelativeTo(frame);
dialogo.setVisible(true);
}
});

frame.add(botón);
frame.setDefaultCloseOperation(frame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}
los que no da como resultado al hacer click:
Fuente: http://lefunes.wordpress.com/2008/02/11/centrar-un-jframejdialog-en-pantalla/

Asesoramiento en programa
Hice el acceso al programa mediante una contraseña(necesaria) con dos clases.
la q contiene el metodo main:
Código:
public class aplicacion {
public static void main(String[] args) {
contraseña obj=new contraseña();
}
}

Y la q contiene las especificaciones de la ventana:


Código:
import java.awt.Color;
import javax.swing.*;
import javax.swing.JFrame;
import java.awt.event.*;
public class contraseña {
public contraseña(){
final JFrame marco=new JFrame("Acceso de programa");//CREAMOS EL MARCO DE LA
VENTANA
//espacio deonde van los componentes
JDesktopPane esc=new JDesktopPane();

JLabel eusuario=new JLabel("Usuario:");


JLabel econtraseña=new JLabel("Contraseña:");
final JTextField usuario=new JTextField();
final JPasswordField contraseña = new JPasswordField();
JButton cerrar=new JButton("cerrar");
JButton ingresar=new JButton("ingresar");

//ubicacion en el plano
eusuario.setBounds(10,10,100,30);
usuario.setBounds(90,10,190,30);
econtraseña.setBounds(10, 50, 100, 30);
contraseña.setBounds(90,50,190,30);
cerrar.setBounds(180, 100, 100, 30);
ingresar.setBounds(10, 100, 100, 30);
//ocultamos la contraseña rusticamente
//agregar al escritorio los diferentes objetos
esc.add(eusuario);
esc.add(usuario);
esc.add(econtraseña);
esc.add(contraseña);
esc.add(cerrar);
esc.add(ingresar);
esc.setBackground(Color.LIGHT_GRAY);//esto es solo para distinguir el escritorio de la ventana

marco.add(esc);//este agrega el escritorio a la ventana


marco.setSize(300,180);//le damos tamaño variable
marco.setLocationRelativeTo(null);
marco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
marco.setVisible(true);//luego ir al metodo main a ocupar esta clase como metodo para un objeto

//programamos los botónes


ingresar.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
String user;
String clave;
clave=contraseña.getText();
user= usuario.getText();

if (user.equalsIgnoreCase("felipe")&&clave.equals("cbrfelipe")){
JOptionPane.showMessageDialog(null,"Bienvenido al sistema");//aprobacion
//abrir otro FRAME Programa
programa frame=new programa();// con este me muevo a la siguiente ventana... me costo caleta
pillarlo
marco.setVisible(false);
}else JOptionPane.showMessageDialog(null,"reintentar");
}
});

cerrar.addActionListener(new ActionListener(){//para el botón cerrar tan solo ocupamos exit


public void actionPerformed(ActionEvent e){
System.exit(0);
}

});

}
Fuente: http://www.elcachondeo.cl/foro/f135/2031731-asesoramiento-en-programa/

Cómo usar frames y diálogos en Java Netbeans


Todos los programas que vemos en el escritorio de Windows o Linux usan ventanas es por eso una de
las razones que el sistema más usado en el mundo tiene el nombre “ventana” en ingles Windows,
cuando hacemos sistema en Java Netbeans existen dos tipos de ventanas que son: Frames y diálogos. A
continuación te estaremos hablando de cada una de ellas.
Visita mi web:http://www.wix.com/foxsoftware/estudiosavefenix
Los FRAMES son ventanas principales que no necesitan de la existencia de otras para existir, por
ejemplo la ventana principal de WORD o EXCEL podemos tener varios WORD abiertos al mismo
tiempo todos son independientes esos y no necesitan de otra ventana para su existencias en JAVA estas
ventanas principales se llaman FRAME y cuando se las da un nombre se acostumbra a poner el nombre
que lo identifica y con la terminación FRAME por ejemplo MAINFRAME es el FRAMA principal, o
NEWITEMFRAME u FRAME para crear un nuevo ítem.
Los DIALOGOS son ventanas también al igual que las ventanas de tipo FRAME pero con la diferencia
que estos bloquean al formulario o ventana padre hasta que se cierre el DIALOGO.
Bueno primeramente vamos a crear un FRAME principal y abrir otro FRAME a través de un botón en
el FRAME principal.
Creamos un nuevo proyecto:

Ahora escogemos JAVA y JAVA APPLICATION y después clic en el botón NEXT:

Luego dejamos las opciónes como se muestra en la siguiente imagen:

Ahora hacemos clic en FINISH, y ahora creamos nuestro primer JFRAME haciendo clic derecho en el
icono en forma de una taza de café de nuestro proyecto que acabamos de crear como en la siguiente
imagen:

Dejamos las opciónes como en la siguiente imagen:


Luego hacemos clic en FINISH recuerda que nuestro primer FRAME se llama NEWJFRAME como se
muestra en la anterior imagen.
De la misma manera creamos otro FRAME llamado NEWJFRAME1:

Ahora ya tenemos dos JFRAME vamos abrir el JNEWFRAME1 a través del NEWJFRAME por medio
de un JBUTTON.
Ahora hacemos clic en el NEWJFRAME1 y en sus propiedades cambiamos la propiedad
DEFAULTCLOSEOPERATION de EXIT_ON_CLOSE A DISPOSE, como se muestra en la siguiente
imagen recuerda que es del NEWJFRAME1:

Esto hemos hecho para que cada FRAME sea independiente a la hora de cerrar y o se sierren todas
cuando cerremos una.
Ahora agregamos un botón al otro NEWJFRAME al primero que creamos y abrimos su código de su
evento con clic derecho como en la siguiente imagen:

Y escribimos en siguiente código como en la siguiente imagen:

Listo con eso cuando hagamos clic en el botón se abrirá nuestro NEWJFRAME1, cuando ejecutes el
proyecto te pedirá que elijas el FRAME principal le dices que sea NEWJFRAME como en la siguiente
imagen:
Ahora vamos a crear un DIALOGO que es el otro tipo de ventana que tiene el JAVA, de la misma
forma que hemos creado un FRAME se crea un DIALOGO, como en la siguiente imagen:

Luego hacemos clic en FINISH, ahora para abrir este NEWJDIALOG por medio de nuestro FRAME
de la misma forma que hicimos anteriormente arrastramos un botón en el NEWJFRAME y en su
evento escribimos el siguiente código:

Listo ahora ejecuta tu proyecto y recuerda que el FRAME principal de be ser NEWJFRAME si te sale
la siguiente ventana:

Elige NEWJFRAME, y cuando ejecute veras las diferencias que existen entre una ventana de tipo
DIALOGO y una ventana de tipo FRAME, espero que te haya servido.
Fuente: http://www.mailxmail.com/como-usar-frames-dialogos-java-netbeans_h
Cómo poner fondo a un formulario de Java Netbeans
Bueno si y has usado alguna vez un DELPHI o C++BUILDER o un VISUAL BASIC y UN VISUIAL
C#, y has pensado que poner una imagen de fondo a un formulario de JAVA NETBEANS es tan fácil
como en las otras tecnologías casi te equivocaste, no es para nada igual, es totalmente diferente muy
diferente no es difícil porque una vez que sepas como se hace lo harás muy fácilmente después.
Visita mi web:http://www.wix.com/foxsoftware/estudiosavefenix
Entonces sigue estos pasos, abre tu NETBEANS, haz clic en FILE->NEW PROJECT:

Ahora escoge JAVA y después JAVA APPLICATION como se muestra en la siguiente imagen:

Luego de hacer clic en NEXT te saldrá otra ventana ponle un nombre a tu aplicación en nuestro caso
será APLICACIONCONFONDO y deja las demás opciónes como en la siguiente imagen:

Después de hacer clic en FINSH se creara el siguiente paquete en la parte derecha como en la siguiente
imagen:

Ahora vamos a crear nuestro formulario principal, haciendo clic en FILE después en NEW FILE como
en la siguiente imagen:
Escogemos en categorías escogemos SWING GUI FORMS y tipo de archivo JDIALOG FORM y de
pues hacemos clic en NEXT> como en la siguiente imagen:

Ahora solo le ponemos un nombre en mi caso “Principal” y luego le damos clic en FINISH:

Ahora creamos otro formulario de tipo PANEL para que sea el fondo de nuestro formulario principal.
Y hacemos similar al anterior clic en FILE luego en NUEVO FILE:

Peo esta vez no escogemos JDIALOG FORM si no que JPANEL FORM de SWING GUI FORM como
se muestra en la siguiente imagen:
Luego clic en NEXT y luego le ponemos un nombre en mi caso “Fondo” como en la siguiente imagen:

Luego hacemos clic en FINISH y se creara nuestro formulario y ahora listo vamos a empezar a trabajar
en la configuración de nuestro Fondo, para eso nos ubicamos en nuestro formulario Fondo no en el
formulario principal si no en fondo como muestra en la siguiente imagen:

Le arrastramos un JLabel1 y le ampliamos su tamaño por todo el formulario agarrándole de una


esquina y agrandándole hasta que tape todo el formulario Fondo:

Ahora nos vamos a las propiedades del JLabel1 que está en la parte derecha y borramos su propiedad
TEXT para que no se vea el título JLABEL1 y hacemos clic en la propiedad ICON en su botón buscar
que está representado por un botón de tres puntos suspensivos como se muestra en la figura:
Luego nos saldrá una ventana done tenemos que elegir la imagen de fondo que queremos, como en la
siguiente imagen:

Nosotros hacemos clic en el botón IMPORT TO PROJECT… y escogemos la imagen que queramos de
nuestro ordenador como en la siguiente imagen:

Luego hacemos clic en NEXT y después clic en FINISH:

Luego clic en el botón OK, Y nos aparecerá el formulario llamado Fondo con la imagen de fondo que
le escogimos ahora solo tenemos que importar este formulario Fondo a nuestro formulario Principal y
lo hacemos de la siguiente forma:
Hacemos clic en Principal para entrar en el formulario Principal luego en clic en SOURCE para entrar
en su código:

Luego buscamos las líneas siguientes:

Y escribimos las siguientes líneas de código dentro de las llaves de amarillo que se muestran en la
imagen de arriba:
El código debe quedar así:

Ahora haz clic en el botón PLAY que es un triángulo verde:


Y te pedirá que elijas en formulario principal:

Escoges Principal y listo ya tienes tu fondo pero solo se verá cuando se ejecute tu proyecto, recuerda
que tienes que trabajar pone ido tus botónes y todo lo demás en el formulario Principal y n así en el
formulario Fondo. Para cada formulario que quieres con fondo tienes que crear otro formulario Fondo.
Bueno es muy largo porque en Java de esa forma se pone un fondo, en la práctica es relativamente
corto y sencillo.
Fuente: http://www.mailxmail.com/como-poner-fondo-formulario-java-netbeans_h
¿Cómo ocultar el botón cerrar del JFrame? en NetBeans?
Puedes quitar el marco completo de la ventana con la siguiente propiedad del Jframe
miventana.setUndecorated(true);
Fuente: http://es.answers.yahoo.com/question/index?qid=20110312080706AA40Qqw

Inhabilitar botón cerrar Java en JFrame


Trata el siguiente código, a mi me funciono sin problema alguno, colócalo en la clase principal donde
inicie el código del programa.
setDefaultCloseOperation(0);
ejemplo:
class Programa extends JFrame{
Programa(){
setDefaultCloseOperation(0);
}
}
Fuente: http://www.todoexpertos.com/categorias/tecnologia-e-internet/programacion/java/respuestas/1018742/inhabilitar-
botón-cerrar-java-en-jframeg
JFrame, JDialog y otras ventanas
Cuando queremos hacer ventanitas en java nos encontramos con dos ventanas: El JFrame y el
JDialog. ¿Cuándo se usa una u otra?, ¿Qué diferencias hay entre ellas?.
Los JDialog admiten un padre y pueden ser o no modales. ¿Para qué sirve ese padre? ¿Puedo hacer
cualquier JDialog modal?
Otras veces queremos hacer una ventana de error, de aviso, para pedir un dato o confirmar algo.
¿Pongo JFrame o JDialog para esas ventanas? ¿Tengo que construirla?
Vamos a tratar en este tutorial de echar un vistazo a JFrame y JDialog, así como a JOptionPane y ver
cuándo usamos una u otra. Trataremos de responder a todas estas preguntas.
JFrame y JDialog
Los dos tipos de ventanas principales que tenemos en java son JFrame y JDialog. Hay varias
diferencias entre ellas y en función de estas diferencias vamos a ver para qué sirven
 Si instanciamos un JFrame, en la barra de abajo de windows (creo que se llama "barra de
herramientas") nos aparece un nuevo "botóncito" correspondiente a nuestra aplicación. Si
instanciamos un JDialog, no aparece nada.
 Un JFrame tiene un método setIconImage() para cambiar el icono por defecto de la taza de
café. JDialog no tiene este método.
 Un JDialog admite otra ventana (JFrame o JDialog) como padre en el constructor. JFrame no
admite padres.
 Un JDialog puede ser modal, un JFrame no.
Todo esto nos indica lo siguiente:
 Un JFrame debe ser la ventana principal de nuestra aplicación y sólo debe haber una.
 Las ventanas secundarias de nuestra aplicación deben ser JDialog.
Los motivos de esto son los siguientes.
Al mostrar el JFrame un botón en la barra de herramientas de windows y tener método para cambiar el
icono, es la ventana ideal como ventana principal de nuestra aplicación y sólo debe haber una. Nos
permite cambiar el icono y sólo debe haber un botón en la barra de herramientas de windows para
nuestra aplicación.
Si usamos un JDialog como ventana principal, no tenemos botón en la barra de herramientas y no hay
forma fácil de cambiarle el icono.
Los JDialog son ideales para ventanas secundarias porque admiten una ventana padre. Si la VentanaA
es padre del JDialogB, entonces el JDialogB siempre estará por delante de VentanaA, nunca quedará
por detrás. Lo ideal es que hagamos nuestras ventanas secundarias como JDialog cuyo padre sea el
JFrame principal. De esta forma los JDialog siempre serán visibles por encima del JFrame y no se
irán detrás ni quedarán ocultos por el JFrame.
Otra ventaja de admitir un padre es que heredan el icono de él. Si hemos cambiado el icono del
JFrame con el método setIconImage(), entonces todos los JDialog que hagamos como hijos de este
JFrame heredarán el icono. Todas las ventanas de nuestra aplicación tendrán el mismo icono en lugar
de la taza de café por defecto.
Jerarquía de padres y ventanas modales
Un JDialog puede ser modal, pasándole un true en el constructor en el sitio adecuado o haciéndolo
modal con el método setModal(). Si hacemos un JDialog modal, todas las demás ventanas se
deshabilitarán hasta que el usuario de nuestro programa cierre el JDialog. Esto está estupendo para
pedir un dato al usuario y evitar que toque otras cosas hasta que haya introducido el dato. Sin embargo,
tiene un peligro.
Supongamos un JDialog que lo hacemos modal para pedir unos datos al usuario. Este JDialog tiene un
botón de "Aceptar" para que el usuario lo pulse cuando haya terminado de introducir los datos.
Supongamos que en el código de ese botón "Aceptar" comprobamos los datos que ha metido el usuario
y vemos que son incorrectos. Le sacamos un segundo JDialog modal para indicarle el error y no
cerramos el primero.
¿Quién debe ser el padre de ese segundo JDialog modal?. Si hacemos que el padre sea el JFrame
tendremos dos JDialog modales hijos del JFrame, es decir, dos JDialog modales hermanos. Esto nos
dará problemas, como que ambas ventanas queden deshabilitadas, que al cerrar una de ellas se nos
oculten todas, que parte de la ventana quede deshabilitada mientras que otra parte no, etc.
Entonces, ¿cómo hacemos?. Para que java no haga cosas raras, el padre del segundo JDialog modal
debe ser el primer JDialog modal. De esta forma, el segundo tiene "prioridad" sobre el primero. Todo
queda deshabilitado excepto este segundo JDialog. Cuando lo cerremos, será el primero el que mande.
Resumiendo, si queremos varias ventanas modales simultáneamente en pantalla, cada ventana que se
muestre debe ser padre de la siguiente, de forma que la cadena de ventanas modales sean padre, hijo,
nieto, etc. Tener dos ventanas modales simultaneas que sean hermanas o primas o cualquier otra
relación que no sea directa, nos dará problemas.
JOptionPane
Para hacer ventanas sencillas que avisen de un error al usuario y tengan un botón de "Cerrar", o que le
pidan una confirmación para hacer algo (como borrar un fichero) y tengan dos botónes de "Si" y "No",
o para pedirle que elija una opción entre varias disponibles ... tenemos suerte. No hay que construir la
ventana.
La clase JOptionPane de java tiene métodos showConfirmDialog(), showInputDialog(),
showOptionDialog(), showMessageDialog(). Estos métodos mostarán una ventana modal que pide al
usuario una confirmación, que le pide un dato o le muestra un mensaje. En caso de que el usuario tenga
que elegir algo, el método usado devuelve el valor elegido.
Por ejemplo, para mostrar un aviso de error, nos basta esta simple línea de código
JOptionPane.showMessageDialog(ventanaPadre, "mensaje de error", "título de la ventana",
JOptionPane.ERROR_MESSAGE);
Esto mostrará el mensaje de error y detendrá la ejecución del código hasta que el usuario cierre la
ventana.
Ahora viene el dato importante. Esta ventana es modal y admite un padre. Si ya hay una ventana modal
visible en pantalla, deberías pasar esa ventana como padre de esta para no tener problemas.
JInternalFrame
El JInternalFrame es una ventana especial que ni es ventana ni es nada. De hecho, no hereda de
Window. En realidad es un componente java que se dibuja dentro de otro componente, pero adornado
con la barra de título de una ventana y sus botónes de maximizar, minimizar y cerrar. Puede incluso
arrastrarse y modificarse de tamaño siempre que se mete dentro del componente adecuado.
El sitio bueno para meter los JInternalFrame es el JDesktopPane. Este panel admite
JInternalFrame y sabe manejarlos.
JFrame ventana = new JFrame();
JDesktopPane desktop = new JDesktopPane();
ventana.getContentPane.add(desktop);
JInternalFrame internal = new JInternalFrame();
desktop.add(internal);
En este código el JInternalFrame se comportará como una ventana, pero que no puede salirse del
JDesktop que la contiene.
Resumen
 En nuestra aplicación debe haber un JFrame y sólo uno, que será la ventana principal.
 Todas las ventanas secundarias deben ser JDialog y todos los JDialog deberían tener padre.
 Todos los JDialog modales visibles a la vez en pantalla, deben ser unos hijos de otros en una
cadena "padre-hijo-nieto" directa. No pueden ser "hermanos", ni "primos" ni "sobrinos".
Fuente: http://www.chuidiang.com/java/novatos/JFrame_JDialog.php
Cerrar la ventana JFrame o JDialog al pulsar la tecla ESCAPE
KeyboardFocusManager kb = KeyboardFocusManager.getCurrentKeyboardFocusManager();
kb.addKeyEventPostProcessor(new KeyEventPostProcessor(){
public boolean postProcessKeyEvent(KeyEvent e){
if (e.getKeyCode() == KeyEvent.VK_ESCAPE && this != null){
System.out.println("probando...");
dispose();
return false;
}
return true;
}
});
Fuente: http://foro.chuidiang.com/java-j2se/cerrar-la-ventana-jframe-o-jdialog-al-pulsar-la-tecla-escape/

JAVA desde cero


Clase JFrame
Por herencia la clase JFrame y sus clases descendientes (subclases directas )
pueden utilizar los datos y/o métodos de la superclase Frame, Window,
Container, Component y Object de la librería awt.
La clase JFrame es ligeramente incompatible con la clase Frame. Como todo
otro contenedor de alto nivel de la librería Swing, un JFrame contiene un
JRootPane como su único elemento. El contentPane proporcionado por el
rootPane debería, como una regla, contener todos los componentes que no
sean menú mostrados por el JFrame.
A diferencia del Frame, un JFrame tiene alguna noción de como responder
cuando el usuario intenta cerrar la ventana. El comportamiento por defecto es simplemente ocultar el
JFrame cuando el usuario cierra la ventana. Para cambiar el comportamiento por defecto se debe
invocar al método setDefaultCloseOperation().
I.- JERARQUÍA DE CLASES

II.- MÉTODOS
ATRIBUTOS
static int EXIT_ON_CLOSE La salida por defecto al cerrar una ventana.
CONSTRUCTORES
JFrame() Crea un nuevo frame que es inicialmente visible
JFrame(String título) Crea un nuevo frame con el título indicado como parámetro
MÉTODOS
Tipo de retorno Método Descripción
Container getContentPane() Retorna el objeto contentPane.
Retorna la operación que ocurre cuando el usuario hace la operación
int getDefaultCloseOperation()
de cerrar la ventana del frame
jMenuBar getJMenuBar() Retorna el menúBar establecido en el frame
Remueve el componente indicado como parámetro de éste
Void remove(Component comp)
contenedor
setContentPane(Container
Void Establece la propiedad del contentPane
contentPane)
setDefaultCloseOperation(int Establece la operación que sucederá por defecto cuando el usuario
Void
operation) cierra la ventana
Void setJMenuBar(JMenuBar menu) Establece la barra de menú para el frame
Por defecto, la distribución de los paneles de éste componente no
Void setLayout(LayoutManager layout) debe cambiarse; en su lugar, debería ser cambiada la distribución de
su contentPane que generalmente es un panel.

III.- OTROS MÉTODOS


Para Colocar el nombre en la ventana del JFrame:
1 this.setTitle(“Título del frame”);
Para maximizar la ventana de JFrame
1 this.setExtendedState(this.MAXIMIZED_BOTH);
Para desactivar el botón de cierre del JFrame
1 this.setDefaultCloseOperation(0)
1 this.setDefaultCloseOperation(this.DO_NOTHING_ON_CLOSE);
Para hacer visible al frame
1 this.setVisible(true);
OBSERVACION: Todos estos métodos se deben invocar en el constructor del JFrame; es decir:
public Principal()
{
panAcces = new panAcceso();
admin = new Administrador();
listadoAlu = new ListaAlumnos();
initComponents();
fecha = new Fecha();
//Maximizar la ventana del JFrame
this.setExtendedState(this.MAXIMIZED_BOTH);
//Evita que se cierrre el frame con el botón salir esquivale a
this.setDefaultCloseOperation(0);
this.setDefaultCloseOperation(this.DO_NOTHING_ON_CLOSE);
this.setTitle("SISTEMA INTEGRAL DE NOTAS - SIN");
lblFecha.setText("" + fecha.iniciarComponentes());
try
{
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
}
catch (Exception e)
{
e.printStackTrace();
}
}

IV.- EJEMPLOS
1. Diseñe una aplicación con dos frames, uno de bienvenida y otro de despedida activados a través de
botónes como se muestra a continuación :
Fuente: http://javax0711.blogspot.com/2009/10/clase-jframe.html
Java - deshabilitar maximizar en frame
public Login() {
initComponents();
setSize(400,300);
this.setResizable(false);// esto hara que el frame no se pueda maximizar
}
Fuente: http://www.lawebdelprogramador.com/foros/Java/930097-deshabilitar_maximizar_en_frame.html

Jframe sin el boton de cerrar, maximizar y minimizar


Facil y sencillo
setUndecorated(true);
getRootPane().setWindowDecorationStyle(JRootPane.NONE);
se le pone al frame y listo
Fuente: http://skuarch.blogspot.com/2011/03/jframe-sin-el-botón-de-cerrar-maximizar.html

Limitar caracteres en un JTextfield


Por diversas razones tenemos la necesidad de evitar que un usuario ingrese ya sea números, letras,
ciertos caracteres especiales o más de un número máximo de caracteres.
Para lograr estos objetivos voy a mostrar algunos de ejemplos de clases que implementan algun tipo de
limitación en los datos ingresados.
Primer ejemplo: Limitar el jTextField a solo letras y espacios.
Nombre de la clase: LimitadorSoloLetras.java
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.PlainDocument;

/**
* @author Hernán
*/
public class LimitadorSoloLetras extends PlainDocument{
public void insertString(int arg0, String arg1, AttributeSet arg2) throws
adLocationException
{
for (int i=0;i<arg1.length();i++)
if (!Character.isLetter(arg1.charAt(i)) &&
!Character.isSpaceChar(arg1.charAt(i)))
return;
super.insertString(arg0, arg1, arg2);
}
}
Modo de uso: supongamos que tenemos un JTextField llamado txtNombres, entonces lo que tenemos
que hacer es:
txtNombres.setDocument(new LimitadorSoloLetras());
Segundo Ejemplo: Limitar el jTextField a solo números.
Nombre de la clase: LimitadorSoloNumeros.java
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.PlainDocument;

/**
* @author Hernán
*/
public class LimitadorSoloLetras extends PlainDocument{
public void insertString(int arg0, String arg1, AttributeSet arg2) throws
adLocationException
{
for (int i=0;i<arg1.length();i++)
if (!Character.isLetter(arg1.charAt(i)) &&
Character.isSpaceChar(arg1.charAt(i)))
return;
super.insertString(arg0, arg1, arg2);
}
}
Modo de uso: supongamos que tenemos un JTextField llamado txtNombres, entonces lo que tenemos
que hacer es:
txtDNI.setDocument(new LimitadorSoloNumeros());

Tercer Ejemplo: Limitar el jTextField a solo letras y espacios y además limitar la cantidad de caracteres
ingresados.
Nombre de la clase: LimitadorSoloLetrasNroMax.java
import javax.swing.JTextField;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.PlainDocument;

/**
* @author Hernán
*/
public class LimitadorSoloLetrasNroMax extends PlainDocument{

private JTextField miJTextField;


private int nroMaxCaracteres;
public LimitadorSoloLetrasNroMax(JTextField mijtext, int nroMaxCaract){
miJTextField=mijtext;
nroMaxCaracteres=nroMaxCaract;
}
public void insertString(int arg0, String arg1, AttributeSet arg2) throws
BadLocationException
{
for (int i=0;i<arg1.length();i++)
if ((!Character.isLetter(arg1.charAt(i)) &&
!Character.isSpaceChar(arg1.charAt(i)))||(miJTextField.getText().length()+arg1.leng
th())>nroMaxCaracteres)
return;
super.insertString(arg0, arg1, arg2);
}
}
Modo de uso: supongamos que tenemos un JTextField llamado txtApellidos, entonces lo que tenemos
que hacer es:
txtApellidos.setDocument(new LimitadorSoloLetrasNroMax(txtApellidos,30));
Cuarto Ejemplo (a pedido de trancelex): Limitar el jTextField a solo letras y espacios, y además cuando
se llegue al número maximo pasar al próximo campo.
Nombre de la clase: LimitadorSoloLetrasNroMaxV2.java
import javax.swing.JTextField;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.PlainDocument;

/**
* @author Hernán
*/
public class LimitadorSoloLetrasNroMaxV2 extends PlainDocument{

private JTextField miJTextField;


private int nroMaxCaracteres;
public LimitadorSoloLetrasNroMaxV2(JTextField mijtext, int nroMaxCaract){
miJTextField=mijtext;
nroMaxCaracteres=nroMaxCaract;
}
public void insertString(int arg0, String arg1, AttributeSet arg2) throws
adLocationException{
for (int i=0;i<arg1.length();i++){
if ((miJTextField.getText().length()+arg1.length())>nroMaxCaracteres){
miJTextField.transferFocus();
return;
}else if (!Character.isLetter(arg1.charAt(i)) &&
!Character.isSpaceChar(arg1.charAt(i)))
return;
}
super.insertString(arg0, arg1, arg2);
}
}
Modo de uso: supongamos que tenemos un JTextField llamado txtApellidos, entonces lo que tenemos
que hacer es:
txtApellidos.setDocument(new LimitadorSoloLetrasNroMaxV2(txtApellidos,30));

Fuente: http://www.divideandconquer.com.ar/2008/10/limitar-caracteres-en-un-jtextfield/

¿Maneras de conectar netbeans con postgreSQL?


La unica manera que conozco de conectar netbeans(java) con postgreSQl es de los siguientes modos:
Modo 1
public static java.sql.Connection conexion;

[...]

URL_bd = "jdbc:postgresql://192.168.0.252:5432/obras";
usuario = "user";
contrasinal = "password";

Class.forName("org.postgresql.Driver").newInstance();
Properties props = new Properties();
props.setProperty("user", usuario);
props.setProperty("password", contrasinal);
//2 opciónes: que vienen siendo lo mismo
1. conexion = DriverManager.getConnection(URL_bd, props);
2. conexion = DriverManager.getConnection(URL_bd, usuario, contrasinal);

Modo 2
public static java.sql.Connection conexion;

[...]

if (pool == null) {
pool = new Jdbc3PoolingDataSource();
pool.setPortNumber(5432);
pool.setUser("usuario");
pool.setPassword("password");
pool.setMaxConnections(100);
pool.setServerName("192.162.0.252");
pool.setDatabaseName("obras");
}

conexion = pool.getConnection();
pool.setLogWriter(new java.io.PrintWriter(System.out));
//Commit a true
conexion.setAutoCommit(true);
Fuente: http://www.forosdelweb.com/f45/maneras-conectar-netbeans-con-postgresql-825340/

Cambiando el icono de los JFrame


Esta es una forma rápida y sencilla de cambiar el icono de los JFrame que viene por defecto
desarrollando aplicaciones Java, con algo de código. Solo hay que tener en cuenta la ruta del archivo de
imagen.
this.setIconImage (new ImageIcon(getClass().getResource(”ruta_imagen/imagen.gif”)).getImage());
En mi caso yo cree un paquete el cual contiene mis imagenes que deseo tener en mi aplicacion,
supongamos que el paquete se llame “mipaquete.imagenes”, entonces la ruta seria asi:
this.setIconImage (new ImageIcon(getClass().getResource(”/mipaquete/imagenes/imagen.gif”)).getImage());
Espero les sirva =).
Fuente: http://nachxs.blogsome.com/2007/10/25/cambiando-el-icono-de-los-jframe/

Java – AWT/Swing – Cambiar el icono de una ventana


Al trabajar con ventanas en Java, notaremos que estas llevan por defecto el icono con el símbolo de
Java el cual es una taza de café.

No es fea la taza de café, pero en un JFrame podemos cambiarlo a nuestro gusto, y aunque no podemos
hacer lo mismo en un JDialog este heredara el icono de su ventana padre. Incluso podríamos cambiar el
icono que usa Java por defecto para sus aplicaciones, aunque claro que seria algo drástico.
Cambiando el icono en nuestro JFrame
Para personalizar nuestro icono en un JFrame utilizaremos el método void setIconImage(Image image),
veamos un simple ejemplo:
package programa;

import java.awt.Image;
import javax.swing.ImageIcon;
import javax.swing.JFrame;

class WindowDemo extends JFrame {

public WindowDemo() {
super("Ventana personalizada");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Image icon = new
ImageIcon(getClass().getResource("/programa/imagenes/love.png")).getImage();
setIconImage(icon);
setSize(350, 350);
setLocationRelativeTo(null);
setVisible(true);
}
public static void main(String[] args) {
new WindowDemo();
}
}
Como se puede ver tengo una clase en el paquete programa y tengo una imagen llamada love con
extensión .PNG en el paquete programa.imagenes.
En el código que hemos visto prestemos atención sobre:
Image icon = new ImageIcon(getClass().getResource("/programa/imagenes/love.png")).getImage();
setIconImage(icon);
Al método void setIconImage() hay que pasarle nuestra imagen como argumento, utilizamos new
ImageIcon(URL location).getImage() donde el argumento location lo obtenemos a través del método
getClass().getResource(String name) que nos devuelve un URL absoluto del recurso que especificamos
como String. Los tipos de archivo que podemos utilizar son GIF, JPEG yPNG (este último desde J2SE
1.3) pero no pueden ser ICO o BMP. En caso de utilizar un tipo de archivo no valido el icono
predeterminado simplemente no cambiara y seguiremos viendo la taza de café, y en caso de que el
archivo no se encontrase el método retornaría null y la JVM nos arrojaría una NullPointerException.
Tanto JDialogs como JInternalFrames que tengan este JFrame como padre llevarían el mismo icono.
Veamos como queda ahora nuestra ventana:

Y como alternativa al código anterior tenemos otra forma muy similar de lograr el mismo resultado:
Image icon = Toolkit.getDefaultToolkit().getImage(getClass().getResource("/programa/imagenes/love.png"));
setIconImage(icon);
Desde un editor visual
Trabajando con editores visuales las cosas pueden ser diferentes, sin duda el caso mas especial es el
editor visual de NetBeans que veremos a continuación.
NetBeans –
En el caso que estemos trabajando con el editor visual de NetBeans (Matisse) no podemos modificar
manualmente el código generado, así que seleccionamos el JFrame en la pestaña “Inspector” y luego en
la pestaña de propiedades (“JFrame – Properties“) buscamos la propiedad “iconImage” seleccionando
donde se ve a continuación:

Se nos abrirá una ventana con nuevas opciónes en la cual seleccionamos “Custom Code” y como
veremos tenemos un campo de texto donde podremos escribir nuestro código para aplicar el método
void setImageIcon(). Siguiendo con mi ejemplo donde tengo el archivo de imagen love.png en el
paquete programa.imagenes el código a introducir sería:
new ImageIcon(getClass().getResource("/programa/imagenes/love.png")).getImage()
Al presionar “Ok” el editor visual introducirá nuestro código donde debe.
Fuente: http://darkbyteblog.wordpress.com/2011/01/14/java-awtswing-cambiar-el-icono-de-una-ventana/

Obtener tamaño/dimensión de la pantalla en Java


Para obtener el "tamaño" de la pantalla, asi como otros atributos como la "resolucion" en java, se hace
uso de la clase abstracta Toolkit.Esta clase nos otorga los metodos getScreenSize() que retona las
dimensiones de pantalla en pixeles y getScreenResolution(), que retorna un valor en PPP (puntos por
pulgada).
import java.awt.Dimension;
import java.awt.Toolkit;
/**
* @web http://jc-mouse.blogspot.com/
* @author Mouse
*/
public class Main {

public static void main(String[] args) {


// TODO code application logic here
//Obtiene el tamaño de la pantalla
Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
//obtiene la resolucion de la pantalla en PPP (Puntos por pulgada)
int sr = Toolkit.getDefaultToolkit().getScreenResolution();
//muestra la informacion por la consola de java
System.out.println("Tamaño de pantalla: " + d.width + "x" + d.height + ",
definición: " + sr + " ppp");
}
}
Fuente: http://jc-mouse.blogspot.com/2010/02/obtener-tamanodimension-de-la-pantalla.html

Convertir números a letras en java (Tipo Factura, cheque, recibo)


Cuando se realizan trabajos donde se necesita mostrar al cliente un determinado monto de dinero, tipo
factura, recibo, cheque, etc, el cliente desea ver el monto en numeral asi como en literal.
Por ejemplo:
877866,50 = ochocientos setenta y siete mil ochocientos sesenta y seis 50/100 Bolivianos

Pues bien, la siguiente clase a la que llame Numero_a_Letra.java realiza justamente esa operacion,
esta extracomentada y trate de hacerla lo mas entendible posible.
La logica que se utliza es la siguiente:
La clase recibe un numero ej. 123456789,50 valida este numero, si el numero no es valido devuelve
NULL
Si el numero es valido segun sea este unidad, decena, centena, mil o millon, va clasificando el numero
y llama a sus procedimientos correspondientes, estas funciones, son utilizadas en cascada, osea: nuestro
numero de ejemplo es 123456789,50, entonces separa en 123456789 y 50, siendo 50 nuestra parte
decimal.
El numero entero, 123456789 es clasificado = es millon, entonces llama a la funcion getMillones, esta
funcion a la vez divide el numero en miles y millones 123456789 = 123 456789 donde 123
corresponde a millones y 456789 a miles entonces la misma funcion llama a las funciones getMiles,
getCentenas, getUnidades, segun corresponda, al igual que la funcion getMiles, hace uso de
getCentenas, getDecenas getUnidades, lo mismo getCentenas, hace uso de getDececas, getUnidades.
Espero se entienda :)
import java.util.regex.Pattern;
/**
* @web http://jc-mouse.blogspot.com/
* @author Mouse
*/
public class Numero_a_Letra {

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 Numero_a_Letra() {
}

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] + "/100 Bolivianos.";
//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);
}
}
Esta clase, recibe un numero de 0,00 a 999999999.00 en formato String, el separador decimal puede ser
un punto (.) o una coma (,), ademas tiene un parametro booleano "mayusculas" el cual sea verdadero
(true) o falso (false), retorna el resultado en mayusculas o minusculas, esta clase no acepta numeros
negativos ni tampoco numero mayores o iguales a mil millones, aunque claro trate de escribir esta clase
para que sea facilmente comprensible y asi pueda ser ampliado o modificado segun sus necesidades.
La forma de llamara a esta clase es:
Numero_a_Letra NumLetra = new Numero_a_Letra();
String numero = "20004.70";
System.out.println( numero + " literal = " + NumLetra.Convertir(numero,true));
y probando para un rango mayor de numeros tenemos como resultado:
352822,50 literal = TRECIENTOS CINCUENTA Y DOS MIL OCHOCIENTOS VEINTE Y DOS 50/100
BOLIVIANOS.
370,50 literal = trecientos setenta 50/100 Bolivianos.
74883,50 literal = SETENTA Y CUATRO MIL OCHOCIENTOS OCHENTA Y TRES 50/100
BOLIVIANOS.
354801,50 literal = trecientos cincuenta y cuatro mil ochocientos un 50/100
Bolivianos.
12,50 literal = DOCE 50/100 BOLIVIANOS.
511812060,50 literal = QUINIENTOS ONCE MILLONES OCHOCIENTOS DOCE MIL SESENTA
50/100 BOLIVIANOS.
285364,50 literal = doscientos ochenta y cinco mil trecientos sesenta y cuatro
50/100 Bolivianos.
97,50 literal = NOVENTA Y SIETE 50/100 BOLIVIANOS.
882,50 literal = OCHOCIENTOS OCHENTA Y DOS 50/100 BOLIVIANOS.
28,50 literal = VEINTE Y OCHO 50/100 BOLIVIANOS.
395362869,50 literal = TRECIENTOS NOVENTA Y CINCO MILLONES TRECIENTOS SESENTA Y
DOS MIL OCHOCIENTOS SESENTA Y NUEVE 50/100 BOLIVIANOS.
687611,50 literal = SEISCIENTOS OCHENTA Y SIETE MIL SEISCIENTOS ONCE 50/100
BOLIVIANOS.
46,50 literal = CUARENTA Y SEIS 50/100 BOLIVIANOS.
394625,50 literal = trecientos noventa y cuatro mil seiscientos veinte y cinco
50/100 Bolivianos.
686671871,50 literal = seiscientos ochenta y seis millones seiscientos setenta y
un mil ochocientos setenta y un 50/100 Bolivianos.
860233047,50 literal = OCHOCIENTOS SESENTA MILLONES DOSCIENTOS TREINTA Y TRES MIL
CUARENTA Y SIETE 50/100 BOLIVIANOS.
656477159,50 literal = SEISCIENTOS CINCUENTA Y SEIS MILLONES CUATROCIENTOS SETENTA
Y SIETE MIL CIENTO CINCUENTA Y NUEVE 50/100 BOLIVIANOS.
99037,50 literal = NOVENTA Y NUEVE MIL TREINTA Y SIETE 50/100 BOLIVIANOS.
159180,50 literal = ciento cincuenta y nueve mil ciento ochenta 50/100 Bolivianos.
69993,50 literal = SESENTA Y NUEVE MIL NOVECIENTOS NOVENTA Y TRES 50/100
BOLIVIANOS.
76,50 literal = setenta y seis 50/100 Bolivianos.
74,50 literal = setenta y cuatro 50/100 Bolivianos.
4,50 literal = cuatro 50/100 Bolivianos.
572356,50 literal = QUINIENTOS SETENTA Y DOS MIL TRECIENTOS CINCUENTA Y SEIS
50/100 BOLIVIANOS.
85,50 literal = OCHENTA Y CINCO 50/100 BOLIVIANOS.
678977004,50 literal = seiscientos setenta y ocho millones novecientos setenta y
siete mil cuatro 50/100 Bolivianos.
311275,50 literal = TRECIENTOS ONCE MIL DOSCIENTOS SETENTA Y CINCO 50/100
BOLIVIANOS.
888,50 literal = OCHOCIENTOS OCHENTA Y OCHO 50/100 BOLIVIANOS.
861740125,50 literal = OCHOCIENTOS SESENTA Y UN MILLONES SETECIENTOS CUARENTA MIL
CIENTO VEINTE Y CINCO 50/100 BOLIVIANOS.
370246,50 literal = trecientos setenta mil doscientos cuarenta y seis 50/100
Bolivianos.
986444,50 literal = novecientos ochenta y seis mil cuatrocientos cuarenta y cuatro
50/100 Bolivianos.
202,50 literal = DOSCIENTOS DOS 50/100 BOLIVIANOS.
407295,50 literal = CUATROCIENTOS SIETE MIL DOSCIENTOS NOVENTA Y CINCO 50/100
BOLIVIANOS.
522,50 literal = QUINIENTOS VEINTE Y DOS 50/100 BOLIVIANOS.
378878653,50 literal = TRECIENTOS SETENTA Y OCHO MILLONES OCHOCIENTOS SETENTA Y
OCHO MIL SEISCIENTOS CINCUENTA Y TRES 50/100 BOLIVIANOS.
712142,50 literal = SETECIENTOS DOCE MIL CIENTO CUARENTA Y DOS 50/100 BOLIVIANOS.
588737075,50 literal = QUINIENTOS OCHENTA Y OCHO MILLONES SETECIENTOS TREINTA Y
SIETE MIL SETENTA Y CINCO 50/100 BOLIVIANOS.
946540,50 literal = novecientos cuarenta y seis mil quinientos cuarenta 50/100
Bolivianos.
34667457,50 literal = treinta y cuatro millones seiscientos sesenta y siete mil
cuatrocientos cincuenta y siete 50/100 Bolivianos.
391874,50 literal = trecientos noventa y un mil ochocientos setenta y cuatro
50/100 Bolivianos.
745,50 literal = SETECIENTOS CUARENTA Y CINCO 50/100 BOLIVIANOS.
670024,50 literal = seiscientos setenta mil veinte y cuatro 50/100 Bolivianos.
703029,50 literal = setecientos tres mil veinte y nueve 50/100 Bolivianos.
745,50 literal = setecientos cuarenta y cinco 50/100 Bolivianos.
975415558,50 literal = NOVECIENTOS SETENTA Y CINCO MILLONES CUATROCIENTOS QUINCE
MIL QUINIENTOS CINCUENTA Y OCHO 50/100 BOLIVIANOS.
294,50 literal = DOSCIENTOS NOVENTA Y CUATRO 50/100 BOLIVIANOS.
559794,50 literal = quinientos cincuenta y nueve mil setecientos noventa y cuatro
50/100 Bolivianos.
23,50 literal = veinte y tres 50/100 Bolivianos.
586335,50 literal = QUINIENTOS OCHENTA Y SEIS MIL TRECIENTOS TREINTA Y CINCO
50/100 BOLIVIANOS.
14174901,50 literal = catorce millones ciento setenta y cuatro mil novecientos un
50/100 Bolivianos.
529551002,50 literal = quinientos veinte y nueve millones quinientos cincuenta y
un mil dos 50/100 Bolivianos.
930,50 literal = NOVECIENTOS TREINTA 50/100 BOLIVIANOS.
581617,50 literal = quinientos ochenta y un mil seiscientos diecisiete 50/100
Bolivianos.
44,50 literal = CUARENTA Y CUATRO 50/100 BOLIVIANOS.
727302804,50 literal = SETECIENTOS VEINTE Y SIETE MILLONES TRECIENTOS DOS MIL
OCHOCIENTOS CUATRO 50/100 BOLIVIANOS.
66,50 literal = SESENTA Y SEIS 50/100 BOLIVIANOS.
34618398,50 literal = TREINTA Y CUATRO MILLONES SEISCIENTOS DIECIOCHO MIL
TRECIENTOS NOVENTA Y OCHO 50/100 BOLIVIANOS.
477354079,50 literal = CUATROCIENTOS SETENTA Y SIETE MILLONES TRECIENTOS CINCUENTA
Y CUATRO MIL SETENTA Y NUEVE 50/100 BOLIVIANOS.
813,50 literal = OCHOCIENTOS TRECE 50/100 BOLIVIANOS.
634888270,50 literal = SEISCIENTOS TREINTA Y CUATRO MILLONES OCHOCIENTOS OCHENTA Y
OCHO MIL DOSCIENTOS SETENTA 50/100 BOLIVIANOS.
219544,50 literal = DOSCIENTOS DIECINUEVEMIL QUINIENTOS CUARENTA Y CUATRO 50/100
BOLIVIANOS.
51,50 literal = cincuenta y un 50/100 Bolivianos.
435640,50 literal = CUATROCIENTOS TREINTA Y CINCO MIL SEISCIENTOS CUARENTA 50/100
BOLIVIANOS.
557896,50 literal = quinientos cincuenta y siete mil ochocientos noventa y seis
50/100 Bolivianos.
36,50 literal = TREINTA Y SEIS 50/100 BOLIVIANOS.
710,50 literal = SETECIENTOS DIEZ 50/100 BOLIVIANOS.
850,50 literal = OCHOCIENTOS CINCUENTA 50/100 BOLIVIANOS.
230498844,50 literal = doscientos treinta millones cuatrocientos noventa y ocho
mil ochocientos cuarenta y cuatro 50/100 Bolivianos.
104296,50 literal = ciento cuatro mil doscientos noventa y seis 50/100 Bolivianos.
1,50 literal = UN 50/100 BOLIVIANOS.
-0100100,70 literal = null
003,70 literal = tres 70/100 Bolivianos.
28,745 literal = null
0,5 literal = CERO 5/100 BOLIVIANOS.
999999999 literal = NOVECIENTOS NOVENTA Y NUEVE MILLONES NOVECIENTOS NOVENTA Y
NUEVE MIL NOVECIENTOS NOVENTA Y NUEVE 00/100 BOLIVIANOS.
9999999999 literal = null
48803770 literal = cuarenta y ocho millones ochocientos tres mil setecientos
setenta 00/100 Bolivianos.
20004.70 literal = VEINTE MIL CUATRO 70/100 BOLIVIANOS.
Fuente: http://jc-mouse.blogspot.com/2011/04/convertir-numeros-letras-en-java-tipo.html

Datos en un jtexfield
Mayúsculas y minúsculas en jtextfield
-Para mayusculas
private void txtNombreTipoMantenimientoKeyReleased(java.awt.event.KeyEvent evt) {
txtNombreTipoMantenimiento.setText(txtNombreTipoMantenimiento.getText().toUpperCase
());
}
Para minusculas
private void txtNombreTipoMantenimientoKeyReleased(java.awt.event.KeyEvent evt) {
txtNombreTipoMantenimiento.setText(txtNombreTipoMantenimiento.getText().toLowerCase
());
}

No permitir números
private void txtNombreCargoKeyTyped(java.awt.event.KeyEvent evt) {
// lee la tecla presionada
int k=(int)evt.getKeyChar();
// chequea en ASCII si esta entre los numeros de las teclas q son numeros
if (k > 47 && k < 58) {
evt.setKeyChar((char)KeyEvent.VK_CLEAR);
JOptionPane.showMessageDialog(null,"No puede ingresar numeros!!!","Ventana
Error Datos",JOptionPane.ERROR_MESSAGE);
}
// si la tecla presionada es enter transfiere el foco
if(k==10){
txtNombreCargo.transferFocus();
}
}
Fuente: http://www.forosdelweb.com/f45/auxilio-extraer-datos-jtable-jtextfield-624066/
jtextField solo numerico
Bueno aqui te dejo un ejmplo lo debes poner en el Evento KeyTyped del jtextfield
private void txtCompraKeyTyped(java.awt.event.KeyEvent evt) {
int k=(int)evt.getKeyChar();
if (k >= 97 && k <= 122 || k>=65 && k<=90){
evt.setKeyChar((char)KeyEvent.VK_CLEAR);
JOptionPane.showMessageDialog(null,"No puede ingresar letras!!!","Ventana Error
Datos",JOptionPane.ERROR_MESSAGE);
}
if(k==241 || k==209){
evt.setKeyChar((char)KeyEvent.VK_CLEAR);
JOptionPane.showMessageDialog(null,"No puede ingresar letras!!!","Ventana Error
Datos",JOptionPane.ERROR_MESSAGE);
}
if(k==10){
txtCompra.transferFocus();
}
}
Hola Mas vale tarde que nunca aqui hay otro ejemplo que en mi programa funciona al 100%
JTextFieldtf1 = new JTextField(); //tambien funciona con JFormattedTextField();
//codigo para limitar a que solo introdusca Números
tf1.addKeyListener(new KeyAdapter() {
public void keyTyped(KeyEvent e) {
char c = e.getKeyChar();
if (!(Character.isDigit(c) ||
(c == KeyEvent.VK_BACK_SPACE) ||
(c == KeyEvent.VK_DELETE))) {
getToolkit().beep();
e.consume();
}
}
});
Fuente: http://www.forosdelweb.com/f45/jtextfield-solo-numerico-575289/

pasar de un jtextfield a otro pulsando enter


import javax.swing.*;
import java.awt.event.*;

public class Ejemplo extends JFrame implements ActionListener{


public JPane panel;
public JTextField campo1;
public JTextField campo2;

public Ejemplo(){
panel = new JPanel(new FlowLayout());
campo1 = new JTextField(30);
campo2 = new JTextField(30);

campo1.addActionListener(this);

panel.add(campo1);
panel.add(campo2);
this.getContentPane.add(panel);
}

public void actionPerformed(ActionEvent e){


if(e.getSource() == campo1){
campo2.setText(campo1.getText);
campo1.setText("");
}
}

public static void main(String args[]){


Ejemplo ventana = new Ejemplo();
ventana.setVisible(true);
}
}
Fuente: http://ar.answers.yahoo.com/question/index?qid=20080727232857AA8uvog
Evento keypress
private void jTextField1KeyReleased(java.awt.event.KeyEvent evt) {
// TODO: Agrege su codigo aqui:
if (evt.getKeyCode() == evt.VK_ENTER){
//lo q debe hacer cuando presione y suelte la tecla enter
}
}
Fuente: http://forodejava.com/showthread.php/960-Evento-keypress

Validación de formularios en Java


CódiLa validación de formularios nos permite asegurarnos que los datos que, por ejemplo, un usuario
ingrese en un campo de texto sean válidos. Dicha validación puede hacerse una vez que el usuario
haya digitado todos los datos, o mientras el usuario los esté digitando.
Para el primer caso, lo mejor es utilizar expresiones regulares usando el método matches() de la clase
String (si necesitas un ejemplo, clic aquí).
Para el segundo caso tendremos que manejar los eventos del teclado que se generen sobre determinado
control, usando la interfaz KeyAdapter y el método keyReleased. Así, en nuestro código de ejemplo
tenemos un JTextField al que le añadimos un Listener que escuchará los eventos del teclado, y
verificará si la tecla presionada es un caractér válido (solo letras), de lo contrario lo elimina.
No hay nada especial en el código de ejemplo salvo por un par de líneas:
 Línea 17: se utiliza el método anidado getToolkit().beep(), que hará que el sistema alerte al
usuario con un pitido cada vez que un dato erróneo.
 Línea 25: comparamos el char que digite el usuario con el entero 8, que es el código resultado
al usar el Backspace (tecla para borrar hacia la izquierda); lo cual permite al usuario borrar
caracteres.
Código…
import java.awt.Robot;
import javax.swing.*;
import java.awt.event.*;
public class SoloLetras extends JFrame {
private JTextField caja = new JTextField();
public SoloLetras() {
super("Solo dejo escribir letras");
caja.addKeyListener(new KeyAdapter() {
public void keyReleased(KeyEvent e) {
Character caracter = new Character(e.getKeyChar());
if (!esValido(caracter)) {
String texto = "";
for (int i = 0; i < caja.getText().length(); i++)
if (esValido(new Character(caja.getText().charAt(i))))
texto += caja.getText().charAt(i);
caja.setText(texto);
getToolkit().beep();
}
}
public boolean esValido(Character caracter)
{
char c = caracter.charValue();
if ( !(Character.isLetter(c) //si es letra
|| c == ' ' //o un espacio
|| c == 8 //o backspace
))
return false;
else
return true;
}
});
getContentPane().add(caja);
setSize(300, 60);
setVisible(true);
}
public static void main(String args[]) {
JFrame.setDefaultLookAndFeelDecorated(true);
SoloLetras ventana = new SoloLetras();
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
Fuente: http://casidiablo.net/validacion-de-formularios-en-java/

Validacion de Campos vacios Usando Objetc


Buenas de nuevo amigos, en esta ocacion eh estado creando unos metodos con los cuales quiero validar
si los campos de tipo Jtexfield estan vacios y el codigo es el siguiente.
public void validarJtexfield(Object[] entrada) {
for (int i = 0; i < entrada.length; i++) {
if (entrada[i] instanceof JTextField) {
if (entrada[i].toString().isEmpty()) {
JOptionPane.showMessageDialog(null, "Hay campos vacios");
}else {
JOptionPane.showMessageDialog(null, "Correcto");
}
}
}

}
/*Metodo para validar los Jtexfield existentes*/
public void validarCampos() {
/*En este caso tengo dos Jtexfield en mi Jframe los cuales deseo validar*/
validarJtexfield(jTextField1,jTextField2);
}
Fuente: http://www.javamexico.org/foros/java_standard_edition/validacion_de_campos_vacios_usando_objetc

Transformando String a Date – uso de SimpleDateFormat


En uno de los post, se planteo la pregunta ¿cómo puedo transformar un String a Date? Para hacer más
interesante el asunto el valor de la variable String estaba en el siguiente formato año-mes-día. En
código se vería algo así:
String strFecha “2007-12-25″;
Con anterioridad conocía la existencia de la clase SimpleDateFormat, que hasta ahora la utilicé para
“formatear” la salida de un objeto tipo Date. Cuando se imprime en consola un objeto Date se obtiene:
Wed Nov 21 12:27:55 COT 2007, pero mi salida debe ser algo así: 21/11/2007. En código sería así:
Calendar calendario = GregorianCalendar.getInstance();
Date fecha = calendario.getTime();
System.out.println(fecha);
SimpleDateFormat formatoDeFecha = new SimpleDateFormat(“dd/MM/yyyy”);
System.out.println(formatoDeFecha.format(fecha));
El primer System.out.println imprime Wed Nov 21 12:27:55 COT 2007, mientras que el segundo
imprime la fecha de acuerdo al formato día/mes/año (21/11/2007) que se especifica como parámetro
del constructor de la clase SimpleDateFormat.
Pero la clase SimpleDateFormat no solamente me permite “formatear” objetos tipo Date, sino que me
permite crear objetos Date a partir de un String que se encuentra en un formato determinado. Es así
cómo se puede hacer.
1. Creamos un objeto SimpleDateFormat y el parámetro del constructor será el formato en el que
se encuentra la variable tipo String.
2. Crear un objeto tipo date, en donde se almacenará la fecha.
3. Utilizar el método parse de la clase SimpleDateFormat, tener en cuenta que puede lanzar
excepciónes.
En código:
SimpleDateFormat formatoDelTexto = new SimpleDateFormat(“yyyy-MM-dd”);
String strFecha = “2007-12-25″;
Date fecha = null;
try {
fecha = formatoDelTexto.parse(strFecha);
}catch (ParseException ex) {
ex.printStackTrace();
}
System.out.println(fecha.toString());
Una nota sobre los formatos: si utilizamos una m minúscula estamos diciendo minutos, si utilizamos M
mayúscula decimos meses. Aquí pueden encontrar mayores detalles
Fuente: http://cafelojano.wordpress.com/2007/11/21/transformando-string-a-date-uso-de-simpledateformat/

Operadores aritméticos, lectura, conversión y escritura Java - Netbeans.


Objetivo:
Utilizar los conceptos de variable y tipo, ámbito de la variable, leer datos de la GUI, mostrar datos en la
GUI del lenguaje seleccionado.
Al finalizar la clase los estudiantes estarán en capacidad de:
Definir las operaciones elementales que ofrece el lenguaje seleccionado.
Realizar ejercicios de programación en el lenguaje seleccionado.
Crear programas simples usando lectura y escritura de datos y las operaciones básicas en el lenguaje
seleccionado.
Trabajando con JAVA.
Importante tener presente la bibliografía dada.
La estructura clave de un programa en
JAVA
La parte 1: es la exterior, en esta solo
pueden haber dos tipos de elementos,
primero el paquete que aparece con la
palabra package nombre; en este ejemplo
no lo colocamos pues no debe usarse a la
ligera.
El segundo tipo de elemento que puede
aparecer es la importación que se logra con
la palabra import seguida de lo que se desea importar y terminando con punto y coma
package nombrepaquete;
import java.io.*;
import javax.swing.*;
import ....
La parte 2: Ésta es la macro estructura que se denomina clase, todo debe estar dentro de la clase pero
en partes específicas. la clase esta determinada así:
public class NombreAlgoritmo{
aquí adentro va todo el programa dividido en partes específicas.
}
El bloque que forma a la clase esta determinado por las llaves {}desde donde abren significa que inicia
y donde cierran significa que termina. Importante que el nombre NombreAlgoritmo sea el mismo del
archivo .java es decir del código fuente.
Todo el programa debe estar contenido dentro de la estructura que denominamos clase.
La parte 3: Este es un subprograma, cada subprograma tiene una estructura especial la cual
estudiaremos con más detalle en los próximos cursos.
El bloque esta delimitado por las llaves que abren y las llaves que cierran dentro de este se colocan las
instrucciones que conforman el programa.

Las variables y su ámbito


Los tipos de las variables:
Java maneja dos grandes tipos que son, los primitivos y los extendidos.
Los primitivos son:
short: entero muy corto (2 bytes -32768 a 32767)
int: entero corto (4 Bytes -2147483648 a 2147483647)
long: entero largo (8 Bytes -9223372036854775808 a 9223372036854775807)
float: decimal corto (4 Bytes 1.40129846432481707 e-45 a 3.40282346638528860e+38) (positivo o
negativo)
double: decimal largo (8 bytes 4.94065645841246544e-324 a 1.79769313486231570e+308) (positivo
o negativo)
char: un carácter incluido los extendidos (2 bytes 0 to 65535)
byte: esta en el rango (-128 a 127)
boolean: valor lógico true-false (Corresponde a un bit)
Los extendidos:
Los tipos de datos extendidos son infinitos, dado que cualquier usuario puede definir el propio según la
orientación a objetos. Los más usados para el curso pueden ser.
String: para el manejo de cadenas de texto.
Double: para la conversión de tipos double
Integer: para la conversión de tipos int
Short: para conversión de tipos short
Long: para la conversión de tipos long
Float: para la conversión de tipos float.
Definir una variable Global
Estas variables se debe colocar dentro de la clase y fuera de cualquier método.
forma general tipo nombre = valorInicial;
tipo: es cualquiera de los antes mencionados.
nombre: debe ser alfanumérico, puede contender letras y números siempre debe iniciar con una letra y
nunca debe contener espacios en blanco o caracteres especiales como /(%$#=+-?......
Ejemplos
String nombre="";
double salario=0;
int edad=0;
Definir una variable local
Lo que diferencia a esta de las demás es el lugar en donde se colocan. Toda variable local debe
colocarse dentro de un método y fuera de cualquier bloque que se defina dentro de este.

Las variables globales: son accesibles desde cualquier parte de la clase y por tanto por cualquier
método que este contenido en esta, la imagen nos muestra las variables Globales en el bloque
numerado con 1 y 3. Dado que la parte en la cual fueron definidas es la clase y fuera de cualquier
método. La palabra static significa que la variable pertenece a la clase y no a las instancias de la misma
aunque esta es teoría orientada a objetos aplica para un mejor entendimiento.
Las variables locales: son accesibles solo para el método en el cual han sido definidas en este caso las
encerradas en el bloque 2.
Dos variables de ámbitos distintos pueden llamarse igual, esto no se aconseja dado que hace necesario
ingresar un elemento que se denomina resolución de ambigüedad this, con fines prácticos evitaremos
que esto suceda.
Las variables de bloque: son las que se definen dentro de los bloques como el si el mientras y otros
que más adelante trabajaremos en el curso.
Las formas de conversión de textos a numéricos son las siguientes:
Integer.parseInt(texto); //convierte el texto dado a entero
Long.parseLong(texto);//convierte el texto dado a un entero
Double.parseDouble(texto);//convierte el texto dado a decimal
5. Operadores aritméticos de java.
Asignación ............................................................... =
Suma......................................................................... +
Resta ......................................................................... -
Multiplicación .......................................................... *
División .................................................................... /
Modulo ..................................................................... %
Potenciación ............................................................. Math.pow(base,exponente)
Raiz cuadrada ........................................................... Math.sqrt(radicando)
Incremento de uno .................................................... ++
Decremento de uno .................................................. ---
6. Operadores relacionales que aplica solo para los números no para los textos
mayor que ................................................................. >
menor que ................................................................. <
mayor o igual que ..................................................... >=
menor o igual que ..................................................... <=
igual que ................................................................... ==
diferente que ............................................................. !=
7. Operadores lógicos
AND ......................................................................... &&
OR ............................................................................ ||
NOT ......................................................................... !
Los algoritmos de tres pasos usando Java-Netbeans
Paso 1 Leer los datos
Paso 2 Realizar los procesos Algoritmo
Paso 3 Imprimir o mostrar los resultados.
Para leer los datos ingresados por el usuario.
Obtendremos los datos inicialmente de tres posibles elementos que son: campos de texto textField, las
areas de texto textArea, ventana de captura JOptionPane. Todos los elementos mencionados retornan lo
capturado del usuario en el formato texto motivo por el cual se hace necesario convertirlo a numérico
en los casos en que sea necesario.
1. Recolectando los datos de una campo de texto.
nombreCampo.getText(); esta es la forma general de capturar un texto que el usuario a ingresado en
el campo de texto.
Ejemplo el campo de texto se llama nombre
String nom=nombre.getText(); //Lo que se encuentre escrito en el campo de texto lo recupera y lo
almacena en la variable.
2. Recolectando los datos de un área de texto.
nombreAreaTexto.getText(); es decir igual que como lo hicimos en el caso del campo de texto.
Ejemplo el área de texto se llama info
String dat=info.getText();
3. Recolectar los datos desde una ventana de captura.
JOptionPane.showInputDialog("Texto que ilustra al usuario sobre lo que se le pide");
Ejemplo
String apellido=JOptionPane.showInputDialog("Ingrese su apellido");
Para procesar los datos.
En estos algoritmos de tres pasos, necesitamos mucho la conversión de tipos a los valores numéricos y
textos al igual que los operadores aritméticos elementales.
Convertir los datos y ejemplos.
Forma general
Double.parseDouble( texto); // convierte un texto al tipo numérico double
Integer.parseInt( texto ); // convierte un texto al tipo numérico entero
Long.parseLong( texto ); // convierte un texto al tipo numérico entero de mayor capacidad
Float.parseFloat ( texto); // convierte un texto al tipo numérico decimal corto
texto se refiere a una de varias cosas que pueden ser (literal, variable, expresión o función) todas de
tipo String.
Ejemplos para la captura de datos y su conversión a número.
1. Si se desea leer un entero capturado de una caja de texto o de una área de texto a la cual
llamaremos num1
//forma1 de hacerlo
String s=num1.getText();
int n1=Integer.parseInt(s);
//forma2 de hacerlo
int n1=Integer.parseInt(num1.getText()); //en este ejemplo se ahorra el uso de la variable de tipo
texto.
2. Si se desea leer un decimal de una ventana de captura.
//Forma 1 de hacerlo
String sal=JOptioPane.showInputDialog("Digite el salario que desea: ");
double salario=Double.parseDouble(sal);
//Forma 2 de hacerlo
double salrio=Double.parseDouble(JOptionPane.showInputDialog("Digite el salario que desea: "));
Para mostrar los datos
Los resultados de una sola linea se muestran fácilmente en un campo de texto asi:
campoDeTexto.setText( resultado );
resultado debe ser un elemento de tipo texto si no lo es, un truco es colocar inicialmente ""+resultado
para lograr la conversión. resultado puede ser una variable, un literal, una expresión o una función.
Cuándo el campo de texto es más de una línea podemos usar un área de texto.
areaDeTexto.setText( linea1+"\n");
areaDetexto.setText(areaDeTexto.getText()+linea2+"\n");
areaDetexto.setText(areaDeTexto.getText()+linea3+"\n"); // y de esta manera agregar más líneas "\n"
corresponde a un enter
Cuándo se trata de mostrar en un mensaje de aceptar y cerrar se hace así:
JOptionPane.showMessageDialog(mainPanel, resultado ); se puede aplicar cualquiera de las formas
antes vistas para el resultado.
Ejemplo 1 completo en vídeo.
Crear un programa que muestre cuántos clic se le ha dado a un botón. La idea es que al momento de
hacer clic contamos uno y lo mostramos en un mensaje emergente.
1. Construimos la interfaz gráfica. La cual solo constará de un botón.
2. programamos el evento clicked del botón para realizar en este el algoritmo
3. Necesitamos una variable global donde vamos guardando el número de veces que se ha presionado
el botón.
4. Utilizaremos el JOptionPane.showMessageDialog para mostrar los resultados.
Video: http://www.youtube.com/watch?v=pL9LVJS4iqE
Ejemplo 2 completo en vídeo.
Crear un programa que permita convertir uno minutos ingresados por el usuario a horas.
1. Construir la GUI del ejercicio, para lo cual usaremos dos cajas de texto una para los minutos
ingresados y otra para colocar su equivalente a horas es decir la respuesta el problema dado.
2. Asignar nombres a las cajas de texto de forma que sean usados correctamente en el código para
captura y mostrar los datos.
3. Ya en el código capturar los minutos ingresados convertirlos a variables decimales.
4. Aplicar la regla de tres para pasar minutos a horas.
5. Mostrar en el campo de texto seleccionado el resultado de la operación.
Video: http://www.youtube.com/watch?v=5gC4RSdXF4Q
1. Solicitar que un usuario ingrese la base de un número y el exponente al cual desea elevarlo, el
programa debe mostrar el resultado de la operación.
2. Solicitarle a una persona que ingrese su nombre, identificación y cuantos billetes de 1000, 5000,
10000, 20000, 50000 tiene, para que el sistema le imprima el valor total de dinero del que dispone.
3. Dado el lado de un cuadrado, imprimir el área del mismo.
4. Dada la base y la altura de un triangulo, imprimir el área del mismo
5. Pedir a un usuario que ingrese un número, luego otro y el programa deberá imprimir el residuo de la
división entera del primer número sobre el segundo.
6. Pedir a un usuario que ingrese su nombre, identificación, nombre de la materia, y las notas de
seguimiento, parcial y final, el sistema deberá imprimir todos los datos junto con la nota definitiva.
7. Dada una lista de cuatro productos, leer el nombre y el precio de cada uno de ellos, el precio no
incluye iva, luego imprimir, el valor del iva para cada producto y el costo total de la compra con y
sin iva.
8. Dado un nombre, año de nacimiento y teniendo presente el año actual, calcular la edad de la
persona.
9. Pensando en los datos de un triangulo rectángulo, calcular, dados la hipotenusa y uno de los catetos,
el área de dicho triangulo.
10. Dado el nombre de un estudiante, la materia, las notas de seguimiento y parcial, el programa deberá
imprimir todos los datos y cuanto necesita el estudiante para ganar la asignatura.
11. Dada una cantidad de dolares y el valor de la tasa de cambio a pesos, imprimir a cuantos pesos
equivale la cifra ingresada.
12. Pedir a una persona que ingrese el monto que desea que le presten en una natillera, si los intereses
son anticipados al 5% mensual, preguntar a cuantos meses desea el préstamo y generarle cuanto
paga de intereses y cuanto realmente le terminan prestando.
13. Construir un programa que permita calcular el valor real de un electrodoméstico del cual se debe
identificar el nombre, el número de cuotas y el costo de cada cuota.
14. Dado el número de peldaños de una escalera, al ancho del peldaño y la distancia entre dos peldaño,
imprimir el largo de dicha escalera. Si el ancho del peldaño esta dado en milímetros, la distancia
entre ellos esta dada en metros y se pide el largo de la escalera en centímetros.
15. Dados 8 dígitos binarios ingresados por el usuario, imprimir su equivalente decimal.
16. Dados 8 dígitos octales ingresados por el teclado, imprimir el equivalente decimal.
Fuente: http://sites.google.com/site/tutoriasdeingenieria/lenguajes-de-programacion/operadores-y-operaciones-basicas-de-
java-netbeans

Usando If en Java-Netbeans
Objetivo:
Reconocer la toma de decisiones en el lenguaje seleccionado.
Al finalizar la clase los estudiantes estarán en capacidad de:
Utilizar las decisiones que ofrece el lenguaje seleccionado.
Realizar ejercicios de programación en el lenguaje seleccionado.
Los operadores relacionales para los tipos primitivos
< ............................................................................... menor que
> ............................................................................... mayor que
<= ............................................................................. menor o igual que
>= ............................................................................. mayor o igual que
!= .............................................................................. diferente de
== ............................................................................. Igual a
Los operadores lógicos
&& ........................................................................... and
|| ................................................................................ or
! ................................................................................ not
Los valores lógicos boolean
true
false
Las funciones para comparar textos
Para verificar si es igual texto.equals( textoComparación )
para verificar si es mayor, menor incluso igual texto.compareTo( textoComparación)
Las decisiones.
Las sentencias de decisión se denominan SI DE LO CONTRARIO. Su finalidad es la de hacer una
pregunta lógica o relacional y con base en dicha pregunta hacer un bloque de código u otro. Se dice que
un si esta anidado cuando se encuentra dentro de otro bloque si o por de lo contrario.
Si de una sola línea
Esta decisión solo aplica para una línea que se encuentra exactamente después del if, también aplica
para else, cuando sea de una sola línea no necesita las llaves.
Si de un bloque

La finalidad de este es evaluar la expresión y en caso que sea verdadera ejecutar todas las instrucciones
que se encuentran encerradas por {}. Recordemos a a esa parte que está delimitada por las llaves se les
denomina bloque.
Si con de lo contrario

La finalidad es evaluar la expresión si es verdadera ingresa al bloque que está debajo del if desde {abre
hasta }cierra. En caso de ser la expresión falsa, salta el bloque principal y entra al bloque else que esta
delimitado por {}, {abre el bloque }cierra el bloque.
Esta es excluyendo es decir o entra al bloque de verdad o lo hace al de falsedad pero no a ambos. A
esto se le denomina exclusión mutua.
Si de lo contrario Si... else.

Esta decisión es especial en la medida que muestra un anidamiento implícito. La finalidad es hacer la
pregunta inicial si esta es falsa, por de lo contrario se realiza otra pregunta, esto se repite
indefinidamente y solo hasta el final se agrega de lo contrario. Cuando se ingresa a un bloque ya no se
ingresa a ningún otro de manera que siguen siendo excluyentes entre SI
Las decisiones anidadas.
Significan que dentro de cualquiera de los bloques de los if,else e if else, se pueden colocar otros if,
else e if else y a su vez dentro de estos otros y esto sin un límite dado. Una clave es respetar la
indentación:
Claves necesarias para las decisiones
1. Siempre la expresión del if debe estar encerrada entre paréntesis ( expresión) y dentro de ésta se
pueden colocar otros if, else, if else...
2. Es mejor siempre delimitar los bloques con {}de forma que no se preste para confusiones.
3. Siempre respetar la sangría, tabulación o indentación.
4. Es mejor anidar preguntas, que hacer expresiones muy complejas de entender.
5. El mayor o igual cuando se habla de enteros, puede ser reemplazado por > valor -1 y < valor+1
6. Cuando se comparan textos == no funciona y debe ser utilizada la palabra equals así:
forma 1
String s="hola";
if (s.equals("prueba")==true){
//bloque de verdad
}
forma 2
String variable="";
if ("prueba".equals(variable)){
//bloque de verdad
}
forma 3
String var1="",var2="";
if ( var1.equals(var2)){
//bloque de verdad
}
forma 4
String var1="",var2="";
if ( var1.equals(var2+"expresión")){
//bloque de verdad
}
7. Cuando se define una variable dentro de un bloque, ésta solo "vive" para el bloque por tanto fuera de
este sirve, para recordar el tema del ámbito ver clases anteriores
La instrucción casos
Es usada para determinar de entre un grupo de elementos cual de ellos es igual a uno dado. Su
desventaja radica en que solo funciona para enteros int o char y en los casos solo pueden haber valores
constantes, aclaro que este solo es un comportamiento de java otros lenguajes no la manejan o lo hacen
de manera distinta.

La palabra break, determina el fin del caso y los dos puntos después del literal determinan el inicio. En
el gráfico lo que aparece con corchetes significa que puede estar pero no es obligatorio.
default es el caso por defecto si después de evaluar todos los anteriores no encuentra coincidencias
entonces por defecto ingresa a éste.
Dentro del grupo de sentencias se puede ubicar cualquiera de las vistas o por ver es decir if, else, for,
while switch.....
Respetar la tabulación hace la diferencia entre entender o complicar el problema.
Fuente: http://sites.google.com/site/tutoriasdeingenieria/lenguajes-de-programacion/usando-if-en-java-netbeans
Limitar los caracteres en un JTextField
Este es un ejemplo muy basico, donde se limita la entrada de caracteres en un JTextField, pues es una
forma muy util cuando se necesita.
Para que quede claro, la clase JTextFieldLimit es una clase de tipo Document que sobreescribirá
insertString(…) que controlará la condicion de la cantidad de caracteres como límite. Esta clase es
llamada donde se instancia el JTextField, es decir donde se declara dicho componente, veamos:
/**
*
* @author manix
*/
import javax.swing.text.*;

public class JTextFieldLimit extends PlainDocument {


private int limit;
// optional uppercase conversion
private boolean toUppercase = false;

JTextFieldLimit(int limit) {
super();
this.limit = limit;
}

JTextFieldLimit(int limit, boolean upper) {


super();
this.limit = limit;
toUppercase = upper;
}

@Override
public void insertString
(int offset, String str, AttributeSet attr)
throws BadLocationException {
if (str == null) return;

if ((getLength() + str.length()) <= limit) {


if (toUppercase) str = str.toUpperCase();
super.insertString(offset, str, attr);
}
}
}
El constructor recibe un int, que indica el límite de caracteres que se permitirá ingresar en el JTextField
JTextFieldLimit(int limit)
Ahora veamos como se usa esta clase con aplicándolo a nuestro JTextField:
JTextField textfield = new JTextField();
textField.setDocument(new JTextFieldLimit(15));
Noten como se hace una instancia de la clase JTextFieldLimit antes mencionada recibiendo el numero
15 como limitador de cararteres. Acá podrán ver el ejemplo completo, y abajo los encontraran el código
empleando.
Fuente: http://www.apuntes.delibertad.com/java/limitar-los-caracteres-en-un-jtextfield/
SOFTWARE DE INVENTARIO DESARROLLADO EN NETBEANS
Buenas, a continuación les dejo un aplicativo que hice como
proyecto en la universidad en el 3er ciclo y quisiera compartirlo
para ver si pueden aportar mejoras al programa y si a alguien le
sirve que pueda usarlo para un proyecto y mejorarlo al mismo
estilo de software libre.
Bueno por motivos de tiempo me falto programar las
instrucciones del botón de Kardex, pues bueno si alguien se
anima a complementarlo o enviar sugerencias para
complementarlo se puede hacer. Espero sus comentarios y
sugerencias para la mejora de un programa.
“Un sistema grande y complejo que no ha evolucionado a partir
de otro pequeño y simple no funciona y, además, es imposible
arreglarlo para que funcione” - Bjarne Stroustrup.
A continuación les dejo unas capturas del aplicativo
Primera pantalla o ventana principal de control con todos los botónes:

Segunda captura que corresponde al botón proveedores, el cual contiene los datos mas resaltantes de un
proveedor de productos:
Tercera captura que le corresponde al botón de clientes, el cual contiene los datos principales de los
clientes que se tiene:

La cuarta captura corresponde al botón de productos al cual se ingresaran los atributos de cada
producto para tenerlos en la base de datos y a partir de hay hacer una orden de compra.

La quinta captura o imagen que se muestra corresponde al botón de personal, el cual contiene los datos
o atributos mas resaltantes de cada vendedor o almacenero que manejara el software de inventario:
La sexta y última imagen que se muestra corresponde a el botón de orden de compra el cual va a
interactuar con los productos existentes para a partir de los que se tiene hacer una orden de compra.

ESPECIFICACIONES:
Cuando intenten cargar el aplicativo en su NetBeans quizá les aparezca una advertencia de error, eso
por el problema de compatibilidad ya que lo desarrollé en la versión del NetBeans 6.7.1 . Pero omiten
la advertencia de error y le dan simplemente a continuar o aceptar y se cargará el aplicativo a su lista de
proyectos con un pequeño icono de advertencia en la taza de café, pero correrá sin ningún problema..
Una vez que hayan cargado el aplicativo a su lista de proyectos en NetBeans aparecerán dos paquetes,
el paquete llamado "newpackage" es el que contiene las claces y formularios y para que vean correr el
aplicativo completo abren ese paquete y dan click derecho al formulario llamado "Presentacion.java" y
seleccionan ejecutar archivo.
Aparecerá después de la presentación una pequeña ventana que pedirá la validación y existen dos tipos
como acceder como administrador o como vendedor, si se selecciona vendedor se activara el cuadro
donde les pide el código del vendedor, pero en este caso ingresaremos como administrador, para eso en
nivel de acceso seleccionamos "ADMINISTRADOR" y la contraseña es "ACREDITACIÓN" le dan a
"OK" y listo.
Justamente después de logearse les aparecerá una ventana que les pide el tipo de cambio, bueno es sin
importancia por que lo puse mas que todo para complementarlo, claro eso no quita que sea importante
ya que manejaremos precios, pero bueno no afecta en nada lo que pongan en ese apartado de tipo de
cambio, si pueden codificarlo y darle un uso para que sea utilizado el tipo de cambio dentro del
aplicativo sería excelente, pero hay esta solo para resaltar ese atributo dentro del aplicativo, entonces
solo colocan un valor numérico cualquiera al tipo de cambio y le san en "SAVE" y se abrirá recién el
formulario de control, asimismo la fecha que aparece es "ficticia" ya que no encontré el método de que
como se cargue la fecha actual para ese cuadro de texto.
Algo muy importante, se observa en cada formulario en la parte izquierda un jList o mejor dicho una
lista que contiene el listado de proveedores, vendedores, productos segun sea el formulario
seleccionado, el algoritmo lo implemente para que mediante un evento de teclado se impriman los
atributos del objeto seleccionado que este en la lista, es decir, por ejemplo seleccionan el botón de
PRODUCTOS se abrira el formulario correspondiente y se observa un listado de productos en una lista
al lado izquierdo, seleccionamos cualquiera le damos un click y le damos ENTER y se imprimiran los
atributos del producto seleccionado.
Lo que quise desarrollar y esto si lo resalto mucho por que quise desarrollar un algoritmo que me
permita filtrar la lista (jList) a través de un campo de texto (TextField) para que el metodo de búsqueda
sea mas sencillo, si alguien encuentra la forma de hacerlo se agradecerá, ya que lo busque por Internet
y nunca logré encontrar la manera como.
Principalmente cabe mencionar que no se utilizó conexiones a bases de datos como SQL o MySql ni
Oracle por motivos que en aquel siclo aun no veiamos ese tema, pero tiene un estilo de base de datos ya
que los datos ingresados se guardan en archivos binarios de extensión ".bin", lo cual guarda los datos
ingresados en la misma carpeta donde se encuentran los archivos del aplicativo.
Adicionalmente si alguien sabe como insertarle un calendario "jCalendar" al aplicativo en las partes
donde se necesita fecha lo agradecería mucho ya que trate de insertarlo pero no entendí nunca por que
me identificaba como error, bueno es un detalle mas para mejorar la apariencia del aplicativo.
El código de cada producto se genera aleatoriamente con el método "Randon" para que no existan
problemas al momento de crear uno manualmente.
Por motivos de tiempo no implemente el botón de Kardex, ademas por falta de conocimiento en la
parte temática ya que es un tema mas de contabilidad, ya que si alguien podría darme ideas de como
implementar un Kardex se podría trabajar en ello.
En conclusión este es un pequeño aplicativo que desarrollé, con la intención que sea totalmente
intuitivo para un usuario, con el genial NetBeans IDE y lo posteo con la intención tambien de mejorarlo
y asimismo aprender mas de este programa tan completo e interesante, cualquier aporte al aplicativo,
comentario, crítica constructiva y puntos se agradecerán mucho, saludos.

Fuente: http://www.taringa.net/posts/info/10095225/Software-de-inventario-desarrollado-en-java---NetBeans.html
Cómo hacer cuadros de diálogo simples
//título e icono por defecto
JOptionPane.showMessageDialog(null,"Texto del mensaje.");

//título personalizado, icono de aviso


JOptionPane.showMessageDialog(null,"Texto del mensaje.","Título del marco",
JOptionPane.WARNING_MESSAGE);

//título personalizado, icono de error


JOptionPane.showMessageDialog(null,"Texto del mensaje.","Título del marco",
JOptionPane.ERROR_MESSAGE);

//título personalizado, sin icono


JOptionPane.showMessageDialog(null,"Texto del mensaje.","Título del marco",
JOptionPane.PLAIN_MESSAGE);

Fuente: http://ayuda-java.blogspot.com/2007/07/cmo-hacer-cuadros-de-dilogo-simples.html

Generar un archivo jar ejecutable


Muchas veces necesitamos crear un archivo que podamos ejecutar , esto es mas cuando empezamos a
trabajar con interface gráfica y en fin necesitamos crear un ejecutable. El propio NetBeans posee una
sencilla forma de como crear ejecutables con nuestros proyectos para esto hay que tener en cuenta lo
siguiente:
1.- Al momento de crear nuestro proyecto debemos haber desmarcado las casillas de Create Main
Class y set as Main Project :
2.- Ahora nos ubicamos en nuestro proyecto , en mi caso será este proyecto:

3.- Y nos vamos a Build → Clean and Build Main Project

4.- NetBeans nos debe confirmar que ya se construyo el archivo jar de nuestra aplicación con un
mensaje de BUILD SUCCESSFUL el cual nos indica que la construcción ha sido exitosa . Es en este
momento que en la carpeta de nuestro proyecto se ha creado una nueva carpeta llamada dist en la cual
esta nuestro archivo jar:
Ahora cada vez que deseamos ejecutar nuestro proyecto sin abrir el netbeans solo bastará con hacer
doble clic en el archivo JAR y listo.
También se puede agregar nuestro archivo JAR a nuevos proyectos que desarrollemos .
Fuente: http://javax0711.blogspot.com/2009/04/generar-un-archivo-jar-ejecutable.html

Saber cuantas filas tiene un ResultSet


Creo que no se puede, no me suena al menos. Pero puedes hacer un
ResultSet rs;
..
rs.last();
int cuantos = rs.getRow();
en vez de hacer tantos .next(). Te devolverá el número de la última fila, lo que no sé es si tendrás que
sumarle 1, restarle 1, o quedarte con ese número ya (haz alguna pruebita) para saber cuantas filas hay.
Fuente: http://www.forosdelweb.com/f45/saber-cuantas-filas-tiene-resultset-425976/

¿NetBeans 6.9 ¿Como convertir un int a su codigo ASCII?


/*
Hola, puedes hacer un casting con (char)
Ypara las conversiones de octal, hexadecima y binario puedes usar la clase Integer
Te dejo los ejemplos
*/

public class Main{


public static void main(String[]args){
int n = 97;
System.out.println( (char)n );
System.out.println( Integer.toBinaryString(n));
System.out.println( Integer.toHexString(n));
System.out.println( Integer.toOctalString(n));
}
}

//El entero n se convierte al caracter 'a'


//Saludos.
Fuente: http://mx.answers.yahoo.com/question/index?qid=20110313152059AAHa6Qp

Tutorial de Java Swing (11): JMenuBar, JMenu, JMenuItem.


Vamos a ver ahora una ventana principal JFrame (ventana principal) que contiene un Menu principal
(JMenuBar) con varias opciones (Archivo, Editar, Ayuda y Salir), cada una de las cuales contiene otras
opciones de menú (JMenuItem) y una barra de progreso (JProgressBar). Colocaremos también un
componente JTextArea.
La mejor manera de afrontar este diseño es crear desde NetBeans un proyecto nuevo siguiendo la
plantilla correspondiente a “Proyecto Nuevo”, “Java” y “Java Desktop Aplication”. (Aplicación
básica).
Si llamamos al proyecto “Apliejemplo” aparecerá un paquete con dicho nombre. Este paquete contiene
tres componentes java: ApliEjemploAboutBox, ApliEjemploApp, ApliEjemploView.
ApliEjemploApp
ApliEjemploApp, define una clase llamada igual “ApliEjemploApp” que deriva de la clase por
extensión “SingleFrameApplication”, definida en el paquete org.jdesktop.application.SingleFrame-
Application. Nótese que la plantilla ha incorporado dos nuevas bibliotecas de clases denominadas
appframework-1.0.3.jar y swing-worker-1.1.jar. Si despliega la primera de ellas, en el paquete
org.jdesktop.application encontrará la definición de la clase “SingleFrameApplication” que buscamos.

Esta clase contiene el método estático main (método vinculado a la clase y no a sus instancias u
objetos) necesario para arrancar, a través de la máquina virtual de Java, el proyecto. ¿Qué hace
exactamente el método main?. Pues llamar a launch(ApliEjemploApp.class, args);
Esto crea una instancia de la clase ApliEjemploApp y llama al método startup de la instancia u objeto
recién creado. En el método startup tenemos el método show(new ApliEjemploView(this)); con esto
instanciamos la clase ApliEjemploView y la visualizamos.
ApliEjemploView
ApliEjemploView es la clase que describe al JFrame o ventana principal. Si desplegamos desde el
“Inspector” los componentes (tenemos que estar en modo Diseño) veremos el siguiente árbol

Vemos pues que el JFrame, contiene


 Un panel (JPanel) principal que ocupa todo el JFrame
 Un menu principal (JMenuBar) con dos opciones fileMenu y helpMenu (los dos son componentes
JMenuItem y los dos tienen a su vez una opción de menú, son los llamados JMenuItem).
 Un panel o componente JPanel que a su vez contiene dos etiquetas JLabel, un separador JSeparator
y una barra de progreso.
Finalmente, la plantilla ha creado otro JFrame, ApliEjemploAboutBox, que muestra una ventana con
información básica de nuestra aplicación.

Esta interfaz está compuesta básicamente de un componente JDialog (un tipo especial de ventana) que
a su vez contiene componentes del tipo JButon y JLabel. Observe que los componentes del tipo JLabel
pueden contener textos y/o imágenes. Como es natural, para una aplicación particular tendremos que
modificar los val0res de estos componentes.
Vamos ahora a singularizar la interfaz ApliEjemploView.
 La primera tarea que vamos a hacer es particularizar la barra de menú, pues deseamos que las
opciones principales del menú principal sean Archivo, Editar, Ayuda y Cerrar. Para ello lo primero
será cambiar el texto de la primera opción “File” por “Archivo”. Para ello seleccionamos el JMenu
correspondiente a File y desde la caja de propiedades cambiamos la propiedad “text”. Después
seleccionamos desde la paleta de menús un componente menú en el menú principal al que le
asignaremos la propiedad “text” en “Editar”. Hacemos lo mismo con una opción de “Cerrar”.
Cambiamos el texto de la opción “Help” y finalmente reorganizamos la opciones. Es decir:

 Ahora en la opción principal “Archivo” queremos que se desplieguen las cuatro opciones “Abrir”,
“Salvar”, “Salvar como…” y “Salir”. Para ello, insertamos tres elementos de menú (JMenuItem) por
encima del ya existente. Cambiamos la propiedad “text” a los textos previstos, cambiamos las
propiedades “toolTipText” a “Abrir archivo nuevo”, “Salvar archivo”, “Salvar con otro nombre” y
“Salir de la aplicación” respectivamente. Finalmente, cambiamos las propiedades “accelerator” de
cada una de las opciones de “Archivo” a través de
de esta manera cambiamos el atajo de tejado a Ctrl+A, Ctrl+S, Ctrl+C las tres primeras opciones de
“Archivo”. Es decir:

Vamos finalmente a colocar un icono en las opciones “Abrir” y “Salvar”. Para hacer esto lo primero
que tenemos que hacer es localizar la carpeta C:\EjemplosJava\ApliEjemplo\src\apliejemplo\resources
(o en su caso, la correspondiente a los recursos del proyecto) y copiar los iconos que representarán las
dos funciones. Luego seleccionando el elemento de menú “Abrir” y desde la caja de propiedades
seleccionamos la propiedad “icon” y seleccionamos finalmente el archivo, es decir:

Finalmente,
Fuente: http://jtagua.wordpress.com/2010/09/24/tutorial-de-java-swing-11-jmenubar-jmenu-jmenuitem-jprogressbar-jtextarea/

¿Llamar JFrame dede Un jMenuItem NETBEANS?


Pues en el evento onclick del menu, lo puedes hacer tansolamente debes, si estas trabajando desde el
editor de formularios del netbeans, hacer clik derecho->eventos->mouse clicked te parecera el metodo
que te captara el evento click (tambien se lo puede hacer desde el evento action) luego llamas a tu
formulario instanciandolo
Formualrio form=new Formulario();
form.setVisible(true);
y listo con esto tendria que andar
ha y tambien tendrias que tener en cuenta, si los formualrios estan en modal o no, siempre la ventana
principal tiene que ser un jframe y la que despues se abren tienen que ser jdialog, y a estas se la pueden
poner como modal o no...saludos
Fuente: http://es.answers.yahoo.com/question/index?qid=20110201095618AA17lc9

JComboBox Con Objetos y Base de Datos MySQL


public Vector<ClaseObjetoParaComboBox> ListaDeObjetosParaComboBox() {
Connection conexion;
conexion = ConexionBD.obtenerConexion();
try {
ResultSet resultado;
Statement sentencia;
sentencia=conexion.createStatement();
resultado=sentencia.executeQuery("SELECT * FROM ObjetoParaComboBox");
Vector<ClaseObjetoParaComboBox> data=new Vector<ClaseObjetoParaComboBox>();
if(resultado.next()) {
do {
ClaseObjetoParaComboBox oListaTemporal = new
ClaseObjetoParaComboBox(resultado.getInt(1),resultado.getString(2));
data.addElement(oListaTemporal);
}
while(resultado.next());
return data;
}
else {
return null;
}
} catch(Exception ex) {
System.out.print(ex);
return null;
}
}

Fuente: http://chuwiki.chuidiang.org/index.php?title=JComboBox_Con_Objetos_y_Base_de_Datos_MySQL

Ejecutar SQL en Java


En esta ocasión veremos como ejecutar sentencias SQL en Java, tomando en cuenta la conexión que
realizamos a la base de datos anteriormente.
Para este ejemplo uso una tabla llamada “usuarios”, la cual tiene únicamente 3 campos: id(autoinc),
nombre y contraseña
El código de la clase es el siguiente:
import java.sql.*;
public class Conexion {
private String user;
private String password;
private String db;
private String host;
private String url;
private Connection conn = null;
private Statement stm;
private ResultSet rs;
public Conexion(String usuario, String contraseña, String bd, String servidor)
{
this.user = usuario;
this.password = contraseña;
this.db = bd;
this.host = servidor;
this.url = "jdbc:mysql://" + this.host + "/" + this.db;
}
public void conectar()
{
try {
Class.forName("org.gjt.mm.mysql.Driver");
conn = DriverManager.getConnection(url, user, password);
if (conn != null)
{
System.out.println("Conexión a base de datos "+url+" ... Ok");
stm = conn.createStatement();
}
}
catch(SQLException ex) {
System.out.println("Hubo un problema al intentar conectarse con la base de datos
+url);
}
catch(ClassNotFoundException ex) {
System.out.println(ex);
}
}
public void consultar() throws SQLException
{
rs = stm.executeQuery("SELECT * FROM usuarios");
while(rs.next())
{
System.out.println(rs.getString("nombre"));
System.out.println(rs.getString("contraseña"));
}
}
public void actualizar() throws SQLException
{
stm.execute("UPDATE usuarios SET nombre='nombre usuario' WHERE id="+1);
}
public void insertar() throws SQLException
{
stm.execute("INSERT INTO usuarios (nombre, contraseña) VALUES ('new_name',
'new_Pass')");
}
public void eliminar() throws SQLException
{
stm.execute("DELETE FROM usuarios WHERE id="+1);
}
}
Únicamente resta crear una instancia de la clase y empezar a utilizar sus métodos.
Fuente: http://fragowb.wordpress.com/2008/05/08/ejecutar-sql-en-java/

Ejemplo de Java + SQL + Netbeans


Después de un poco de retraso de este post y de tener un poco de tiempo sin postear algo, traigo este
ejemplo (el tercero) de Java y MySQL bajo la plataforma Netbeans. El propósito de este post es crear
una clase que realmente realiza las acciones básicas (agregar, modificar, eliminar, consultar) pero
implementadas de una “mejor manera” comparada con los otros post que hay en este blog sobre este
tema (tampoco quiero decir que sea la mejor ni mucho menos).
La base de datos que usaremos para este ejemplo es la siguiente:
 BD: prueba.
 tabla: usuarios.
 campos: id(autoinc), nombre, contraseña.
Diagrama de clases:

Bueno, primero que nada empezaremos con nuestra clase que contendrá los métodos de las acciones
que vamos a realizar.
import java.sql.*;
import java.util.Hashtable;
public class SQLconnection {
private String user;
private String password;
private String db;
private String host;
private String url;
private Connection conn = null;
private Statement stm;
private ResultSet rs;
public SQLconnection()
{
this.url = “jdbc:mysql://” + this.host + “/” + this.db;
}
public SQLconnection (String server, String usuario, String contraseña, String bd)
{
this.user = usuario;
this.password = contraseña;
this.db = bd;
this.host = server;
this.url = “jdbc:mysql://” + this.host + “/” + this.db;
}
public void connectar()
{
try {
Class.forName(“org.gjt.mm.mysql.Driver”);
conn = DriverManager.getConnection(url, user, password);
if (conn != null)
{
System.out.println(“Conexión a base de datos “+url+” … Ok”);
stm = conn.createStatement();
}
}
catch(SQLException ex) {
System.out.println(“Hubo un problema al intentar conectarse con la base de datos
“+url);
}
catch(ClassNotFoundException ex) {
System.out.println(ex);
}
}
public String getDb() {
return db;
}
public void setDb(String db) {
this.db = db;
}
public String getHost() {
return host;
}
public void setHost(String host) {
this.host = host;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getUser() {
return user;
}
public void setUser(String user) {
this.user = user;
}
public ResultSet consultar(String tabla) throws SQLException
{
rs = stm.executeQuery(“SELECT * FROM ” + tabla);
return rs;
}
public String buscarNombre(String tabla, String nombre) throws SQLException
{
String name = null;
try{
rs = stm.executeQuery(“SELECT * FROM ” + tabla + “ WHERE nombre = ‘”+ nombre +”‘
LIMIT″);
rs.next();
name = rs.getString(2);
}catch(SQLException ex){System.out.println(ex);}
return name;
}
public void insertar(Hashtable usuario)
{
try {
stm.execute(“INSERT INTO usuarios (nombre, contraseña) VALUES (‘” +
usuario.get(“nombre”) + “‘,’” + usuario.get(“contraseña”) + “‘)”);
}catch (SQLException ex) {
System.out.println(ex);
}
}
public void actualizar(String tabla, Hashtable usuario, String nombre)
{
try {
stm.execute(“UPDATE ” + tabla + ” SET nombre=’” + usuario.get(“nombre”) + “‘ WHERE
nombre=’” + nombre + “‘”);
}catch (SQLException ex) {
System.out.println(ex);
}
}
public void eliminar(String tabla, String nombre)
{
try {
stm.execute(“DELETE FROM ” + tabla + ” WHERE nombre=’” + nombre + “‘”);
}catch (SQLException ex) {
System.out.println(ex);
}
}
}
Como podemos observar, esta clase cuenta con sobrecarga de constructores lo cual nos permite
conectarnos de 2 maneras distintas a la base de datos. La primera es utilizar el constructor que no
recibe ningún parámetro y definirlos mediante los métodos set y get para después llamar al método
conectar. La segunda es enviarle directamente los valores al constructor y, al igual que en la forma
anterior, ejecutar el método conectar, y esta será la forma que usaremos para nuestro ejemplo.
Primero que nada vamos a conectarnos a nuestra base de datos y realizaremos una consulta de todos
los registros:
SQLconnection con = new SQLconnection(“localhost”,“usuario”,“contraseña”,“prueba”);
con.connectar();
ResultSet rs;
rs = con.consultar(“usuarios”);
while(rs.next()){
System.out.println(rs.getString(1));
System.out.println(rs.getString(2));
System.out.println(rs.getString(3));
}
En esta clase también implementamos una opción que nos permite realizar búsquedas por medio de
nombres(es el campo de la base de datos que elegí para este ejemplo); ha este método le mandamos 2
parámetros, que son la base de datos y el nombre:
System.out.println(con.buscarNombre(“usuarios”, “frago”));
Para insertar un nuevo registro vamos a hacer uso del Hastable para enviarle los valores que queremos
agregar:
Hashtable usuario = new Hashtable();
usuario.put(“nombre”,“frago”);
usuario.put(“contraseña”,“xxx”);
con.insertar(usuario);
Para eliminar un registro simplemente le ejecutamos el método correspondiente y le pasamos como
parametros la tabla y el nomrbe del usuario a eliminar:
con.eliminar(tabla, “frago”);
Para actualizar un registro le tenemos que pasar 3 parámetros al método. EL primero es el nombre de
la tabla; el segundo es un Hastable en el que se incluya la modificación que se quiere realizar y el tercer
es, en este caso, el nombre de la persona a la que se le va realizar la modificación:
Hashtable usuario = new Hashtable();
usuario.put(“nombre”, “frago1″);
con.actualizar(tabla, usuario, “frago”);
Fuente: http://fragowb.wordpress.com/2008/07/22/ejemplo-de-java-sql-netbeans/

CONECTAR MYSQL A JAVA (Netbeans)


Conocemos la forma de conectar mysql o alguna base de datos como lo es Sql Server, Oracle,
PosgreSQL a java perousando lis driversManager una forma visual muy practica pero muy compleja a
la hora de mandar la aplicacion a alguna otra computadora, para olvidarnos de esto y no tener un
desorden de codificaciones visuales en el form crearemos una clase de conexcion, en ella realizaremos
un metodos para la conexion y otros dos para hacer las consultas y operaciones de insert y update a la
base de datos.
La Clase
Para crear la clase de conexion en nuestra solucion damos clic en el boton de Agregar Archivo, o nos
vamos a archivo una vez que nos aparesca la ventana de nuevo archivo escojemos la carpeta de Clases
Java y el tipo de archivo Clase Java, una vez que nos ha creado la , empezamos bueno de esta seccion,
la codificacion.
Codificacion:
Empezamos anexando la siguiente directiva que utilizaremos java.sql.*, esto nos permitira utilizar
todos los componentes para la creacion de la conexion y otros metodos que utilizemos
Ejemplo:
Import java.sql.*
Metodo de conexion , para el metodo de conexcion para ello utilizaremos los siguientes componentes:
Connection, Statement y ResultSet, a continuacion generamos el metodo o en este caso el constructor
de la clase.
public Conexion() {
try
{
Class.forName(“com.mysql.jdbc.Driver”);
String url = “jdbc:mysql://localhost:3306/bdpruebrasjava”;
cn= DriverManager.getConnection( url, “root”, “123456″ );
}
catch(Exception ee)
{
System.out.println(“Error: ” + ee.getMessage());
}
}
Si se observa detenidamente, se utiliza una variable string denominada url, que sera la direccion de
nuestra base de datos, la primera linea nos crea la informacion del driver de conexion y por ultimo se
genera dicha conexion usando la variable “cn” y asignandole los parametros de ruta de la base de
datos,usuario y contraseña.
Metodos Auxiliares
Acontinuacion crearemos los metodos para generar los insert, update y deletes de los registros de la
base de datos.
public String Ejecutar(String sql)
{
String error=”";
Try
{
St=Conec.createStatement();
St.execute(sql);
}
catch(Exception ex)
{
error = ex.getMessage();
}
return(error);
}
El St es nuestro Statemen el cual generara el comando de ejecucion, para ello todo este comando lo
mandamos en el parametro sql, la funcion es de tipo string, por ello se regresa la variable de tipo string
error la cual contendra el error que pueda optenerce en el proceso de insert o update,o en su caso no
traer nada debido a que la accion fue exitosa.
Por ultimo creamos el metodo para ejecutar consultas para ello utilizaremos un componente llamado
ResultSet.
public ResultSet Consulta(String sql){
String error=”";
Try
{
St=Conec.createStatement();
reg=St.executeQuery(sql);
}
catch(Exception ee)
{
error = ee.getMessage();
}
return(reg);
}
Dentro de esta funcion volvemos a encontrar a nuestro Statement por lo anteriormente mencionado sera
nuestro ejecutor de comandos del parametro sql el cual tendra como valor la consulta que deseamos
ejecutar.
Conclusion:
Todas la variables de conexion (cn), Statement (St) y ResultSet(reg) fueron declaradas fuera de todos
los metodos, es decir son globales y pueden verse en toda la clase no importa en que proceso lo
utilizemos, y para saldar la duda, anteriormente dije que todos estos son metodos, asi es pero por que
ejecutar y consulta los llame funciones, es sencillo recordemos algo de teoria, toda funcion retorna un
valor es por ello que se le llama funciones a ejecutar y a consulta por que regresan el valor de la
variable error y reg respectivamente.
Uso
Para terminar esta entrada, les dejo la forma de utilizar esta clase.
//Instanciamos la clase de conexion
Conexion cxn = new Conexcion();
//Generamos un insert en la tabla de clientes usando el metodo ejecutar de la clase
conexión
string msg =
cxn.Ejecutar(“INSERT INTO tpjclientes (nombre,apellidos) VALUES (‘Juan’,'Perez’);
//Generamos un select a la tabla de clientes, el resultado caera en resultset
ResultSet = cxn.Consulta(“SELECT * FROM tpjclientes”);
NOTA IMPORTANTE: Las funciones o metodos utilizados, regresan un tipo de datos o componente
especifico, es por ello que en ejecutar el resultado lo guardo en eun string y en consulta lo guardo en n
ResultSet, ademas hay que resaltar algo, java obliga a los usuarioa utilizar el clasico catch y try para
manejar correctamente las exepciones que puedan existir dentro de la llamada al metodo, eso es todo
por el dia de hoy espero les sea de gran utilidad este codigo, dejen sus comentarion y/o sugerencias de
que desean ver sobre tecnologia en el blog.
Fuente: http://jhodrickgg.wordpress.com/2007/11/30/conectar-mysql-a-java-netbeans/

Conectando PostgreSQL con Java


En este mini tutorial intentaré explicar la manera en conectar nuestra aplicación hecha en JAVA con la
Base de Datos de PostgreSQL.
Primero, es necesario descargarse el JDBC Driver para PostgreSQL. Este se encuentra en la página
http://jdbc.postgresql.org/index.html Obviamente, será necesario contar con nuestra Base de Datos
funcionando para realizar las consultas necesarias.
Posteriormente hay que determinar la manera de agregar este Driver a nuestro proyecto. NetBeans
ofrece una manera mas que sencilla.
Conociendo la ubicación de nuestro Driver y con el proyecto abierto, en el Panel de Proyectos,
ubicamos en el Árbol de Proyecto la opción Libraries, clic Derecho en ella y seleccionamos Add JAR /
Folder..., de esta manera estaremos
agregando ej .JAR del Driver que descargamos. Esto nos crea en nuestro proyecto una carpeta llamada
"dist" y en ella otra de nombre "lib" donde esta nuestro Driver.
Ahora, teniendo lo necesario, podemos probar nuestra conexión con PostgreSQL y realizar lo que nos
concierne, Altas, Bajas y Modificaciones a nuestras tablas.
Para empezar, debemos de importar lo siguiente:
import java.sql.*;
Cabe mencionar que hay una gran diferencia entre Select y Update, Insert o Delete, ya que no se
aplican de igual manera. A continuación muestro el proceso para realizar un Select (en idioma geek,
vamos a selectear)
public class Main{
public static void main(String[] args){
/*Variable para almacenar la URL de conexión a nuestra Base de Datos, si esta estuviera en otra
máquina, necesitariamos estar registrados en ella y contar con su IP*/
String url = "jdbc:postgresql://localhost/moo";
try{
//Acceso al Driver
Class.forName("org.postgresql.Driver");
//La conexión con los parámetros necesarios
Connection con = DriverManager.getConnection( url,"postgres","postgres");
//Abrimos la conexión y la iniciamos
Statement stmt = con.createStatement();
/*Un ResultSet es como en .NET un DataSet, un arreglo temporal donde se almacenará el
resultado de la consulta SQL*/
ResultSet rs;
//Una variable String para almacenar la sentencia SQL
String query = "select id as ID from moo.usuarios";
//En el ResultSet guardamos el resultado de ejecutar la consulta
rs = stmt.executeQuery(query);
//En un ciclo while recorremos cada fila del resultado de nuestro Select
while ( rs.next()){
/*Aqui practicamente podemos hacer lo que deseemos con el resultado, en mi caso solo lo mande
a imprimir*/
System.out.println(rs.getString("ID") + " " + rs.getString("ID"));
}
//Cerramos la conexión
stmt.execute("END");
stmt.close();
con.close();
}
catch( Exception e ){
//Por si ocurre un error
System.out.println(e.getMessage());
e.printStackTrace();
}
}
}
Para realizar todo aquello diferente a un Select, utilzaremos lo siguiente:
/*Variable para almacenar la URL de conexión a nuestra Base de Datos, si esta estuviera en otra
máquina, necesitariamos estar registrados en ella y contar con su IP*/
String url = "jdbc:postgresql://localhost/moo";
try{
//Acceso al Driver
Class.forName("org.postgresql.Driver");
//La conexión con los parámetros necesarios
Connection con = DriverManager.getConnection( url,"postgres","postgres");
//Abrimos la conexión y la iniciamos
Statement stmt = con.createStatement();
//Una variable String para almacenar la sentencia SQL
String query = "update moo.usuarios set nombre = 'Mauricio' where id =
'1'";
//Ejecutamos la consulta SQL
stmt.executeQuery(query);
//Cerramos la conexión
stmt.execute("END");
stmt.close();
con.close();
}
catch( Exception e ){
//Por si ocurre un error
System.out.println(e.getMessage());
e.printStackTrace();
}
Es muy importante tener en cuenta que si este método lo utilizas en una función para hacerla llamar
cuando lo necesites, y quieras enviarle tanto argumentos como retornar resultados, en la función de
Select las líneas siguientes NO deben de estar presentes:
stmt.execute("END");
stmt.close();
Y en la parte de Update, Insert o Delete, solo la siguiente línea:
stmt.execute("END");
Espero que sea útil esta información.
Fuente: http://mygnet.net/articulos/java/conectando_postgresql_con_java.1162

ResultSet & JTable


Basado en el tutorial Meter un ResultSet en un JTable veremos muy brevemente como hacerlo,
destacando las principales líneas del código.
En primera instancia nos conectamos a la BD y ejecutamos la consulta SQL que nos llenará el
ResultSet
DriverManager.registerDriver(new com.mysql.jdbc.Driver());
//Reemplazar localhost, prueba, usuario y clave por los host de la base de datos,
nombre de esquema, user y pass.
Connection conexion =
DriverManager.getConnection("jdbc:mysql://localhost/prueba","usuario","clave");
Statement s = conexion.createº();
ResultSet rs = s.executeQuery("select * from persona");
Crear un JTable, pasando como parámetro un DefaultTableModel
DefaultTableModel modelo = new DefaultTableModel();
JTable tabla = new JTable(modelo);
Nos queda resolver como llenar el DefaultTableModel. Básicamente, la forma es esta:
// Creamos las columnas.
modelo.addColumn("id");
modelo.addColumn("nombre");
modelo.addColumn("nacimiento");
// Bucle para cada resultado en la consulta
while (rs.next()) {
// Se crea un array que será una de las filas de la tabla.
Object [] fila = new Object[3]; // Hay tres columnas en la tabla
// Se rellena cada posición del array con una de las columnas de la tabla en
base de datos.
for (int i=0;i<3;i++)
fila[i] = rs.getObject(i+1); // El primer indice en rs es el 1, no el cero, por eso se suma 1.
// Se añade al modelo la fila completa.
modelo.addRow(fila);
}
Una alternativa propuesta en el tutorial es crear una clase ConversorResultSetADefaultTableModel
(puedes optar por un nombre más corto) que haciendo uso del atributo ResultSetMetaData del
ResultSet pueda obtener la metadata de las columnas seleccionadas. De esta forma, nos
independizamos de la consulta que se realice y el número de filas y columnas devueltas.
Fuente: http://luauf.com/2008/04/23/resultset-jtable/

Llamar Otro JFrame


Para llamar a un Jframe desde un boton, ya sea, situado en la pantalla principal o no, solo debes escribir
el siguiente codigo en el evento del boton que deseas:
Frame2 dg=new Frame2();
Dimension dlgSize=dg.getPreferredSize();
Dimension pantalla=getSize();
Dimension ventana=dg.getSize();
dg.setLocation((pantalla.width-dg.WIDTH)/2,(pantalla.height-dg.HEIGHT)/2);
dg.setLocationRelativeTo(null);//Centra el segundo frame en la pantalla
dg.pack();
dg.setResizable(true);//Permite redimensionarlo o agrandarlo
dg.setVisible(true);//Esto hace que se vea el segundo jframe
Fuente: http://www.lawebdelprogramador.com/foros/JBuilder/738305-Llamar_Otro_JFrame___.html

Mandar llamar a otra ventana desde un boton utilizando NetBeans.


Saludos compañeros , en la universidad apenas comienzo a ver java, y no hemos visto mucho sobre
este lenguaje.
Me impuse un pequeño reto el cual consiste en conectar el programa creado en NetBeans a una base de
datos creada en MySQL, la conexion fue correcta y despues de leer y moverle por un rato pude lograr
insertar datos a la base desde el propio programa en netbeans.
Ahora lo que quiero hacer es crear otras tablas en la base y obvio desde el programa meter los datos (lo
cual ya se hacer), la cosa aqui es no se como hacerle para cuando yo le de clic a al boton de "Maestros"
por ejemplo me aparezca la ventana para desde ahi insertar los datos.
Osea lo que quiero es que cuando yo le de clic a X boton me aparezca la otra ventana para insertar los
datos.
El code es el siguiente:
Código PHP:
/*
* alumnos.java
*
* Created on 8 de marzo de 2010, 09:52 AM
*/

package desktopapplication1;
import java.sql.*;
import javax.swing.JOptionPane;
/**
*
* @author ALUMNO
*/
public class alumnos extends javax.swing.JFrame {
private Connection conn;
private Statement sentencia;
private ResultSet res;

/** Creates new form alumnos */


public alumnos() {
initComponents();

try{
Class.forName("org.gjt.mm.mysql.Driver");

onn=DriverManager.getConnection("jdbc:mysql://localhost/control_escolar","root","ro
ot");
sentencia=conn.createStatement();
JOptionPane.showMessageDialog(this,"La conexion fue correcta");

}catch(Exception e){
JOptionPane.showMessageDialog(this,e.getMessage());
}
}

/** This method is called from within the constructor to


* initialize the form.
* WARNING: Do NOT modify this code. The content of this method is
* always regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {

jButton1 = new javax.swing.JButton();


jTextField1 = new javax.swing.JTextField();
jTextField2 = new javax.swing.JTextField();
jTextField3 = new javax.swing.JTextField();
jTextField4 = new javax.swing.JTextField();
jLabel1 = new javax.swing.JLabel();
jLabel2 = new javax.swing.JLabel();
jLabel3 = new javax.swing.JLabel();
jLabel4 = new javax.swing.JLabel();
jLabel5 = new javax.swing.JLabel();
jLabel6 = new javax.swing.JLabel();
jTextField5 = new javax.swing.JTextField();
jTextField6 = new javax.swing.JTextField();
jButton2 = new javax.swing.JButton();
jButton3 = new javax.swing.JButton();
jButton4 = new javax.swing.JButton();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
setName("Form"); // NOI18N

org.jdesktop.application.ResourceMap resourceMap =
org.jdesktop.application.Application.getInstance(desktopapplication1.DesktopApplica
tion1.class).getContext().getResourceMap(alumnos.class);
jButton1.setText(resourceMap.getString("btn_prim.text")); // NOI18N
jButton1.setName("btn_prim"); // NOI18N
jButton1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton1ActionPerformed(evt);
}
});

jTextField1.setText(resourceMap.getString("Id_txt.text")); // NOI18N
jTextField1.setName("Id_txt"); // NOI18N

jTextField2.setText(resourceMap.getString("jTextField2.text")); // NOI18N
jTextField2.setName("jTextField2"); // NOI18N

jTextField3.setText(resourceMap.getString("jTextField3.text")); // NOI18N
jTextField3.setName("jTextField3"); // NOI18N

jTextField4.setText(resourceMap.getString("jTextField4.text")); // NOI18N
jTextField4.setName("jTextField4"); // NOI18N

jLabel1.setText(resourceMap.getString("jLabel1.text")); // NOI18N
jLabel1.setName("jLabel1"); // NOI18N

jLabel2.setText(resourceMap.getString("jLabel2.text")); // NOI18N
jLabel2.setName("jLabel2"); // NOI18N

jLabel3.setText(resourceMap.getString("jLabel3.text")); // NOI18N
jLabel3.setName("jLabel3"); // NOI18N

jLabel4.setText(resourceMap.getString("jLabel4.text")); // NOI18N
jLabel4.setName("jLabel4"); // NOI18N

jLabel5.setText(resourceMap.getString("jLabel5.text")); // NOI18N
jLabel5.setName("jLabel5"); // NOI18N

jLabel6.setText(resourceMap.getString("jLabel6.text")); // NOI18N
jLabel6.setName("jLabel6"); // NOI18N

jTextField5.setText(resourceMap.getString("jTextField5.text")); // NOI18N
jTextField5.setName("jTextField5"); // NOI18N

jTextField6.setText(resourceMap.getString("jTextField6.text")); // NOI18N
jTextField6.setName("jTextField6"); // NOI18N

jButton2.setText(resourceMap.getString("jButton2.text")); // NOI18N
jButton2.setName("jButton2"); // NOI18N
jButton2.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton2ActionPerformed(evt);
}
});

jButton3.setText(resourceMap.getString("jButton3.text")); // NOI18N
jButton3.setName("jButton3"); // NOI18N
jButton3.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton3ActionPerformed(evt);
}
});

jButton4.setText(resourceMap.getString("jButton4.text")); // NOI18N
jButton4.setName("jButton4"); // NOI18N
jButton4.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton4ActionPerformed(evt);
}
});

javax.swing.GroupLayout layout = new


javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(jLabel1, javax.swing.GroupLayout.PREFERRED_SIZE,
53, javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(jLabel2)
.addComponent(jLabel4)
.addComponent(jLabel3)
.addComponent(jLabel5)
.addComponent(jLabel6))
.addGap(23, 23, 23)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING,
false)
.addComponent(jTextField6)
.addComponent(jTextField5)
.addComponent(jTextField4)
.addComponent(jTextField2,
javax.swing.GroupLayout.DEFAULT_SIZE, 172, Short.MAX_VALUE)
.addComponent(jTextField3)
.addComponent(jTextField1))
.addGap(32, 32, 32)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(jButton2)
.addComponent(jButton3)
.addComponent(jButton1)
.addComponent(jButton4))
.addContainerGap(33, Short.MAX_VALUE))
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addGap(28, 28, 28)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
.addComponent(jTextField1,
javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(jLabel1)))
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addComponent(jButton4)))
.addGap(18, 18, 18)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
.addComponent(jTextField2,
javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(jLabel2)
.addComponent(jButton1))

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addGap(18, 18, 18)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
.addComponent(jTextField3,
javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(jLabel4))
.addGap(18, 18, 18)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
.addComponent(jTextField4,
javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(jLabel3))
.addGap(18, 18, 18)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
.addComponent(jLabel5)
.addComponent(jTextField5,
javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(jButton3))
.addGap(18, 18, 18)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
.addComponent(jLabel6)
.addComponent(jTextField6,
javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE)))
.addGroup(layout.createSequentialGroup()
.addGap(36, 36, 36)
.addComponent(jButton2)))
.addContainerGap(56, Short.MAX_VALUE))
);

pack();
}// </editor-fold>

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


// TODO add your handling code here:
try{

Class.forName("org.gjt.mm.mysql.Driver");

conn=DriverManager.getConnection("jdbc:mysql://localhost/control_escolar","root","r
oot");
sentencia=conn.createStatement();

res=sentencia.executeQuery("SELECT * FROM estudiantes");


res.first();

jTextField1.setText(res.getString(1));
jTextField2.setText(res.getString(2));
jTextField3.setText(res.getString(3));
jTextField4.setText(res.getString(4));
jTextField5.setText(res.getString(5));
jTextField6.setText(res.getString(6));

}
catch(Exception e){
JOptionPane.showMessageDialog(this,e.getMessage());

}
}

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

try{

String Matricula=("0");
String Nombre_Estudiante=jTextField2.getText();
String Edad=jTextField3.getText();
String Sexo=jTextField4.getText();
String Telefono=jTextField5.getText();
String Direccion=jTextField6.getText();

jTextField1.setText("");
jTextField2.setText("");
jTextField3.setText("");
jTextField4.setText("");
jTextField5.setText("");
jTextField6.setText("");

sentencia.executeUpdate("INSERT INTO estudiantes VALUES


('"+Matricula+"','"+Nombre_Estudiante+"','"+Edad+"','"+Sexo+"','"+Telefono+"','"+Di
reccion+"' )");
}
catch(Exception e){

JOptionPane.showMessageDialog(this,e.getMessage());

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


String Nombre_Estudiante=jTextField2.getText();
try{

sentencia.executeUpdate("DELETE from estudiantes where


Nombre_Estudiante='"+Nombre_Estudiante+"'");

}
catch(Exception e){

JOptionPane.showMessageDialog(this,e.getMessage());

}
}

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

/**
* @param args the command line arguments
*/
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new alumnos().setVisible(true);
}
});
}

// Variables declaration - do not modify


private javax.swing.JButton jButton1;
private javax.swing.JButton jButton2;
private javax.swing.JButton jButton3;
private javax.swing.JButton jButton4;
private javax.swing.JLabel jLabel1;
private javax.swing.JLabel jLabel2;
private javax.swing.JLabel jLabel3;
private javax.swing.JLabel jLabel4;
private javax.swing.JLabel jLabel5;
private javax.swing.JLabel jLabel6;
private javax.swing.JTextField jTextField1;
private javax.swing.JTextField jTextField2;
private javax.swing.JTextField jTextField3;
private javax.swing.JTextField jTextField4;
private javax.swing.JTextField jTextField5;
private javax.swing.JTextField jTextField6;
// End of variables declaration

}
Fuente: http://forodejava.com/showthread.php/2313-Mandar-llamar-a-otra-ventana-desde-un-boton-
utilizando-NetBeans.

Tamaño del resultset


Statement stmt = connection.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR _READ_ONLY);

ResultSet resultSet = stmt.executeQuery("SELECT * FROM tutabla");

resultSet.last();
int rowCount = resultSet.getRow();
Fuente: http://forodejava.com/showthread.php/159-tama%C3%B1o-del-resultset

Mostrar un ResultSet en un JTable en Java


JAVA:
//Primero se obtiene la conexión a la base de datos con un código como
este:
DriverManager.registerDriver(new com.mysql.jdbc.Driver());
Connection conexion =
DriverManager.getConnection("jdbc:mysql://localhost/prueba","usuario","clav
e");

//El siguiente paso es realizar la consulta y obtener el ResultSet.


Elcódigo es el siguiente
Statements=conexion.createStatement();
ResultSetrs=s.executeQuery("select*fromtablaprueba");

//ParameterlosdatosenelJTable,usaremoslaclaseDefaultTableModel.Paraellobast
aconinstanciarelJTablecomosemuestraenelcodigo
DefaultTableModelmodelo=newDefaultTableModel();
JTabletabla=newJTable(modelo);

//AhorasólohayquerellenarelDefaultTableModelconlosdatosdelResultSet.

//Creamoslascolumnas.
modelo.addColumn("id");
modelo.addColumn("nombre");
modelo.addColumn("telefono");

//Recorremoslosregistrosconunciclowhile
while(rs.next())
{
//Secreaunarrayqueseráunadelasfilasdelatabla.
Object[]fila=newObject[3];//Haytrescolumnasenlatabla

//Serellenacadaposicióndelarrayconunadelascolumnasdelatablaenbasededatos.
for(inti=0;i<3;i++)
fila[i]=rs.getObject(i+1);//Elprimerindiceenrsesel1,noelcero,poresosesuma1.
//NoescomoenPHPootroslenguajesdondelosindicesiniciancon0

//Seañadealmodelolafilacompleta.
modelo.addRow(fila);
}
Fuente: http://www.scriptmatico.com/2008/04/18/mostrar-un-resultset-en-un-jtable-en-java/

Cargar un jcombobox desde un resulset con Netbeans 5.0 RC2


while( Resultado.isBeforeFirst()!=true)
{
Lista.addItem(Resultado.getString(3));
System.out.println(Resultado.isFirst());
Resultado.previous();
//System.out.println(Resultado.getString(3));
}
Fuente: http://www.programacion.com/foros/java-basico/cargar_un_jcombobox_desde_un_resulset_con_netbeans_5_0_rc2_283227

Consultar DB en Java – Mostrar resultados en un JTable


Siguiendo con nuestro tema de conexiones a bases de datos desde Java… Cuando estamos trabajando
con bases de datos y aplicaciones que usen Swing, la manera más elegante de presentar los datos a un
usuario es usando tablas usando la clase JTable.

Lo que haremos será básicamente crear una clase que herede de la clase AbstractTableModel:
Esta clase abstracta provee la implementación por defecto de la mayoría de los métodos en la interfaz
TableModel. Para crear un TableModel como subclase de AbstractTableModel necesitarás
implementar únicamente los sigientes tres métodos:
public int getRowCount(); public int getColumnCount();public Object
getValueAt(int row, int column);
Dicha clase administrará el contenido de nuestra tabla. Ten en cuenta que vamos a trabajar con la base
de datos que hicimos aquí. Veamos entonces el código:
import java.sql.*;
import java.util.*;
import javax.swing.table.*;
// Las filas y columnas del objeto ResultSet se cuentan desde 1 y las filas
// y columnas del objeto JTable se cuentan desde 0. Al procesar filas
// o columnas del objeto ResultSet para usarlas en un objeto JTable, es
// necesario sumar 1 al número de fila o columnas para manipular la
// columna apropiada del objeto ResultSet (es decir, la columna 0 del objeto JTable
// es la columna 1 del objeto ResultSet y la fila 0 del objeto JTable es la fila 1
del objeto ResultSet).
public class ModeloTablaResultados extends AbstractTableModel {
private Connection conexion;
private Statement instruccion;
private ResultSet conjuntoResultados;
private ResultSetMetaData metaDatos;
private int numeroDeFilas;
// mantener el registro del estado de la conexión a la base de datos
private boolean conectadoALaBaseDeDatos = false;
// inicializar conjuntoResultados y obtener su objeto de meta datos;
// determinar el número de filas
public ModeloTablaResultados( String controlador, String url,
String consulta ) throws SQLException, ClassNotFoundException {
// cargar clase de controlador de base de datos
Class.forName( controlador );
// conectarse a la base de datos
conexion = DriverManager.getConnection( url );
// crear objeto Statement para consultar la base de datos
instruccion = conexion.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY );
// actualizar estado de conexión a la base de datos
conectadoALaBaseDeDatos = true;
// establecer consulta y ejecutarla
establecerConsulta( consulta );
}
// obtener la clase que representa al tipo de columna
public Class getColumnClass( int columna ) throws IllegalStateException {
// asegurar que la conexión a la base de datos esté disponible
if ( !conectadoALaBaseDeDatos )
throw new IllegalStateException( "No hay conexion a la base de datos" );
// determinar la clase de Java de columna
try {
String nombreClase = metaDatos.getColumnClassName( columna + 1 );
// devolver objeto Class que representa a nombreClase
return Class.forName( nombreClase );
}
// atrapar excepciones SQLException y ClassNotFoundException
catch ( Exception excepcion ) {
excepcion.printStackTrace();
}
// si ocurren problemas arriba, suponer que es tipo Object
return Object.class;
}
// obtener el número de columnas en el objeto ResultSet
public int getColumnCount() throws IllegalStateException {
// asegurar que la conexión a la base de datos esté disponible
if ( !conectadoALaBaseDeDatos )
throw new IllegalStateException( "No hay conexion a la base de datos" );
// determinar el número de columnas
try {
return metaDatos.getColumnCount();
}
// atrapar excepciones SQLException e imprimir mensaje de error
catch ( SQLException excepcionSQL ) {
excepcionSQL.printStackTrace();
}
// si ocurren problemas arriba, devolver 0 para el número de columnas
return 0;
}
// obtener el nombre de una columna específica en el objeto ResultSet
public String getColumnName( int columna ) throws IllegalStateException {
// asegurar que la conexión a la base de datos esté disponible
if ( !conectadoALaBaseDeDatos )
throw new IllegalStateException( "No hay conexion a la base de datos" );
// determinar el nombre de la columna
try {
return metaDatos.getColumnName( columna + 1 );
}
// atrapar excepciones SQLException e imprimir mensaje de error
catch ( SQLException excepcionSQL ) {
excepcionSQL.printStackTrace();
}
// si hay problemas, devolver cadena vacía para el nombre de la columna
return "";
}
// devolver el número de filas en el objeto ResultSet
public int getRowCount() throws IllegalStateException {
// asegurar que la conexión a la base de datos esté disponible
if ( !conectadoALaBaseDeDatos )
throw new IllegalStateException( "No hay conexion a la base de datos" );
return numeroDeFilas;
}
// obtener el valor en una fila y columna específicas
public Object getValueAt( int fila, int columna ) throws IllegalStateException {
// asegurar que la conexión a la base de datos esté disponible
if ( !conectadoALaBaseDeDatos )
throw new IllegalStateException( "No hay conexion a la base de datos" );
// obtener un valor en una fila y columna específicas del objeto ResultSet
try {
conjuntoResultados.absolute( fila + 1 );
return conjuntoResultados.getObject( columna + 1 );
}
// atrapar excepciones SQLExceptions e imprimir mensaje de error
catch ( SQLException excepcionSQL ) {
excepcionSQL.printStackTrace();
}
// si hay problemas, devolver objeto cadena vacía
return "";
}
// establecer nueva cadena de consulta para la base de datos
public void establecerConsulta( String consulta )throws SQLException,
IllegalStateException {
// asegurar que la conexión a la base de datos esté disponible
if ( !conectadoALaBaseDeDatos )
throw new IllegalStateException( "No hay conexion a la base de datos" );
// especificar consulta y ejecutarla
conjuntoResultados = instruccion.executeQuery( consulta );
// obtener meta datos para el objeto ResultSet
metaDatos = conjuntoResultados.getMetaData();
// determinar el número de filas en el objeto ResultSet
conjuntoResultados.last(); // mover a la última fila
numeroDeFilas = conjuntoResultados.getRow(); // obtener número de fila
// notificar al objeto JTable que el modelo ha cambiado
fireTableStructureChanged();
}
// cerrar objetos Statement y Connection
public void desconectarDeLaBaseDeDatos() {
// cerrar objetos Statement y Connection
try {
instruccion.close();
conexion.close();
}
// atrapar excepciones SQLException e imprimir mensaje de error
catch ( SQLException excepcionSQL ) {
excepcionSQL.printStackTrace();
}
// actualizar estado de conexión a la base de datos
finally {
conectadoALaBaseDeDatos = false;
}
}
} // fin de la clase ResultSetTableModel
Cosas por explicar el en código anterior:
 Si tienes dudas respecto a las operaciones hechas con el API de JDBC significa que debes leer esto
primero: Ejemplo Programación con JDBC
 public Class getColumnClass(); con este método obtendremos el tipo de dato de la columna
(Integer, String, Float, etc).
 public int getColumnCount(); este método devuelve el número de columnas que tendrá la tabla.
 public String getColumnName(int x); devuelve el nombre de la columna X de la tabla.
 public int getRowCount(); este método devuelve el número de filas que tendrá la tabla.
 public Object getValueAt(int f, int c); asigna a la tabla el valor de la celda que se encuentra en la
fila f y en la columna c.
 fireTableStructureChanged(); esto le indica al objeto AbstractTableModel que la estructura de la
tabla ha cambiado.
Ahora el código del frame que contiene la tabla:
import java.awt.*;
import java.awt.event.*;
import java.sql.*;
import java.util.*;
import javax.swing.*;
import javax.swing.table.*;
public class MostrarResultadosConsulta extends JFrame {
// controlador JDBC y URL de la base de datos
static final String CONTROLADOR_JDBC = "com.mysql.jdbc.Driver";
static final String URL_BASEDEDATOS =
"jdbc:mysql://localhost/ejemplo?user=root&amp;amp;password=";
// la consulta predeterminada recupera todos los datos de la tabla autores
static final String CONSULTA_PREDETERMINADA = "SELECT * FROM datos";
private ModeloTablaResultados modeloTabla;
private JTextArea areaConsulta;
// crear objeto ModeloTablaResultados y GUI
public MostrarResultadosConsulta() {
super( "Mostrando resultados de la consulta" );
// crear objeto ModeloTablaResultados y mostrar tabla de la base de datos
try {
// crear objeto TableModel para los resultados del a consulta SELECT *
FROM autores
modeloTabla = new ModeloTablaResultados( CONTROLADOR_JDBC,
URL_BASEDEDATOS,
CONSULTA_PREDETERMINADA );
JTable tablaResultados = new JTable(modeloTabla);

getContentPane().setLayout(new BorderLayout());
getContentPane().add( new JScrollPane(tablaResultados) ,
BorderLayout.CENTER );
// establecer tamaño de ventana y mostrarla en pantalla
setSize( 500, 250 );
setVisible( true );
} // fin de bloque try
// atrapar la excepción ClassNotFoundException lanzada por el
// objeto ModeloTablaResultados si no se encuentra el controlador de la
base de datos
catch ( ClassNotFoundException claseNoEncontrada ) {
JOptionPane.showMessageDialog( null,
"No se encontro el controlador de la base de datos", "No se
encontro el controlador",
JOptionPane.ERROR_MESSAGE );
System.exit( 1 ); // terminar la aplicación
} // fin de bloque catch
// atrapar la excepción SQLException lanzada por el objeto
ModeloTablaResultados
// si ocurren problemas al establecer la conexión a la base de datos
// y realizar la consulta en la misma
catch ( SQLException excepcionSQL ) {
JOptionPane.showMessageDialog( null, excepcionSQL.getMessage(),
"Error en la base de datos", JOptionPane.ERROR_MESSAGE );
// asegurar que la conexión a la base de datos esté cerrada
modeloTabla.desconectarDeLaBaseDeDatos();
System.exit( 1 ); // terminar la aplicación
}
// desechar la ventana cuando el usuario salga de la aplicación
// (esta opción sobrescribe a la opción predeterminada de HIDE_ON_CLOSE)
setDefaultCloseOperation( DISPOSE_ON_CLOSE );
// asegurar que la conexión a la base de datos esté cerrada cuando el
usuario salga de la aplicación
addWindowListener(
new WindowAdapter() {
// desconectarse de la base de datos y salir cuando se haya cerrado la
ventana
public void windowClosed( WindowEvent evento ) {
modeloTabla.desconectarDeLaBaseDeDatos();
System.exit( 0 );
}
}
);
} // fin del constructor de MostrarResultadosConsulta
// ejecutar la aplicación
public static void main( String args[] ) {
JFrame.setDefaultLookAndFeelDecorated(true);
new MostrarResultadosConsulta();
}
} // fin de la clase MostrarResultadosConsulta
Fuente: http://casidiablo.net/consultar-base-datos-java-mostrar-resultados-jtable/

Limitar la cantidad de caracteres en un JTextField


Para empezar debo poner que estoy trabajando en NetBeans, bueno, lo mismo del título...
Lo que quiero hacer es que una caja de texto (JTextField) no me permita colocar más de un caracter, lo
que he logrado hacer es validar eso pero recién cuando se presenta algún evento:
Ejemplo:
Código:
if(JTextField.getText().length() != 1)
//aca la excepción
Else
//aca sigue todo normal
Pero yo quisiera que no se pudiera colocar más de un caracter, sin necesidad de hacer válido algun
evento, he buscado en las propiedades del mismo JTextField, pero sin encontrar nada que me ayude.
Espero haberme hecho entender y que alguien pueda ayudarme.
En mi caso uso:
Código:
TextField (nombre de variable)=new TextField ("lo que quieres que vaya en el
campo", 25);
Y luego mas abajo donde quieras ponerlo le das un: add(nombre de la variable)
Donde el 25 es la cantidad de caracteres permitidos, asi lo manejo yo, tambien en NetBeans.
Pues yo soy mas applets que programas a consola y a nivel maquina, pero si puedo ayudarte.
En tu if has probado poner que si es mas largo haga focus en el siguiente campo o pierda focus?
tambien puede ser otra forma con jTextField lo que he hecho hasta el momento es algo asi (me da
flojera abrir el netbeans, pero lo se mas o menos de memoria):
Código:
txt1.requestFocus();
} else if(txt1.getText().toLowerCase().length() != 1{
lblMensaje.setText("ingrese solo un caracter");
txt1.setText("");
txt1.requestFocus();
} else {
//YA ACA TODO COMO DEBE FUNCIONAR CON UN CARACTER INGRESADO
}
Fuente: http://forospamloco.net/limitar-la-cantidad-de-caracteres-en-un-jtextfield-t193.html

Hay alguna función en Java / Netbeans que me devuelva el valor ASCII de un caracter?
char c = 'A';
int ascii = (int) c;
Fuente: http://mx.answers.yahoo.com/question/index?qid=20091118071319AA4XRtW

Obtener los códigos ASCII de una cadena de texto


En este ejemplo vamos a ver como obtenemos los códigos ASCII de una cadena de texto con Java. Para
ello recorreremos los caracteres de la cadena e iremos obteniendo el código. Para ello nos apoyamos en
el método.codePointAt().
El método .codePointAt() devuelve el código ASCII de un carácter en concreto. El carácter será el que
coincida con el índice que se pasa como parámetro al método.
Empezamos definiendo la cadena:
String sCadena = "Esto es una cadena de texto";
Ahora empezamos recorriendo la cadena, para ello nos apoyamos en un bucle for y en el método
.length(), el cual nos ayuda a conocer el tamaño de la cadena. En el interior del bucle, y apoyándonos
en el elemento de interacción vamos obteniendo el código ASCII de los caracteres con el
método.codePointAt()
for (int x=0;x<sCadena.length();x++)
System.out.println(sCadena.charAt(x) + " = " + sCadena.codePointAt(x));;
Vemos que utilizamos el método.charAt() para sacar el carácter asociado al código ASCII.
package com.lineadecodigo.java.string;

/**
* @file CodigosASCIICadena.java
* @version 1.0
* @author Linea de Codigo (http://lineadecodigo.com)
* @date 4/enero/2010
* @url http://lineadecodigo.com/java/obtener-los-codigos-ascii-de-una-cadena-de-
texto/
* @description Extraer los códigos ASCII de una cadena de texto
*/
public class CodigosASCIICadena {
public static void main(String[] args) {
String sCadena = "Esto es una cadena de texto";

for (int x=0;x<sCadena.length();x++)


System.out.println(sCadena.charAt(x) + " = " +
sCadena.codePointAt(x));
}
}
Fuente: http://cucutaloco.es.tl/Obtener-los-c%F3digos-ASCII-de-una-cadena-de-texto.htm

Obtener codigo ascii de un String


String cadena = "hola";
System.out.println((int) cadena.charAt(0));
//Lo de arriba devuelve tu 104...

int c = 0;
for (int i = 0; i < cadena.length(); i++) {
c += (int)cadena.charAt(i);
}
System.out.println(c);
Fuente: http://www.forosdelweb.com/f45/obtener-codigo-ascii-string-384813/

Código Ascii
No hace falta ningún método para obtener esto. Debes tener en cuenta que el tipo char es un número de
0 a 255, simplementes debes hacer un casting, algo como:
char a = 'a';
System.out.println((int)a);
Esto te devolverá el código ascii del carácter a.
Fuente: http://www.todoexpertos.com/categorias/tecnologia-e-internet/programacion/java/respuestas/647640/codigo-ascii

Convertir char a String


Lo más fácil, aunque carretero es:
char c='3';
String d = ""+c;
// concatenar un caracter nulo ("") + la variable de tipo char.
Fuente: http://www.forosdelweb.com/f45/convertir-char-string-180106/

Métodos de la clase String


Método Descripción
+ Concatenación (unión de hilera).También permite concatenar una hilera con un dato numérico o
booleano.
EJEMPLO
1-) String cadena = “Universidad " + “ Técnica";
Ahora cadena contendrá: "Universidad Técnica"
Cadena += “ Nacional”;
Ahora cadena contiene Universidad Técnica Nacional
2-) int i = 5;
String resultado = "El valor de i es " + i;
Ahora resultado contiene: “El valor de i es 5”
length( ) Retorna la cantidad de caracteres que tiene la String
EJEMPLO
1-) String cadena = “Universidad Técnica”;
int a = cadena.length();
La variable “a” contendrá 19
int indexOf(String ó char) Retorna el índice o posición donde aparece por primera vez la String o
char
que se recibe como parámetro, o un -1 si no la encuentra
EJEMPLO
1-) String cadena = "San Jose";
int posicion = cadena.indexOf("Jose" );
Ahora posición contiene un 4
int a = cadena.indexOf(‘o’);
Ahora la variable a contiene un 5
Recuerde que la primera posición es cero.
String replace (char viejoChar, char nuevoChar) Remplaza en la hilera que invoca el método, el
viejoChar por el nuevoChar. Se utiliza para reemplazar caracteres
EJEMPLO
1-) String hilera, cadena = “mamá";
hilera = cadena.replace(‘m’,’p’ );
Ahora hilera contiene “papá” y cadena continúa teniendo “mamá”.
String replaceAll (String viejaString, String nuevaString) Remplaza en la hilera que invoca al
método la vieja String por la nueva String. Se utiliza para reemplazar subhileras
EJEMPLO
1-) String cadena = “José Soto";
cadena = cadena.replaceAll(“Soto”,”Solís” );
Ahora cadena contiene “José Solís” ya que se modificó sobre ella misma
String toLowerCase() Convierte todos los caracteres de la hilera a minúscula.
Solo para hileras, no funciona para char.
EJEMPLO
1-) String cadena = "JAVA";
cadena = cadena.toLowerCase();
Ahora cadena contiene “java”
String toUpperCase() Convierte todos los caracteres de la hilera a mayúscula. Solo para hileras, no
funciona para char.
EJEMPLO
1-) String cadena = "java";
cadena = cadena.toUpperCase();
Ahora cadena contiene “JAVA”
boolean equals(String str): Compara la hilera que invoca al método con la del parámetro. Si son
iguales retorna true y si nó, retorna false. Es sensitivo a mayúsculas y minúsculas.
EJEMPLO
1-) String cadena1 = “alajuela", cadena2 = “Alajuela”;
if (cadena1.equals(cadena2)){
out.println(“Son iguales”);
else
out.println(“Son diferentes”);
La impresión será: Son diferentes
boolean equalsIgnoreCase (String str) Compara la hilera que invoca al método con la del parámetro.
Si son iguales retorna true y si nó, retorna false. No es sensitivo a mayúsculas y minúsculas.
EJEMPLO
1-) String cadena1 = “alajuela";
String cadena2 = “Alajuela”;
if (cadena1.equalsIgnoreCase(cadena2)){
out.println(“Son iguales”);
else
out.println(“Son diferentes”);
La impresión será: Son iguales
int compareTo(String str1) Compara 2 cadenas y retorna un valor numérico.:
Cero (o): si ambas cadenas son iguales
Un número < 0 si la primera hilera es menor a la segunda.
Un número > 0 si la primera hilera es mayor a la segunda.
EJEMPLO
String cad1="1234";
String cad2="1334";
valor=cad1.compareTo(cad2);
if(valor==0)ut.println("Son iguales";
else
if (valor<0)
out.println("cad1 menor cad2";
else
out.println("cad1 mayor cad2";
String trim():
Elimina espacios en blanco al principio y al final de la cadena. No elimina los espacios situados entre
las palabras.
EJEMPLO
1-) String cadena = " Programación 1 ";
cadena = cadena.trim();
Ahora cadena contiene “Programación 1”
String substring(int indiceInicial, int indiceFinal) Retorna el segmento de la String entre la posición
‘indiceInicial’ inclusive hasta una posición anterior a ‘indiceFinal’.
EJEMPLO
1-) String cadena = "Desarrollo Orientado a Objetos";
out.println(cadena.substring(11,20));
Impresión: Orientado
char charAt (int indice) Devuelve el carácter que ocupa la posición indicada por el índice.
EJEMPLO
1-) String cadena = "Polimorfismo";
out.println(cadena.charAt(4));
Impresión : m
2-) char caracter = cadena.charAt(7);
Ahora carácter contiene ‘f’
String.valueOf Convierte valores de una clase a otra. Permite convertir valores que no son de tipo
String a valores de tipo String.
Este método pertenece a la clase String directamente, no hay que utilizar el nombre del objeto creado
(es un método estático).
EJEMPLO
String numero = String.valueOf(1234);
String fecha = String.valueOf(new Date());
Métodos de la clase Carácter
bolean isLetter(char caracter))
Retorna un verdadero si el carácter del parámetro es una letra
EJEMPLO
1-) char caracter;
if (Character.isLetter(caracter))
out.println(caracter +" es una letra";
bolean isDigit(char caracter))
Retorna un verdadero si el carácter del parámetro es un dígito
EJEMPLO
1-) char caracter;
if (Character.isDigit(caracter))
out.println(caracter +" es un dígito";
bolean isUpperCase(char caracter)
Retorna un verdadero si el carácter del parámetro es una letra mayúscula
EJEMPLO
1-) char caracter;
if (Character.isUpperCase(caracter))
out.println(caracter +" es una letra mayúscula";
boolean isLowerCase(char caracter)
Retorna un verdadero si el carácter del parámetro es una letra minúscula
EJEMPLO
1-) char caracter;
if (Character.isLowerCase(caracter))
out.println(caracter +" es una letra minúscula";
Conversiones
int valor = Integer.parseInt(String)// Pasar de String a int
String resultado = Integer.toString(12345) // Pasar de int a String
String resultado = Double.toString(12345.25)// Pasar de double a String
String resultado = Float.toString(12345.70)// Pasar de int a String
String hilera = Character.toString(caracter)//Pasar de caracter a hilera
String numero = String.valueOf(1234);
String fecha = String.valueOf(new Date());
Fuente: http://www.taringa.net/posts/apuntes-y-monografias/7545333/Metodos-de-la-clase-String.html
JTable en Netbeans
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

/*
* NewJFrame3.java
*
* Created on 06/06/2011, 01:34:57 AM
*/

package mariscal.pruebas;

/**
*
* @author Administrador
*/
public class NewJFrame3 extends javax.swing.JFrame {

/** Creates new form NewJFrame3 */


public NewJFrame3() {
initComponents();
jTable1.getColumnModel().getColumn(0).setWidth(25);
jTable1.getColumnModel().getColumn(0).setMaxWidth(25);
jTable1.getColumnModel().getColumn(0).setMinWidth(20);
jTable1.getColumnModel().getColumn(1).setWidth(155);
jTable1.getColumnModel().getColumn(1).setMaxWidth(155);
jTable1.getColumnModel().getColumn(1).setMinWidth(150);
}

/** This method is called from within the constructor to


* initialize the form.
* WARNING: Do NOT modify this code. The content of this method is
* always regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {

jScrollPane1 = new javax.swing.JScrollPane();


jTable1 = new javax.swing.JTable();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

jTable1.setModel(new javax.swing.table.DefaultTableModel(
new Object [][] {
{null, null, null},
{null, null, null},
{null, null, null},
{null, null, null}
},
new String [] {
"Title 1", "Title 2", "Title 3"
}
));
jTable1.setAutoResizeMode(javax.swing.JTable.AUTO_RESIZE_OFF);
jScrollPane1.setViewportView(jTable1);

javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());


getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 375,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addContainerGap(25, Short.MAX_VALUE))
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 275,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addContainerGap(25, Short.MAX_VALUE))
);

pack();
}// </editor-fold>

/**
* @param args the command line arguments
*/
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new NewJFrame3().setVisible(true);
}
});
}

// Variables declaration - do not modify


private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JTable jTable1;
// End of variables declaration

}
Fuente: http://www.lawebdelprogramador.com/foros/Java/1269731-Ayuda_JTable_en_Netbeans.html

Java: JTable
Las tablas nos permiten tener tabulados de información que se vean organizados y que sean de utilidad
para los clientes. Las tablas son muy utilizadas en programas similares a excel, donde se deben tener
rejillas de información; o en programas de administración donde pueden haber varios productos que
tienen un conjunto de características, o en programas de ventas, donde pueden haber varios vendedores
con número de ventas y con total vendido.
Para agregar una tabla en NetBeans selecciona el icono de tabla de la paleta (que regularmente se
encuentra a la derecha) . Una vez que lo hayas seleccionado agrégalo a la ventana principal. El
JTable utiliza un DataModel para representar sus datos, de la misma manera que varios otros
componentes como JList.
Creando un modelo estático
El modelo nos permite indicarle a la tabla qué información va a contener. Si sólo queremos presentar
información estática (que nunca cambia) al cliente entonces podemos usar un modelo estático, para
hacer esto vamos a hacer click en el atributo model que se encuentra en las propiedades.

Una vez que hicimos click aparecerá una pantalla en la que podemos editar cómo queremos que se vea
la tabla. En esta pantalla podemos seleccionar el núemro de columnas, el nombre de las columnas e
incluso podemos agregar algunos datos.
En la pantalla anterior podemos ver cómo manejar el número de columnas (con los botones de Insert,
Delete o con los botones de +, -) y también podemos ver una rejilla donde podemos poner el título que
aparece en la columna, el tipo de dato que va a guardar y si se puede editar o no.
Con esto podemos crear una tabla estática que siempre va a iniciar con los mismos datos.
Creando un modelo dinámico
La mayoría de las veces un usuario no va a querer una tabla estática (en la que aunque pueda editar los
valores no se muestren los valores que se habían guardado previamente). Es por esto que es necesario
crear un modelo dinámico. Para poder crear un modelo dinámico es necesario implementar la interfaz
TableModel que nos obliga a sobrecargar un gran número de métodos:
 getColumnClass(): Es un método que nos permite saber qué clase tiene guardada cada columna,
esto es para que sean más fáciles de pintar para java.
 getColumnCount(): Es un método que nos permite saber cuántas columnas tiene la tabla.
 getColumnName(): Es un método que nos permite saber el encabezado de la tabla para una cierta
columna.
 getRowCount(): Es un método que nos permite saber cuántas filas tiene la tabla.
 getValueAt(): Es un método que nos devuelve el valor que se encuentra en la posición pasada
como parámetro.
 isCellEditable(): Es un método que nos devuelve verdadero si la celda puede ser modificada, o
falso en caso contrario.
 setValueAt(): Es un método que nos permite cambiar el valor que se encuentra en la posición
pasada como parámetro mediante código (el usuario puede cambiar los datos dependiendo del
método isCellEditable()).
 getValueAt(): Es un método que nos devuelve el valor que está guardado en la celda pasada como
parámetro, este valor va a ser de la clase que indica getColumnClass() para esa columna.
Además de todos los métodos anteriores, la interfaz TableModel tiene un par de métodos para manejar
eventos (como por ejemplo, que el usuario haga click, que edite una celda). Estos métodos involucran
agregar código a nuestra clase que cuando modifique algún valor o que agregue nuevos datos tenga que
disparar eventos. Este código, aunque no es muy complicado, no tendría ninguna utilidad (a menos que
vayamos a escribir una manera de deshacer acciones o algo similar), sin embargo como tenemos que
implementar TableModel tendríamos que implementarlos. Por suerte Java cuenta con un modelo ya
implementado (el que utilizan todas las tablas al ser creadas) que podemos utilizar para no implementar
estos métodos, entonces, en lugar de implmentar la interfaz TableModel vamos a extender la clase
DefaultTableModel que ya implementa la interfaz anterior.

Implementando el modelo dinámico


Normalmente las tablas sólo crecen en una dirección (hacia abajo, aumentando el número de filas). Por
ejemplo, en el reporte de empleados, es probable que contratemos o despidamos empleados, por lo que
vamos a tener que agregar más filas, sin embargo sería raro que apareciera un nuevo atributo que
quisiéramos manejar del empleado (y más raro aún que el cliente pudiera modificar el programa de tal
manera que lo agregue). Entonces, como la mayoría de las tablas crecen en una sola dimensión(sólo
aumenta el número de filas) vamos a implementar un modelo en el que utilizando un ArrayList que
contiene arreglos vamos a manejar el crecimiento de la tabla (el ArrayList puede crecer, pero los
arreglos no).
El ArrayList va a representar las filas de la tabla, y va a contener arreglos, que representan las
columnas.

Primero veamos a crear una clase nueva, que extienda DefaultTableModel.


public class EditableTableModel
extends DefaultTableModel
Nuestro modelo debe tener alguna manera de almacenar los datos (ya vimos cómo vamos a resolver
este problema) y además debe contar con variables de control que nos faciliten la tarea de saber cuál es
el nombre de las columnas, qué tipo de dato guarda cada columna (importante para poder guardar
números o booleanos) y si la columna es editable (la mayoría de las veces este parámetro va a ser
verdadero, pero podrían haber ocasiones en que necesitáramos que fuera falso).
private ArrayList<Object[]> data;
private int numColumns;
private String columnNames[];
private Class classes[];
private boolean editable[];
El constructor que recibe todos los parámetros debe de crear un tabla de datos en blanco y debe de leer
los parámetros que manda el usuario. Como vamos a tener varios constructores que reciban diferente
número de parámetros debemos construir un método que nos permita iniciar el objeto y llamarlo desde
todos los constructores, el método sería algo similar a:
private void initComponents(String columnNames[], Class classes[], boolean
editable[])
throws IllegalArgumentException {
if (columnNames.length != classes.length || classes.length !=
editable.length)
throw new IllegalArgumentException("The arrays passed as parameters
must be of the same size");

data = new ArrayList<Object[]>();

this.numColumns = columnNames.length;
this.columnNames = columnNames;
this.classes = classes;
this.editable = editable;
}

La mayoría de los métodos son simples getters y setters (por ejemplo getRowCount() sólo debe
regresar el tamaño de data con data.size(), getValueAt() sólo debe obtener el valor de la celda
con data.get(row)[col]), por lo que estos métodos no van a ser consultados con más detenimiento.
Sin embargo, para permitir que la tabla pueda crecer debemos crear métodos que nos permitan agregar
o quitar filas. Estos métodos deben agregar o quitar arreglos de objetos de la lista de datos. Es decir:
public void addRow() {
int numRows = data.size();

Object[] row = new Object[numColumns];


data.add(row);

this.fireTableRowsInserted(numRows, numRows+1);
}
Y para remover va a ser muy similar:
@Override
public void removeRow(int row) {
data.remove(row);
this.fireTableRowsDeleted(row, row);
}
En los métodos anteriores no está sucediendo mucho que no sepamos, excepto por los métodos
fireTableRowsInserted() y fireTableRowsDeleted(). Estos dos métodos le indican a la tabla (y la
tabla se encarga de comunicarle a todos los componentes que dependan de ella) que se agregaron o
quitaron filas. Si no hiciéramos esta llamada entonces no veríamos los cambios hasta que
modifiquemos los datos en la lista, que sería cuando la tabla se daría cuenta de que el modelo cambió.
Otro método que quizás sería importante implementar sería uno que nos permitiera agregar filas con
datos, ya que muchas veces vamos a leer los datos de un archivo y vamos a querer construir la tabla.
public void addRow(Object[] row) {
int numRows = data.size();
data.add(row);
this.fireTableRowsInserted(numRows, numRows+1);
}
Quizás también sería prudente crear un constructor que reciba una matriz de datos y de ahí obtenga
todos los datos para crear la tabla.
Usando el modelo
Construir el modelo es un proceso un poco abstracto y muchas veces no sabemos cómo están
sucediendo las cosas sino hasta que lo comenzamos a usar, para poder usar nuestro modelo vamos a
crear una clase de prueba que tenga una ventana con una tabla y dos botones de la siguiente manera:
Vamos a declarar el modelo en la parte de declaraciones globales, para que toda la interfaz gráfica
pueda acceder a ella (esto es conveniente porque así los botones van a poder usarlo directamente, sin
tener que sacarlo de la tabla pero podría considerarse una mala práctica de programación).
private EditableTableModel model;
En el constructor de la ventana vamos a agregar el siguiente código:
public EditableModelTest() {
initComponents();

String columnNames[] = { "Nombre", "Edad", "Telefono" };


Class classes[] = { String.class, Integer.class, String.class };
boolean editable[] = { true, true, true };

model = new EditableTableModel(columnNames, classes, editable);

tblEmployees.setModel(model);
}
Como podemos ver, el código está creando tres arreglos, el primero tiene los nombres de las columnas
(son tres columnas: nombre, edad y teléfono), el segundo arreglo es un arreglo de clases, que nos dice
de qué tipo va a ser cada columna. Podemos utilizar cualquier clase de Java, pero regularmente
queremos utilizar String, Integer, Double, Float o Boolean, que son las clases para las que ya está
creado un renderer y por lo tanto no tenemos que preocuparnos por eso. Fíjate que después del nombre
de la clase ponemos .class para que obtenga la clase. El último arreglo es un arreglo de boolean y nos
dice si las columnas van a ser editables (en la mayoría de los casos sí).
Ahora vamos a implementar el botón para agregar filas:
private void btnAddRowActionPerformed(java.awt.event.ActionEvent evt) {
model.addRow();
}
Como nuestro modelo está bien implementado esto fue sencillísimo, ahora vamos a implementar el
botón que borra las filas seleccionadas:
private void btnRemoveRowActionPerformed(java.awt.event.ActionEvent evt) {
int rows[] = tblEmployees.getSelectedRows();
model.removeRows(rows);
}
Igual de sencillo. Una vez que hayamos hecho todo esto nuestro programa debe permitir agregar y
quitar filas y poner los datos que querramos adentro de las filas.
Guardar datos
Una vez que los usuarios tengan la oportunidad de modificar la tabla van a agregar datos y van a querer
guardar esos datos (imaginen que cada que abran excel tienen que volver a poner todos los datos que
habían puesto la vez anterior). Para guardar los datos vamos a crear un método en el modelo que se
encargue de poner los datos en una matriz (para que sea más fácil de manejar) y después, utilizando
este método vamos a utilizar un par de ciclos para guardar los datos en un archivo.
En el modelo vamos a agregar el siguiente método:
public Object[][] getDataMatrix() {
int numRows = getRowCount();
int numCols = getColumnCount();
Object matrix[][] = new Object[numRows][numCols];

for (int rowIndex = 0; rowIndex < data.size(); rowIndex++) {


Object[] row = data.get(rowIndex);
for (int colIndex = 0; colIndex < row.length; colIndex++) {
Object object = row[colIndex];
matrix[rowIndex][colIndex] = object;
}
}

return matrix;
}
Y dentro de la interfaz gráfica hay que crear un nuevo botón que sea el que guarda y debemos poner el
siguiente código:
private void btnSaveActionPerformed(java.awt.event.ActionEvent evt) {
try {
PrintWriter fileOut = new PrintWriter(new FileWriter("out.csv"));

Object[][] data = model.getDataMatrix();


for (int i = 0; i < data.length; i++) {
fileOut.print(data[i][0]);
for (int j = 1; j < data[i].length; j++) {
Object object = data[i][j];
if (object != null)
fileOut.print("," + object.toString());
else
fileOut.print(",");
}
fileOut.println();
}
fileOut.close();
JOptionPane.showMessageDialog(this, "Datos guardados");
} catch (IOException ex) {
JOptionPane.showMessageDialog(this, "Error al guardar!");
}
}
El método anterior debería mostrar una ventana para seleccionar el archivo y debería de proporcionar
información más relevante en los errores, pero para este ejemplo es suficiente para ver que los datos se
guardan. Una vez que hagamos esto se va a crear un archivo llamado out.csv que puede ser abierto por
excel.

Fuente: http://www.magusoft.net/neotrials/pages/java/jtable.html

Cómo seleccionar una fila de un JTable de Java


A veces nos vemos en la necesidad de seleccionar o resaltar mediante código una fila de un JTable,
ya sea porque necesitamos realizar una búsqueda en la tabla o por cualquier otro motivo. Si el JTable
se encuentra dentro de un JScrollPane, las barras de desplazamiento se deben mover automáticamente
para que se vea la fila que se seleccionó.
Para realizar ésta tarea tenemos el método changeSelection de la clase JTable, el cual cuenta con 4
parámetros: rowIndex, columnIndex, toggle y extend; los dos primeros son dos números enteros que
indican la fila y columna de la celda, mientras que toggle y extend son booleanos que sirven para
indicar si queremos seleccionar una fila, un rango de filas o varias filas.
Para entender mejor el funcionamiento de éste método realizaremos un ejemplo práctico, que consistirá
en realizar la búsqueda de un elemento químico dentro de una tabla. Es decir tendremos una tabla con
cierta cantidad de elementos químicos, para buscar un determinado elemento deberemos introducirlo
dentro del campo de texto respectivo, seguidamente deberemos presionar el botón Buscar e
inmediatamente se resaltará la fila en la cual se encuentra el dato que estábamos buscando (si fue
encontrado).
La interfaz gráfica quedaría como sigue:

Como vemos en la anterior imagen buscamos el elemento "Decano" que se encuentra a lo último de la
tabla, por lo que las barras de desplazamiento se movieron automáticamente hasta hacer visible la fila
donde se encuentra el dato.
Si realizamos una nueva búsqueda, la fila seleccionada anteriormente se deseleccionará y se
seleccionará la fila donde se encuentra el dato de la última búsqueda, como podemos ver en la siguiente
imagen:

El código que va dentro del botón Buscar para realizar este programa es el siguiente:
private void btnBuscarActionPerformed(java.awt.event.ActionEvent evt) {

String ele = txtElemento.getText();

for (int i = 0; i < tbComponentes.getRowCount(); i++) {


if (tbComponentes.getValueAt(i, 1).equals(ele)) {
tbComponentes.changeSelection(i, 1, false, false);
break;
}
}
}
Del anterior código podemos observar en la línea de código 7 que los parámetros toggle y extend del
método changeSelection deben estar en false, para trabajar de la manera que nos propusimos en el
ejemplo: mantener seleccionada solamente una fila por cada búsqueda.
Sin embargo puede haber otras ocasiones en las que se necesita seleccionar más de una fila a la vez,
para ello pueden "jugar" con el código de ejemplo que les estoy pasando, cambiando los valores de los
parámetros toggle y extend para poder visualizar mejor qué "papel juegan" dentro del método.
Les recomiendo leer la documentación oficial del método selectionChange de la clase JTable, donde
encontrarán una breve explicación sobre el mismo y sus parámetros.
No se preocupen que no me olvido de dejarles el código fuente programado en Java utilizando
NetBeans 6.5 para que puedan practicar. Espero les haya sido de utilidad, cualquier acotación o aporte
será bienvenido, hasta la próxima.
Fuente: http://jedicerocool.blogspot.com/2011/01/como-seleccionar-una-fila-de-un-jtable.html

Desplegar datos en jtable (netbeans)


Puedes en un boton o funcion colocar esto:
Código:
Object[][] dtPer;
String[] columNames = {"aleatorio","hora de llegada","hora de entrada","tiempo de
servicio","hora de salida","longitud de la cola"};

dtPer = getDatos();

DefaultTableModel datos = new DefaultTableModel(dtPer,columNames);

tabla.setModel(datos);
y la funcion getDatos() seria:
Código:
public Object [][] getDatos(){
int registros = 0;
try{
PreparedStatement pstm = con.getConnection().prepareStatement("SELECT
count(1) as total FROM horario");
ResultSet res = pstm.executeQuery();
res.next();
registros = res.getInt("total");
res.close();
}catch(SQLException e){
System.out.println(e);
}

Object[][] data = new String[registros][6];


try{
PreparedStatement pstm = con.getConnection().prepareStatement("SELECT " +
" aleatorio, hora_llegada, hora_entrada, tiempo_servicio, hora de
salida, longitud_cola " +
" FROM horario" +
" ORDER BY aleatorio ");
ResultSet res = pstm.executeQuery();
int i = 0;
while(res.next()){
String v1 = res.getString("aleatorio");
String v2 = res.getString("hora_llegada");
String v3 = res.getString("hora_entrada");
String v4 = res.getString("tiempo_servicio");
String v5 = res.getString("hora de salida");
String v6 = res.getString("longitud_cola");
data[i][0] = v1;
data[i][1] = v2;
data[i][2] = v3;
data[i][3] = v4;
data[i][4] = v5;
data[i][5] = v6;
i++;
}
res.close();
}catch(SQLException e){
System.out.println(e);
}
return data;
}
Fuente: http://www.forosdelweb.com/f45/desplegar-datos-jtable-netbeans-860278/

Extraer datos de un jtable a un jtextfield


Para obtener un valor de una tabla existe un metodo getValueAt(fila, columna) un ejemplo seria asi
Integer id = (Integer) tabla.getValueAt(tabla.getSelectedRow(), 0);
luego harias el txt.setText(Integer.toString(id));
Fuente: http://www.forosdelweb.com/f45/auxilio-extraer-datos-jtable-jtextfield-624066/

Customizando un JTable, hágalo usted mismo en 5 simples pasos


El objetivo de este artículo es modificar un JTable para que quede totalmente distinto y mejorado. Si no
les sirve tal como queda al final, no se preocupen ya que pueden sacar buenas ideas de los pasos
intermedios. Empecemos, el objetivo es tranformar:

En…

Paso 1: Modificar el Modelo del JTable JDefaultTableModel


Para no meter mágia y misticismo en esto, vamos a usar directamente el editor de Netbeans. Para ello
seleccionamos la Tabla, y en las propiedades buscamos “model” y le damos a los tres puntitos “…”
Esto va a abrir un editor muy simple, la idea es dejar sin filas la tabla y con solo dos columnas (para
este caso la primera tiene el icono y la segunda tiene el texto).
Deberían configurar algo como esto:
Cuando terminemos ya deberíamos tener nuestra tabla en el siguiente estado:

Paso 2: Que no se muestre la cabecera del JTable


Esto es muy simple de hacer, pero es por la mayoría desconocido. La idea es que la cabecera (Icono –
Texto) esté, pero no se muestre. Para esto seleccionamos el JTable, y buscamos en el cuadro de
propiedades “tableHeader” y le damos a los tres puntitos “…“. La idea aca es poner un null como
parametro del constructor para esto, dentro del editor, seleccionamos en el combo “Código Personal”
y ponemos (null).

Vamos avanzando y seguro ya tenemos algo como ésto:


Paso 3: Creando el Renderizador de las celdas
Este es el “killer step” de la idea, donde la mayoria toma aire, cuenta hasta 10 y tira la compu al patio
no sin antes recordar a la madre de los desarrolladores de sun y desear que les pase un Focus por arriba.
Lo que tenemos que hacer es crear una clase que será utilizada para renderizar las celdas, en ella vamos
a escribir como se va a mostrar cada una y de que forma. Parece sumamente complicado, salvo que
tenemos un As bajo la manga, los jLabel.
El jLabel si tiene algo de bueno es que podemos mostrar un icono/imágen en él, entonces sería buena
idea poder hacer que cada celda del JTable sea un jLabel.
El código de esta clase se los dejo a continuación y comentado, luego hago unas breves acotaciones:
/**
* Descripción: Un renderizador de celdas de un JTable que pone
* un jLabel en cada una de las celdas para que se pueda poner
* un icono/imagen
* @version 1.0
* @author Iuga
* @cambios
* @todo
*/

public class IconCellRenderer extends DefaultTableCellRenderer


{
/**
* Acá redefinimos como se muestra, vemos q ahora lo forzamos a
* trabajar con JLabel, pero si no lo es, por ejemplo un String
* igual lo muestro llamando a Super
*/
public Component getTableCellRendererComponent (JTable table, Object value, boolean
isSelected,boolean hasFocus, int row, int column)
{
if(value instanceof JLabel)
{
JLabel label = (JLabel)value;
label.setOpaque(true);
fillColor(table,label,isSelected);
return label;
}
else
{
return super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row,
column);
}
}

/**
* Este método es para que pinte el fondo del JLabel cuando
* lo seleccionamos para que no quede en blanco, desentonando
* con el resto de las celdas que no son JLabel
*/
public void fillColor(JTable t,JLabel l,boolean isSelected )
{
if(isSelected)
{
l.setBackground(t.getSelectionBackground());
l.setForeground(t.getSelectionForeground());
}
else
{
l.setBackground(t.getBackground());
l.setForeground(t.getForeground());
}
}
Como vemos, redefinimos dos métodos de DefaultTableCellRenderer, el primero indica que y como
vamos a mostrar la celda (y vemos que trabajamos con JLabel) y el segundo método está atento a los
cambios de color para ahcerlo uniforme y que no desentonen los colores.
Ahora lo que resta es pasarle el Rederer al JTable para que use éste en lugar del Default.
jTable1.setDefaultRenderer(Object.class,new IconCellRenderer());
En este punto no tenemos cambios visuales, así que sigamos con el siguiente paso
Paso 4: Llenando el JTable con datos de Prueba
Ahora a probar el producto terminado. Vamos a cargar algunas filas con datos, vamos con los datos de
una sola fila para que se entienda la idea:
Object[] fila = new Object[2];
ImageIcon icon = new
ImageIcon(getClass().getResource("/res/iconos/plantillas/vacio.png"));
fila[0] = new JLabel(icon);
fila[1] = "Presupuesto en Blanco";
Como vemos el primer valor del Array es un JLabel con un icono y sin texto. (Nota: Si, podríamos
haber hecho una sola columna y que muestre icono y texto al mismo tiempo, pero era para mejorar el
ejemplo y demostrar que podemos mezclar JLabels y otros tipos de datos sin complicar el modelo).
Una vez que tenemos los datos solo queda agregarlos al modelo de la tabla:
DefaultTableModel modelo = (DefaultTableModel)jTable1.getModel();
modelo.addRow(fila);

Paso 5: Mejorando la Visual del JTable y la altura de las celdas


Primero tenemos que ajustar, en cada caso, la altura de las celdas de acuerdo al tamaño de los
iconos/imágenes que mostremos, así no nos corta la imágen como en el caso anterior.
// Donde 50 es el tamaño que querramos en la celda según lo q necesitemos
jTable1.setRowHeight(50);
Ahora podemos cambiar un poco el tamaño de la tabla para que quede acorde a los datos y el tamaño
de las celdas. Para esto nuevamente recurrimos a la facilidad que nos da Netbeans y vamos a otro editor
haciendo “click derecho” en la JTable y en “Contenido de la Tabla…” y vamos a la segunda Solapa
“Columnas“, en cada una podemos configurar el tamaño mínimo, sugerido y máximo.
Todo lo bueno tiene fin, y este fue el nuestro, ya con esto tenemos nuestro JTable modificado
completamente y si seguimos bien los pasos deberíamos tener algo como esto:

Lo que sigue es llenar la tabla con datos a nuestro antojo, poner o sacar columnas, simplemente
modificarla a nuestro antojo.
Fuente: http://hackelare.wordpress.com/2010/09/23/customizando-un-jtable-hagalo-usted-mismo-en-
5-simples-pasos-leer-con-la-voz-de-sprayette/

Tablas en netbeans
Muchas veces me han preguntado, oye como se usan las tablas en netbeans? o como puedo hacer
dinámica una tabla en java?, y la mas frecuente como puedo hacer dinámica una tabla con netbeans? la
cual es la misma que la anterior, por lo que decidí escribir cada paso de lo que yo normalmente hago
cuando manejo tablas, no se si sea lo mas correcto, pero a mi me funciona:
Aquí supondré que sabemos usar netbeans hasta el punto en el que se inserta una tabla, es decir cuando
podemos ver algo como esto:
Ya teniendo la tabla creada se pueden modificar sus propiedades de forma gráfica dando click-derecho
sobre la tabla que creamos
Aparecerá un cuadro de dialogo que describe las propiedades de la tabla, en la primera pestaña "modelo
de la tabla" se indica de donde se obtendrán los datos de la tabla, la verdad, de esa pestaña no se casi
nada si embargo si nos pasamos a la pestaña que dice Columnas 1
Podemos ver las propiedades de cada columna 2 en esta parte podemos cambiar el tipo de el valor que
aceptara la tabla, si es editable o si se puede cambiar el tamaño de la celda y por supuesto el nombre de
la columna y los números 3,4,5,6 en la selección de modelo indican la forma en que se podrán
seleccionar las celdas de la tabla; a continuación una descripción de lo que hacen:
3 solo permite la selección de filas
Si se selecciona 4 solo se podrá seleccionar una sola celda
Si se selecciona 5 se podrá seleccionar múltiples celdas, pero estas deberán ser vecinas
Y por ultimo si se selecciona 6 se podrá seleccionar celdas sin importar que sean vecinas o no
Los tipos que se pueden seleccionar en las tablas son los que se muestran en la imagen, lo cual puede
ser útil para recabar datos con formato, en lo personal, no me gusta usar las jtables para recabar datos
porque siempre se tiene un problema al insertar el ultimo dato, pero de igual forma al definir el tipo del
objeto de una columna esta no aceptara que se inserte otro tipo de valor y en adición, al seleccionar
boolean el valor de las columnas cambiaran por un checkbox donde la palomita significa true, y vació
false
Después de cambiarle el formato a la tabla todo lo que quieras, podemos seguir con lo dinámico, ahhh
la pestaña de filas o rows solo permite agregar o quitar renglones en la tabla, pero bueno eso no nos
sirve si lo que queremos es ponerlos dinamicamente.
Esto de formatear la tabla servirá ahora tenemos una tabla que solo acepta ciertos tipos de datos, con
todos los renglones en blanco.
Estas tablas, sin tener que ver con netbeans se manejan de forma diferente de la que muchos pensamos,
la jTable es mas bien una versión gráfica, y sus datos provienen de un TableModel y ese es el que se
necesita saber utilizar bueno, en si el TableModel no, sino un hijo de este, el DefaultTableModel, el
cual permite manipularlo fácilmente. solo necesitamos pues sacarlo de ahí, ya que si revisas el código
que genero el netbeans en la función de initComponents dice algo como
new jtable(new DefaultTableModel{cosas raras de netbeans});
En las cosas raras de netbeans se desarrollan todas las características que seleccionamos gráficamente
para aplicar a la tabla, entonces, después de initComponets sacamos el objeto del modelo de la tabla, lo
casteamos y lo guardamos en un atributo de nuestra clase.
private javax.swing.table.DefaultTableModel modelo;//atributo de nuestra clase
public Inicio() {//este es el constructor de la tabla
initComponents();
modelo = (javax.swing.table.DefaultTableModel)tabla.getModel();//con esta
linea obtenemos el modelo
tabla.setModel(modelo);//con esta instruccion se pueden cambiar las
caracteristicas de la tabla por otro modelo
}
Y con el modelo guardado podemos realizar varias acciones como agregar un renglón, borrar un
renglón, agregar datos, modificarlos, y obtener los valores de la tabla.
//borrar renglón seleccionado
try{
modelo.removeRow(tabla.getSelectedRow());
}catch(Exception e){
javax.swing.JOptionPane.showMessageDialog(this, "Seleccione almenos
una celda","Error",javax.swing.JOptionPane.ERROR_MESSAGE);
}
//insertar renglón con datos
modelo.addRow(new Object[]{23,"Hola",23.5,true});//Los datos del nuevo
renglon de la tabla, se puede insertar un renglon vacio si en lugar de los
datos se pone {}
//modificar datos de la tabla esto se puede hacer directamente desde la tabla, pero
lo haremos con el modelo
modelo.setValueAt("valorNuevo",renglon,columna);
//tomar un valor de la tabla ojo:los valores salen en forma de object por lo que se
necesitan castear
Object variable = modelo.getValueAt(renglon,columna);
Y listo tenemos una tabla dinámica ;)
De cualquier forma dejo el código de ejemplo en mi pagina http://luismy.espaciogratis.info
Fuente: http://faq-netbeans.blogspot.com/2011/01/tablas-en-netbeans.html

JList
Archivos necesarios:
El JList nos permite crear una lista para agregar a nuestras aplicaciones. A diferencia del JComboBox
que puede crecer muy fácilmente, el JList es un poco más difícil de manejar pero nos permite hacer
cosas más interesantes que el JComboBox. También veremos cómo utilizar algunas otras clases que
nos van a permitir manejar un JList de una manera más eficiente por ejemplo para permitir que crezca
de manera dinámica. Podemos utilizar listas para mostrar a los jugadores en un juego de mesa o
también podemos utilizarla para mostrar una lista de contactos.
La clase que incluye este trial es un programa que únicamente incluye un JList con los nombres de los
empleados de una empresa. El programa nos permite contratar más empleados y despedirlos según sea
necesario.

Main.java
¿Cómo utilizar un JList?
Construir un JList
es muy sencillo si
no queremos que
sea dinámico, es
decir: si queremos
que el usuario no
pueda agregar más items. Para hacerlo basta con declarar un arreglo de String y pasarlo como
parámetro al constructor del JList.
Para hacer que el JList tenga una barra
de desplazamiento es necesario utilizar
una clase auxiliar llamada JScrollPane.
Esta clase se va a detallar en algún trial más adelante, pero por el momento se debe de construir como
se ve en la foto.
Es importante notar que el JScrollPane es el que se añade a la forma y no la lista en si. Esto es porque
el JScollPane contiene a la lista.
Para escuchar eventos en una lista
(por ejemplo para saber cuando se
seleccionó un elemento) es necesario
importar un nuevo tipo de escuchador
de eventos. Primero que nada
tenemos que importar la librería:
javax.swing.event.* después la clase
tiene que implementar ListSelection-
Listener y por último tenemos que
hacer un método valueChanged() que
recibe un objeto ListSelectionEvent.
Dentro de este método podemos utilizar la variable ListSelectionEvent para saber cuál fue el JList que
mandó llamar el método mediante el método getSource() que es igual que el que habíamos utilizado
hasta ahora.
Un paso más allá
Una parte importante de las listas es el poder
agregar y eliminar registros. Para hacer esto
necesitamos crear un objeto llamado
DefaultListModel e iniciar el JList con este objeto
en vez de con el arreglo de String como habíamos
visto en la primera parte. Como podemos ver aqui
podemos agregar elementos al DefaultListModel
utilizando el método addElement() que recibe un
String con el elemento a añadir.

Una vez que ya tengamos el DefaultListModel con todos los elementos que queramos es hora de crear
la lista con el constructor que recibe el DefaultListModel. Recuerda que la variable listModel que
estamos utilizando en el código es un objeto tipo DefaultListModel.
Una vez que ya creamos la lista
podemos utilizar nuestro Default-
ListModel para eliminar los eleven-
tos que queramos, si sabemos el ín-
dice en que lugar fueron agregados
(que es la misma posición en la que
aparecen en el JList) con el método
removeElementAt() que recibe úni-
camente un número que es el índice a borrar. También hay un método del JList que nos permite saber
qué elemento está seleccionado. El método getSelectedIndex() nos devuelve el índice del elemento que
esté seleccionado en ese momento.
Entonces, para poder borrar un elemento de un JList podemos utilizar juntos el método para borrar el
registro en un índice y el método que nos devuelve el índice que está actualmente seleccioando, con lo
que podemos borrar el elemento que seleccionó el usuario. Si nuestro JList permite elegir más de un
elemento entonces el método getSelectedIndex() no funciona, para leer un poco más acerca de cómo
manejar listas donde se puedan manejar multiples selecciones consulten la clase Main.java que se les
da al principio.
También es importante saber cómo
guardar los datos de un
DefaultListModel a un archivo.
También hay un método que nos
devuelve que tantos elementos se han
agregado al DefaultListModel llamado
getSize(), este método lo podemos utilizar para hacer un for que guarde desde 0 hasta el tamaño todos
los registros que encuentre, es más sencillo manejar este tipo de guardado en archivos de texto por lo
que les recomiendo que lo hagan así.
Fuente: http://www.magusoft.net/trials/list.html

Hacer que una celda del JTable no sea editable


Si usamos DefaultTableModel las celdas del JTable son editables por defecto. A veces esto no nos
interesa y JTable no tiene métodos para impedirlo. La forma de decidir qué celdas son o no editables
es hacer nuestro propio modelo de datos, nuestro TableModel. La forma sencilla de hacerlo es heredar
de DefaultTableModel y redefinir el método isCellEditable() para que sirva a nuestros propositos
public class MiModelo extends DefaultTableModel
{
public boolean isCellEditable (int row, int column)
{
// Aquí devolvemos true o false según queramos que una celda
// identificada por fila,columna (row,column), sea o no editable
if (column == 3)
return true;
return false;
}
}
En este ejemplo, hemos creado nuestro propio modelo de datos que hace que la columna 4 (los índices
empiezan en cero) de la tabla sea editable y el resto no. Ahora simplemente instanciamos el JTable
usando este modelo y rellenamos los datos igual que antes
MiModelo modelo = new MiModelo();
JTable tabla = new JTable(modelo);
Fuente: http://foro.chuidiang.com/java-j2se/jtable-no-editable/

jTable y su "Modelo"
Continuando con las tablas en Java, vamos a ver como crear las tablas y manejarlas, en la entrada de
"Tablas Swing" explico un poco del tema, pero en esta entrada explicare mas del tema y date más tips.
Para evitarnos problemas utilizaremos un "Modelo" para nuestra tabla, ¿como funciona esto?, la verdad
que explicarlo es medio enredado, así que mejor una imagen:

Básicamente es crear la tabla, cargarle el modelo y agregar la data, esto se hace con la finalidad de
editar el modelo que es mas fexible para utilizar solo la tabla como una especie de panel el cual
contendra los datos, en realidad lo que editamos es el modelo, en otras palabras es como hacer galletas,
el molde es nuestro modelo, la data es la masa y la galleta es la tabla.
Quedando claros en esto (pienso yo) vamos con algunos truquillos importantes e imprecindibles. Para
crear el modelo y agregarselo a la tabla.
DefaultTableModel modelo = new DefaultTableModel();
JTable tabla = new JTable(modelo);
Agregar columnas
modelo.addColumn("columna");
Agregar datos
Object [] filas = new Object[2];
filas[0] = "dato columna 1";
filas[1] = "dato columna 2";
modelo.addRow ( filas );
Borrar datos
modelo.removeRow(FILA);
Modificar
modelo.setValueAt ("nuevo dato", fila, columna);
Obtener el valor donde se hace click.
public void mouseClicked(MouseEvent e) {
int fila = tabla.rowAtPoint(evt.getPoint());
int columna = tabla.columnAtPoint(evt.getPoint());
if ((fila > -1) && (columna > -1))
System.out.println(modelo.getValueAt(fila,columna));
}
Hacer que la celda no se edite
public boolean isCellEditable (int row, int column){
if (column == 3)
return true;
return false;
}
Cambiar el tipo de dato
public Class getColumnClass(int columna) {
if (columna == 0) return Boolean.class;
if (columna == 1) return Integer.class;
return Object.class;
}
Agregarle un Scroll
JTable tabla = new JTable();
JScrollPane scroll = new JScrollPane(tabla);
JTable tabla = new JTable();
JScrollPane scroll = new JScrollPane();
scroll.setViewportView(tabla);
Fuente: http://carlitoxenlaweb.blogspot.com/2010/05/jtable-y-su-modelo.html

JAVA: Celdas no editables


package cunloganthorium.*;

import javax.swing.table.DefaultTableModel;

/**
*
* @author whyem
*/
public class CustomDefaultTableModel extends DefaultTableModel{
/**
* Sobreescribe el método isCellEditable de DefaultTableModel,
* para que las celdas no sean editables.
*
* @param row
* @param column
* @return
*/
@Override
public boolean isCellEditable (int row, int column)
{
return false;
}

}
Fuente: http://bufferdecodigo.blogspot.com/2011/11/java-celdas-no-editables.html

Pasar datos en Jframes


//agrégale "getters" a la clase Segundario, por ejemplo:

public class Segundario {

// aquí el código que ya tenías

public String getNombre () {


return jNombre.getText ();
}
}

// muestra en forma modal el jframe secundario

Segundario nf = new Segundario();


ff.setModal (true);
nf.setVisible(true);
// aquí ya puedes extraer los datos
String nombre = nf.getNombre ();
....
// aquí destruyes el jframe secundario
nf.removeAll ();
nf.dispose ();
Fuente: http://es.answers.yahoo.com/question/index?qid=20090929081101AAblmTu

¿Cómo hacer un JTable no editable?


Puedes utilizar un TableModel.
Definir una clase como esta:
public class MyModel extends AbstractTableModel {
//not necessary
}
JTable myTable = new JTable();
myTable.setModel(new MyModel());
Puedes reemplazar el método isCellEditable y poner en práctica lo que quieras por ejemplo:
//instance table model
DefaultTableModel tableModel = new DefaultTableModel() {
@Override
public boolean isCellEditable(int row, int column) {
//all cells false return false;
}
};
table.setModel(tableModel);
O
//instance table model
DefaultTableModel tableModel = new DefaultTableModel() {
@Override
public boolean isCellEditable(int row, int column) {
//Only the third column
return column==3;
}
};
table.setModel(tableModel);
Fuente: http://stackoverflow.com/questions/1990817/how-to-make-a-jtable-non-editable

Pasar datos de un registro de un JTable a un JDialog en sus respectivos campos


Partiendo de que su JTable se llame JTPrueba, el JDialog donde esta el JTable donde se va a capturar
los clicks se llame JDPrincipal y que el JDialog donde esten los JtextField a rellenar se llame
JDialogModificar; se debe hacer lo siguiente.
Se le debe declarar un capturador de eventos al JTable para que detecte los clicks y su respectiva
posicion(tanto fila como columna);
JTPruebas.addMouseListener(new ListenerJTable(this,nuevoJDialogSecundario));
En este ejemplo yo estoy asignandole un nuevo objeto de tipo ListenerJTable donde ListenerJTable es
otra clase que implementa la interfas MouseListener. a continuacion un ejemplo de una clase
(ListenerJTable) implementando la interfaz Mouselistener para capturar el evento del click(cada vez
que se de un click en el JTable se ejecutara el metodo mouseClicked.
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;

public class ListenerJTable implements MouseListener {


intfila;
intcolumna;
JDialog JDPrincipal;
JDialog JDialogModificar;

private ListenerJTable(JDialog JDprincipal, JDialog JDialogModificar) {


//supuestamente en JDPrincipal esta el JTPruebas.
this.JDPrincipal= JDprincipal;
this.JDialogModificar=JDialogModificar;
}

public void mouseClicked(MouseEvent e) {


fila=JDPrincipal.getJTPruebas().rowAtPoint(e.getPoint());
columna=JDPrincipal.getJTPruebas().columnAtPoint(e.getPoint());
// en este caso ya capturamos las fila y la columna donde se dio clic
System.out.println("Fila " + fila + " columna" + columna );
//teniendo eso solo nos quedaria por actualizar el JDialog donde estan
//todos los campos //de la siguiente forma....
//No olvide que el que guarda el contenido del JTable es el DefaultTableModel
//por lo tanto necesitamos obtenerlo.
DefaultTableModel dft = (DefaultTableModel)
JDPrincipal.getJTPruebas().getModel();
//Ahora se empezarian a rellenar los campos por medio de los metodos
//Set y leyendo cada valor del DefaultTableModel con el metodo getValueAt(int
//fila, int Columna);
JDialogModificar.setNombre(dft.getValueAt(fila,0));
JDialogModificar.setApellido(dft.getValueAt(fila,1));
JDialogModificar.setTel(dft.getValueAt(fila,2));
//Siendo esas 0,1,2 las columnas del jtable correspondientes a cada valor
//requerido,por ejemplo siendo la columna 0 la que tiene todos los nombres.
}
}

Lo que depronto faltaria seria implementar un if que descarte cuando detecte el click en la fila y
columna -1 que ese quiere decir que no ha seleccionado nada pero dio click en algun borde del JTable
Espero haber sido claro...
Fuente: http://comunidad.dragonjar.org/f201/pasar-datos-de-un-registro-de-un-jtable-un-jdialog-en-sus-respectivos-campos-10296/

Pasar Datos de un jDialog a otro jDialog


Tienes que instanciar el jdialog_secundario desde el jdialog_principal y pasar los parámetros que
deseas obtener en el jdialog_secundario y ya estando en el jdialog_secundario lo atrapas por su método
constructor.
Algo asi:
Código PHP:
public class jdialog_principal {
private button pasar_datosAction {
String nombre="David";
Int edad=20;
jdialog_secundario ref=new jdialog_secundario(null,true,nombre,edad);
}
...
}
public class jdialog_secundario {
private String nombre;
private int edad;
public jdialog_secundario(...,...,String nombre,int edad); {
this.nombre=nombre;//Aquí la variable this.nombre es David.
this.edad=edad;//Aquí la variable this.edad es 20.
//Una vez capturado las variables puedes mostrarlo en JTextField.
}
...
}
Fuente: http://forodejava.com/showthread.php/631-Pasar-Datos-de-un-jDialog-a-otro-jDialog

Java - Diferencia entre JFrame Form y JDialog Form


Para llamar a un JDialog Form: new menu.pPrincipal(new java.awt.Frame(),true).setVisible(true);
Para llamar a un JFrame Form: new menu.pPrincipal().setVisible(true);
Fuente: http://www.lawebdelprogramador.com/foros/Java/967634-Diferencia_entre_JFrame_Form_y_JDialog_Form.html

JFormattedTextField y MaskFormatter
Si bien dentro de las aplicaciones bajo swing (java) podemos utilizar un componente como el
JTextField para capturar una entrada de texto. Pero que sucede si esta entrada debe seguir un formato
específico? o posee un tamaño obligatorio al cual debe llegar? Claros ejemplos de esto son al querer
capturar un número de telefóno o un número de cédula (DNI).
Para ello se puede utilizar un componente conocido como JFormattedTextField. Al que podemos
indicar el formato de nuestra entrada. Lo que tenemos que hacer es crear una instancia de la Clase
MaskFormatter en base a un patrón y este enviarlo en el constructor del JFormattedTextField.
MaskFormatter patron = new MaskFormatter(“#########-#”);
JFormattedTextField campoEntrada = new JFormattedTextField(patron);
y listo nuestra entrada será validada, en este caso solo para números.
Si utilizamos NetBeans, deberemos colocar una instancia de la clase AbstractFormatterFactory en la
propiedad FormatterFactory del elemento gráfico.
new javax.swing.JFormattedTextField.AbstractFormatterFactory(){
public javax.swing.JFormattedTextField.AbstractFormatter
getFormatter(javax.swing.JFormattedTextField tf) {
try {
return new javax.swing.text.MaskFormatter("########.##");
} catch(java.text.ParseException pe) {
pe.printStackTrace();
}
return null;
}
}
Resulta muy útil en varias ocaciones.
Fuente: http://qmarqeva.wordpress.com/2009/06/15/jformattedtextfield-y-maskformatter/

Ejemplos de uso del JFormattedTextField


El JFormattedTextField es un componente java un paso más evolucionado que un JTextField
normalito. El JTextField permite al usuario meter texto. Cuando desde nuestro código le pedimos el
contenido, nos devuelve el texto introducido por el usuario como String. Cuando desde código le
decimos lo que queremos que muestre, debemos pasarle un String. El JTextField, además, no hace
ningún tipo de comprobación sobre el texto.
El JFormattedTextField da un paso más allá. Aunque el usuario mete un texto, el
JFormattedTextField lo convierte a la clase que nosotros queramos (un Integer, Float, Date o
incluso una clase nuestra propia). Cuando queramos pasarle algo, le podemos pasar directamente
cualquiera de estas clases y él se encarga de la conversión a texto para mostrar.
JFormattedTextField para editar Integer
Para editar cualquier tipo básico de java, estilo Integer, Float, Double, Date, etc, basta con llamar al
método setValue() del JFormattedTextField pasándole uno de estos tipos de datos, o bien pasárselo
en el constructor.
Por ejemplo, para Integer, nos bastaría con cualquiera de los dos casos siguientes:
JFormattedTextField textField1 = new JFormattedTextField (new Integer(3));
// o bien ....
JFormattedTextField textField2 = new JFormattedTextField ();
textField2.setValue(new Integer(3));
Con esto ya tenemos un editor que nos permite recoger Integer directamente cuando el usuario lo edite
Integer valor = textField1.getValue();
Supongamos que el usuario escribe algo en el JFormattedTextField y l uego pincha con el ratón en
otros sitio (se dice que el JFormattedTextField pierde el foco), por ejemplo, en un botón de "Aceptar"
los cambios introducidos. En el momento que el JFormattedTextField pierde el foco, comprueba el
texto escrito por el usuario. Si es correcto, lo guarda de forma que el método getValue() nos devolverá
el nuevo valor. Si es incorrecto, pondrá automáticamente el último valor bueno, deshaciendo el cambio
hecho por el usuario.
Si no te interesa cambiar ese comportamiento, puedes pasar al siguiente punto. Si quieres cambiarlo,
sigue leyendo.
Este comportamiento puede cambiarse con el método setFocusLostBehavior(), al que podemos pasar
varios valores:
 JFormattedTextField.COMMIT. Si el texto introducido es correcto, se guarda para devolverlo
cuando se haga getValue(). Si es incorrecto, no se hace nada, el texto en pantalla queda como esta, o
sea, mal. getValue() nos devolverá el último valor correcto, independientemente de lo que se
muestre en pantalla.
 JFormattedTextField.REVERT. Cuando hacemos click en otro sitio, el editor vuelve
automáticamete a su último valor bueno, descartando todas nuestras ediciones, sean correctas o no.
Para que esta opción tenga sentido, debemos llamar desde código al método commitEdit() sin que el
JFormattedTextField pierda el foco, por ejemplo, cuando se pulsa <intro> sobre el editor, validando
así los cambios realizados.
 JFormattedTextField.COMMIT_OR_REVERT. Esta es la opción por defecto y la más útil. Si el
texto introducido es incorrecto, se vuelve automáticamente al último valor bueno conocido. Si el
texto no es válido, se muestra el último valor bueno conocido.<>
 JFormattedTextField.PERSIST. Esta opción no hace nada con el texto introducido,
independientemente de que esté bien o mal. getValue() siempre devolverá el último valor bueno
conocido. Para que el editor recoga el nuevo valor, debemos llamar a commitEdit() previamente.
Puedes ver estos cuatro casos funcionando en unos applets de ejemplo. También puedes descargarte los
fuentes de los mismos.
JFormattedTextField para editar nuestra propia clase
Podemos usar la forma indicada en el punto anterior con cualquier clase básica de java (Integer, Float,
Date, etc). Si queremos que el JFormattedTextField nos acepte y devuelva una clase nuestra propia,
debemos hacer un poco más de código.
Vamos primero a definir nuestra propia clase. Por ejemplo, una clase Mayuscula que representa una
cadena de texto siempre en mayúsculas. Le ponemos un constructor que admita un String para
convertirlo a mayúsculas y un método toString() para obtener la cadena en mayúsculas. La clase puede
ser como esta
/**Representa una cadena en mayúsculas */
class Mayusculas
{
/** La cadena en mayúsculas */
private String valor="";

/** Pasa a mayúsculas la cadena que se le pasa y la guarda */


public Mayusculas(String cadena)
{
valor = cadena.toUpperCase();
}

/** Devuelve la cadena en mayúsculas */


public String toString()
{
return valor;
}
}
Para que el JFormattedTextField nos acepte esto en sus métodos setValue() y getValue(), tiene que
saber la forma de convertir esto a un texto que se muestre en el editor y la forma de convertir el texto
recogido del editor y convertirlo a esta clase.
Las clases que realizan este tipo de conversiones para el JFormattedTextField heredan de
JFormattedTextField.AbstractFormatter, una clase interna del JFormattedTextField. Si queremos
usar nuestra clase Mayuscula, debemos hacer una clase hija de JFormattedTextField.Abstract-
Formatter y definir los dos métodos abstractos que tiene que son, precisamente, los de convertir de
clase a String y de String a clase.
/** Clase que sabe convertir Mayuscula a texto para presentar en el editor y
de texto recogido del editor obtener una clase Mayúscula
*/class Formateador extends JFormattedTextField.AbstractFormatter
{
/** Se le pasa el texto del editor y debe devolver una clase Mayuscula */
public Object stringToValue(String text) throws ParseException
{
return new Mayusculas(text);
}

/** Se le pasa una clase Mayuscula o null y devuelve la cadena para poner en
el editor */
public String valueToString(Object value) throws ParseException
{
if (value==null)
return ("");
return value.toString();
}
}
Bien, ya tenemos todo lo necesario construido. Ahora solo hay que instanciar el JFormattedTextField
pasándole en el constructor nuestra clase Formateador y con setValue() darle un primer valor válido
para evitar problemas.
JFormattedTextField textField = new JFormattedTextField(new Formateador());
textField.setValue(new Mayusculas("hola"));
El método getValue() nos devolverá una clase Mayusculas y a través de setValue() podemos pasarle
una clase Mayusculas sin problemas.
Puedes ver un Applet con este editor funcionando y descargarte sus fuentes.
JFormattedTextField con máscara para Float
Existen varios JFormattedTextField.AbstractFormatter además de los que podamos hacernos
nosotros. Uno de los más conocidos es el MaskFormatter. Este formateador restringe el texto válido
incluso mientras lo estamos tecleando. Al instanciar el MaskFormatter le damos un "patrón" sobre
cómo queremos que sea el texto. Una vez configurado todo, el usuario no podrá escribir en el
FormattedTextField nada que se salga de ese "patrón". Veamos con un ejemplo qué quiero decir.
Supongamos que quiero un editor que me permita escribir un número con dos cifras enteras y dos
decimales. No queremos que el usuario escriba algo que no sea un número y no queremos que escriba
ni más ni menos de las cifras de las indicadas. El editor debe admitir y devolvernos con setValue() y
getValue() un Float.
Para conseguir esto, basta instanciar un MaskFormatter y pasárselo al JFormattedTextField en el
constructor. Para evitar problemas, le damos un valor válido inicial válido al editor. El new
MaskFormatter lanza una excepción, así que debemos capturarla.
try
{
/* El "patrón" para el editor. Las # representan cifras. En la API puedes ver
más. Ojo con el punto decimal, según el idioma puede ser una coma.*/
MaskFormatter mascara = new MaskFormatter("##.##");
// Se construye el JFormattedTextField pasándole la máscara
JFormattedTextField textField = new JFormattedTextField(mascara);
// Se da un valor inicial válido para evitar problemas
textField.setValue(new Float("12.34"));
}
catch (...)
Ya está listo. Nuestro editor sólo admite números de dos cifras enteras y dos decimales y no nos deja
escribir otra cosa. Los métodos getValue() y setValue() devuelven y admiten Floats.
Podemos usar el MaskFormatter con cualquier tipo de dato que:
 Tenga un constructor con String. El MaskFormatter para construir el dato llamará al constructor
pasándole el String recogido en el JFormattedTextField.
 El método toString() devuelva algo que cuadre con el patrón que hemos puesto.

JFormattedTextField con máscara para nuestra propia clase.


El MaskFormatter nos vale también para la clase Date. El problema es que debemos restringirnos a
los formatos de texto que entiende Date en su constructor con String, que no son precisamente bonitos
ni cómodos para introducir un usuario.
Si queremos usar MaskFormatter con un formato distinto para Date o bien usar MaskFormatter con
una clase nuestra, debemos hacer algo parecido a lo que hicimos para poder usar nuestras propias
clases, pero heredando de MaskFormatter en vez de heredar de JFormattedTextField.Abstract-
Formatter.
Por ejemplo, supongamos que queremos un editor de Fecha hora en este formato "dd/mm/yy
hh:mm:ss" y que no queremos que nos dejen escribir nada incorrecto.
Tenemos que hacernos nuestro propio MaskFormatter heredando del original y redefiniendo los
métodos de conversion de Date a String y de String a Date
/** Mascara para fecha/hora a nuestro gusto */
class FormatoFecha extends MaskFormatter
{
/** Se construye con el patrón deseado */
public FormatoFecha() throws ParseException
{
// Las # son cifras y representa "dd/mm/yy hh:mm:ss"
super ("##/##/## ##:##:##");
}

/** Una clase adecuada para convertir Date a String y viceversa de forma
cómoda. Puedes ver cómo se hace el patrón "dd/MM/yy kk:mm:ss" en la API.
El patrón que pongamos aquí debe cuadrar correctamente con la máscara que
hemos puesto en el constructor */
private SimpleDateFormat formato = new SimpleDateFormat("dd/MM/yy kk:mm:ss");

/** Convierte el texto del editor en un Date */


public Object stringToValue(String text) throws ParseException
{
return formato.parseObject(text);
}

/** Redibe un Date o null y debe convertirlo a texto que cumpla el patrón
indicado anteriormente */
public String valueToString(Object value) throws ParseException
{
if (value instanceof Date)
return formato.format((Date)value);
return formato.format(new Date());
}
}
Ya está todo listo. Simplemente instanciamos el JFormattedTextField pasándole nuestro
FormatoFecha y le damos un valor inicial válido para evitar problemas. Como nuestro constructor
lanza una excepción, hay que meterlo todo en un try-catch.
try
{
JFormattedTextField textField = new JFormattedTextField(new FormatoFecha());
textField.setValue(new Date());
}
catch (...)
El InternationalMaskFormatter
Una AbstractFormatter interesante es el InternationalMaskForamatter. Además de otras muchas
cosas, nos permite editar un número sin que se salga de un rango determinado. Por ejemplo, un entero
entre 10 y 100. Este AbstractFormatter permite escribir cosas incorrectas, pero al final sólo admite
números entre el rango indicado.
Su uso es sencillo, basta algo como esto
InternationalFormatter formato = new InternationalFormatter();
formato.setMaximum(new Integer(100));
formato.setMinimum(new Integer(10));
JFormattedTextField textField = new JFormattedTextField(formato);
textField.setValue(new Integer(90));
Fuente: http://www.chuidiang.com/java/ejemplos/JFormattedTextField/EjemplosJFormattedTextField.php

Verificar si la tecla pulsada no es un digito


Texto. AddKeyListener(new KeyAdapter() {
public void keyTyped(KeyEvent e) {
char caracter = e. GetKeyChar();
//Verificar si la tecla pulsada no es un digito
if(caracter < '0') || (caracter > '9')) && (caracter! = KeyEvent. VK_BACK_SPACE)) {
JOptionPane. ShowMessageDialog(new JFrame(),"Disculpe, el valor de este Campo es
Numerico","Información",JOptionPane. INFORMATION_MESSAGE,new ImageIcon(getClass().
GetResource("/imagenes/adver. Png")));
e.Consume(); // ignorar el evento de teclado
}
}
});

Fuente: http://grupos.emagister.com/debate/convertir_a_mayusculas_en_jtextfield_en_netbeans/6709-719070

Formatear una fecha en dd/mm/yyyy


import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class Main {


public static void main(String[] args) {
Date date = Calendar.getInstance().getTime();
// Display a date in day, month, year format
DateFormat formatter = new SimpleDateFormat("dd/MM/yyyy");
String today = formatter.format(date);
System.out.println("Today : " + today);
}
}

Fuente: http://www.java2s.com/Tutorial/Java/0040__Data-Type/Formatadateintoddmmyyyy.htm

Ingresar la fecha
suponiendo que tu textfield se llama fieldFecha:

TextField fieldFecha;

. . . . .

// para validar la fecha hazlo así:

String fecha = fieldFecha.getText ();


if (fecha.matches ("\\d{4}\\-\\d{2}\\-\\d{2}")) {
//aquí el codigo que sigue si es válido
} else {
// aquí el codigo que sigue si no es válido
}
Fuente: http://mx.answers.yahoo.com/question/index?qid=20090829105856AA1huan

Convirtiendo Date a String / String a Date


Podemos convertir un objeto fecha a String de varias maneras. Cada manera es un tipo de formato
establecido por el JVM instalado en nuestro computador. Consideremos este ejemplo:
Date d1 = new Date();
DateFormat[] dfa = new DateFormat[6];
dfa[0] = DateFormat.getInstance();
dfa[1] = DateFormat.getDateInstance();
dfa[2] = DateFormat.getDateInstance(DateFormat.SHORT);
dfa[3] = DateFormat.getDateInstance(DateFormat.MEDIUM);
dfa[4] = DateFormat.getDateInstance(DateFormat.LONG);
dfa[5] = DateFormat.getDateInstance(DateFormat.FULL);

for (DateFormat df : dfa) {


System.out.println(df.format(d1));
}
En mi caso, el resultado es:
09/02/09 10:29 AM
09/02/2009
09/02/09
09/02/2009
9 de febrero de 2009
lunes 9 de febrero de 2009
Notemos el resultado del formato obtenido por DateFormat.getInstance(). Es toda la fecha en
formato corto, además de la hora. Mientras que si obtenemos el formato con DateFormat.getDate-
Instance() la fecha se muestra en formato medio (Podemos consultar la configuración del sistema
operativo referido al formato de fechas). También podemos ver los demás formatos: SHORT,
MEDIUM, LARGE y FULL.
De la misma manera podemos convertir de String a objeto java.util.Date. Aquí muestro las diferentes
maneras, de diferentes cadenas:
DateFormat df = DateFormat.getDateInstance();
Date d = df.parse("09/02/2009");

DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
Date d = df.parse("09/02/09");

DateFormat df = DateFormat.getDateInstance(DateFormat.MEDIUM);
Date d = df.parse("09/02/09");

DateFormat df = DateFormat.getDateInstance(DateFormat.LONG);
Date d = df.parse("9 de febrero de 2009");

DateFormat df = DateFormat.getDateInstance(DateFormat.FULL);
Date d = df.parse("lunes 9 de febrero de 2009");
Fuente: http://www.apuntesdejava.com/2009/02/convirtiendo-date-string-string-date.html

Convertir Date a String (y String a Date)


Java almacena las fechas en un objeto llamado java.util.Date. Si se imprime o se usa como cadena,
el resultado no es nada agradable ya que no se entiende: Sat Mar 27 00:00:00 COT 1976
Pues bien, existe una clase llamada java.text.DateFormat que permite convertir de Date a String
(bajo un formato en especial) y visceversa (también usando el mismo formato).
Aquí dejo un pequeño código (adaptado del libro de certificación SCJP 5.0 de Katty Sierra - Página
464) donde se muestra los diferentes formatos que maneja la clase java.text.DateFormat. Si
necesitas convertir una cadena (String) a Date, primero prueba este código, analízalo y luego piensa
cómo lo puedes usar.
import java.text.DateFormat;
import java.text.ParseException;
import java.util.Date;

public class Main {

public static void main(String[] args) {


Date fecha = new Date();
DateFormat dfDefault = DateFormat.getInstance();
DateFormat dfDateInstance = DateFormat.getDateInstance();
DateFormat dfDateShort = DateFormat.getDateInstance(DateFormat.SHORT);
DateFormat dfDateMedium = DateFormat.getDateInstance(DateFormat.MEDIUM);
DateFormat dfDateLong = DateFormat.getDateInstance(DateFormat.LONG);
DateFormat dfDateFull = DateFormat.getDateInstance(DateFormat.FULL);

System.out.println("getInstance()=" + dfDefault.format(fecha));
System.out.println("getDateInstance()=" + dfDateInstance.format(fecha));
System.out.println("getDateInstance(DateFormat.SHORT)=" +
dfDateShort.format(fecha));
System.out.println("getDateInstance(DateFormat.MEDIUM)=" +
dfDateMedium.format(fecha));
System.out.println("getDateInstance(DateFormat.LONG)=" +
dfDateLong.format(fecha));
System.out.println("getDateInstance(DateFormat.FULL)=" +
dfDateFull.format(fecha));
try {
Date fecha2 = dfDateMedium.parse("27/03/1976");
System.out.println("Parsed:" + fecha2);
} catch (ParseException ex) {
ex.printStackTrace();
}
}
}
El resultado para este código, en mi caso, es el siguiente:
getInstance()=22/04/09 11:12 AM
getDateInstance()=22/04/2009
getDateInstance(DateFormat.SHORT)=22/04/09
getDateInstance(DateFormat.MEDIUM)=22/04/2009
getDateInstance(DateFormat.LONG)=22 de abril de 2009
getDateInstance(DateFormat.FULL)=miércoles 22 de abril de 2009
Parsed:Sat Mar 27 00:00:00 COT 1976
Fuente: http://www.apuntesdejava.com/2009/04/convertir-date-string-y-string-date.html

Formatear Miles y decimales


Existe alguna librería para separar miles y decimales
Si escribo en un textfield:1000 me de formato 1,000.00
Si escribo 10000 de formato a 10,000.00
y asi sucesivamente para cantidades mayores.
He mirado DecimalFormat.
A ver si alguien me tira un par de ejemplos.
import java.text.DecimalFormat;
...
DecimalFormat formateador = new DecimalFormat("###,###.##");
//Este daria a la salida 1,000
System.out.println (formateador.format (1000));
//Este otro 10,000
System.out.println (formateador.format (10000));
Fuente: http://www.javamexico.org/foros/java_standard_edition/formatear_miles_y_decimales

DecimalFormat
La clase DecimalFormat de java nos permite mostrar los números en pantalla con el formato que
queramos, es decir, con cuántos decimales, si queremos
o coma para los decimales, etc. DecimalFormat también es útil para presentar un número en un
JTextField o recoger el texto del JTextField y reconstruir el número.
Un uso simple de DecimalFormat puede ser este
import java.text.DecimalFormat;
...
DecimalFormat formateador = new DecimalFormat("####.####");

// Esto sale en pantalla con cuatro decimales, es decir, 3,4324


System.out.println (formateador.format (3.43242383));
En la API de DecimalFormat podemos ver todos los posibles caracteres que admite la máscara.
Si usamos ceros en vez de #, los huecos se rellenarán con ceros.
import java.text.DecimalFormat;
...
DecimalFormat formateador = new DecimalFormat("0000.0000");

// Esto sale en pantalla con cuatro cifras enteras


// y cuatro decimales, es decir, 0003,4300
System.out.println (formateador.format (3.43));
Porcentajes
Una característica curiosa, es que si usamos en la máscara el signo de porcentaje %, el número se
multiplicará automáticamente por 100 al presentarlo en pantalla.
DecimalFormat formateador = new DecimalFormat("###.##%");

// Esto saca en pantalla 34,44%


System.out.println (formateador.format(0.3444));
DecimalFormatSymbols
La clase DecimalFormat usa por defecto el formato para el lenguaje que tengamos instalado en el
ordenador. Es decir, si nuestro sistema operativo está en español, se usará la coma para los decimales y
el punto para los separadores de miles. Si estamos en inglés, se usará el punto decimal.
Una opción para cambiar esto, es crear una clase DecimalFormatSymbols, que vendrá rellena con lo
del idioma por defecto, y cambiar en ella el símbolo que nos interese. Por ejemplo, si estamos en
español y queremos usar el punto decimal en vez de la coma, podemos hacer esto
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
...
DecimalFormatSymbols simbolos = new DecimalFormatSymbols();
simbolos.setDecimalSeparator('.');
DecimalFormat formateador = new DecimalFormat("####.####",simbolos);

// Esto sale en pantalla con punto decimal, es decir, 3.4324,


System.out.println (formateador.format (3.43242383));
En la API de DecimalFormatSymbols puedes ver qué más símbolos se pueden cambiar.
Reconstruir el número
Si suponemos que un usuario escribe en un JTextField un número, podemos leerlo y reconstruirlo con
DecimalFormat
JTextField textField = new JTextField();
...
DecimalFormat formateador = new DecimalFormat("####.####");
String texto = textField.getText();
try
{
// parse() lanza una ParseException en caso de fallo que hay
// que capturar.
Number numero = formateador.parse(texto);
double valor = numero.doubleValue();
// Estas dos líneas se puede abreviar con
// double valor = formateador.parse(texto).doubleValue();
}
catch (ParseException e)
{
// Error. El usuario ha escrito algo que no se puede convertir
// a número.
}
Fuente: http://chuwiki.chuidiang.org/index.php?title=DecimalFormat

SimpleDateFormat
Para qué sirve SimpleDateFormat
La clase SimpleDateFormat nos ayuda a mostrar las fechas en el formato que queramos o a
reconstruirlas a partir de una cadena de texto.
Convertir un Date a String
Un uso simple de SimpleDateFormat para escribir una fecha en pantalla puede ser este
import java.text.SimpleDateFormat;
...
SimpleDateFormat formateador = new SimpleDateFormat("dd/MM/yyyy");

// Esto muestra la fecha actual en pantalla, más o menos así 26/10/2006


System.out.println(formateador.format(new Date()));
Por supuesto, podemos jugar con la máscara y ponerla a nuestro gusto, dentro de las posibilidades que
nos ofrece la API de SimpleDateFormat.
SimpleDateFormat formateador = new SimpleDateFormat("'Hoy es' EEEEEEEEE dd 'de'
MMMMM 'de' yyyy");
SimpleDateFormat formatea = new SimpleDateFormat("dd/MM/yyyy");
SimpleDateFormat forma = new SimpleDateFormat("'Ingresaste' EEEEEEEEE dd 'de'
MMMMM 'de' yyyy");
DateFormat formatoFecha=DateFormat.getDateInstance(DateFormat.FULL);
En la API de SimpleDateFormat podemos ver todas las opciones para la máscara de fecha y hora.
Obtener un Date a partir de un String
Para reconstruir una fecha a partir de la cadena de texto, podemos usar la misma clase
SimpleDateFormat. Por ejemplo, si un usuario escribe una fecha con este formato en un JTextField,
podemos leerla así
import java.text.SimpleDateFormat;
...
JTextField textField = new JTextField();
...
SimpleDateFormat formateador = new SimpleDateFormat("dd/MM/yyyy");
try
{
Date fecha = formateador.parse(textField.getText());
}
catch (ParseException e)
{
// Error, la cadena de texto no se puede convertir en fecha.
}
Una cosa interesante es que a la hora de convertir un String a Date, la clase SimpleDateFormat es
"indulgente", es decir, si metemos mal el String, trata de corregirlo. Por ejemplo, si introducimos una
fecha "32 de Enero", no obtendremos error, sino que se arreglará y nos devolverá un Date
correspondiente a "1 de Febrero". Podemos eliminar este comportamiento con el método
setLenient(false);
SimpleDateFormat formateador = new SimpleDateFormat("dd/MM/yyyy");
formateador.setLenient(false);
de esta forma, el "32 de Enero" dará un error.
Otro aspecto importante a tener en cuenta es nunca enviar
SimpleDateFormat formateador = new SimpleDateFormat("dd/mm/yyyy");
en vez de
SimpleDateFormat formateador = new SimpleDateFormat("dd/MM/yyyy");
debido a que mm se refiere a minutos y no meses.
Fuente: http://chuwiki.chuidiang.org/index.php?title=SimpleDateFormat

Validar un JtextField y definir un tamaño fijo para mi aplicación


Esta es una clase que extiende al keyadapter y si la usas dentro del jtextfield solo te permite meter
número y un solo punto para decimales.
espero te sirva.
Saludos
public class KeyAdapterNumerico extends KeyAdapter {

private JTextField texto;


private boolean conpunto;
private char puntodecimal;

public KeyAdapterNumerico(JTextField text, boolean condecimales, char


puntoDecimal){
super();
texto = text;
conpunto = condecimales;
puntodecimal = puntoDecimal;
}

@Override
public void keyTyped(KeyEvent e) {
char tecla = e.getKeyChar();
if(conpunto && (tecla == puntodecimal)){
if (texto.getText().contains(""+puntodecimal)){
e.consume();
}
} else{
if ("0123456789".indexOf(tecla) == -1){
e.consume();
}
}
}
Fuente: http://forodejava.com/showthread.php/4754-Necesito-Validar-un-JtextField-y-definir-un-tama%C3%B1o-fijo-para-mi-aplicaci%C3%B3n.

Java: Convertir un Date en un String formato dd/MM/aaaa


Si tenemos un Date y lo queremos convertir en una fecha, por ejemplo, en el formato que señalo en el
título, simplemente hay que hacer:
java.util.Date date = new java.util.Date();
java.text.SimpleDateFormat sdf=new java.text.SimpleDateFormat("dd/MM/yyyy");
String fecha = sdf.format(date);
Realmente, con el SimpleDateFormat, podemos dar el formato que deseemos a las fechas. Si por
ejemplo quisiésemos poner la fecha en formato anglosajón, simplemente habría que cambiar la línea
donde usamos el constructor y escribir…
java.text.SimpleDateFormat sdf=new java.text.SimpleDateFormat("yyyy/MM/dd");
Fuente: http://blogs.vandal.net/3996/vm/1737313172008

Convertir datetime a string


myStringDate=myStringDate.trim();
if(myStringDate.equals("") || myStringDate.equalsIgnoreCase("null")){
myStringDate=this.fechaHoyS();
dia=myStringDate.substring(6, 8);
mes=myStringDate.substring(4, 6);
ano=myStringDate.substring(0, 4);
} else{
dia=myStringDate.substring(8,10);
mes=myStringDate.substring(5,7);
ano=myStringDate.substring(0,4);
}
Fuente: http://www.todoexpertos.com/categorias/tecnologia-e-internet/programacion/java/respuestas/2034401/convertir-datetime-a-string

Java: JTable scroll a la última fila cada vez que se agrega una
La Idea:
Cuando se agrega dinamicamente una fila a un JTable, el foco de ésta no se altera, osea parecen las
famosas barras de scroll y se siguen agregando datos, que si queremos ver, tenemos que scrollear. El
objetivo de éste código sería que automaticamente cada vez que se agrega una fila, ponerla en foco
El Uso:
Una tabla que vaya registrando eventos de bitácora ( Un Log ) e ir viendo en tiempo real que sucede sin
tener que estar usando la barra.
El Código:
public void agregarFilaTabla(...) {
//Código que agrega una fila en la tabla
//......
// Scroll a la última fila
int row=tabla.getRowCount()-1;
Rectangle rect=tabla.getCellRect(row, 0, true);
tabla.scrollRectToVisible(rect);
tabla.clearSelection();
tabla.setRowSelectionInterval(row, row);
DefaultTableModel modelo=(DefaultTableModel)tabla.getModel();
modelo.fireTableDataChanged();
}
Fuente: http://hackelare.wordpress.com/2011/06/27/java-jtable-scroll-a-la-ultima-fila-cada-vez-que-se-
agrega-una/

JTABLE
Un JTable es un componente visual de Java que nos permite dibujar una tabla, de forma que en cada
fila/columna de la tabla podamos poner el dato que queramos; un nombre, un apellido, una edad, un
número, etc.
http://www.abcdatos.com/tutoriales/tutorial/z3128.html
Definición Jtable
Jtable es una clase que me permite organizar una determinada información en tabla, esta difiere de una
base de datos normal porque al utilizar Jtable tu puedes visualizar esta tabla, brindándole a el usuario
organización de información, oportunidades de editar y cambiar el tamaño de las columna entre otras.
INICIOS DE JTABLE
En principio se creo la clase Jtable para constituir un interfaz ligado a bases de datos a través de "Java
Database Connectivity" (JDBC), y así evita la complejidad que existía par el manejo de datos, dando
así al programador mucha mas facilidad a la hora de trabajar con este tipo de información.
Jtable le da al programador muchas facilidades, pues este posee varias características que permiten
hacer desde tablas con información compleja y muy estructurada hasta tablas con información sencilla
y "básica".
TABLE MODEL
La clase Jtable controla como se presentan los datos, siendo el TableModel quien controla los datos sí
mismos. para crear una Jtable habrá pues que crear un TableModel antes, normalmente. TableModel lo
que hace es predeterminar ciertas características para el Jtable es decir que tu puedes poner ciertos
parámetros dentro de un TableModel y así no tener que determinarlos siempre. TableModel es un
programa que guarda los datos de la tabla para si mismo, es decir, puede tener la información de la
tabla pero estos datos son los visualizados por el computador, es decir, para visualizar una tabla el
TABLEMODEL puede tener la información pero sin el Jtable no se puede visualizar para el usuario.
EDITABLE O NO?
Jtable tiene una característica muy llamativa, este permite que el programador pueda decirdir que se
edita y que no, sin embargo si el programador dentro de su programa o de su TABLEMODEL no tiene
determinado este aspecto, Jtable automáticamente hace editable las celdas dentro de la tabla. Existen
varias maneras de hacer editable o no las celdas dentro de la tabla, para ver estos comandos tu te
puedes dirigir a Dentro de las celdas encontradas en una tabla se puede permitir al usuario editar o no
editar según lo desee el programador, esta propiedad se puede arreglar desde el table model o
directamente y/o desde el programa. Jtable tiene la propiedad de dejar editable las celdas si no
encuentra nada que hable de esto.
Y LA INFORMACIÓN, Y LAS COLUMNAS?.
Jtable te brinda muchas facilidades para poder crear una table, y así mismo de llenarla con la
información que desees ( números, letras etc...) por lo que sencillamente dentro de una tabla esta
automáticamente a través de la información debidamente separada - por ""(comillas) o por , (coma) - es
capaz de contabilizarlas y al mismo tiempo llenarla con la información que se le dio; es decir el
programador solo se debe encargar de poner los títulos de las tablas y así mismo de escribir la
información en el mismo orden en que desee que salga de acuerdo con los títulos y Jtable se encargara
automáticamente de colocar la información donde se le indico.
UN CHECK BOX?
Para un CellRendered con un TableModel sencillo, tal vez identificar clases pueda ser algo mas
complejo que no pueda hacer, pero para uno un poco mas avanzado, esto seria muy fácil, y para esto
cito el caso de un CHECK BOX(casilal de verificación) el cual es un componente grafico generado por
Jtable después de que identifica una información tipo boolean, dándole así la apariencia de un cuadro
rellenable, un check box no es mas que eso, una opción - que puede ser editable o no - que simplemente
se chulea para indicar un si o un no ( si esta chuleado significa verdadero, sino lo esta indica falso), la
cual el usuario solo puede colocar mediante un TableModel que sepa identificar clases.
UN LIST BOX?
En algunas oportunidades, para cierto tipo de información que deseamos que el usuario complete,
necesitamos darle a el usuario, cierto tipo de opciones cosa que a través de un List Box tu puedes
ofrecer al usuario el tipo de respuestas que tu desees que el selecciones, este tipo de organización de
información ya no es tan sencillo como declarar una información tipo boolean, toca crear la lista.
http://www.gfc.edu.co/estudiantes/anuario/2002/sistemas/alejandra/Jtable.junk/c2.html
La forma más sencilla de usar un JTable y tener toda su funcionalidad es instanciar un DefaultTable-
Model y meterlo en el JTable, en el constructor
DefaultTableModel modelo = new DefaultTableModel();
JTable tabla=new JTable(modelo);
Podemos añadir columnas directamente en el modelo
modelo.addColumn("etiqueta columna 1");
modelo.addColumn("etiqueta columna 2");
Podemos añadir datos directamente en el modelo, así como borrarlos o modificarlos
Object [] fila = new Object[2];
fila[0]="dato columna 1";
fila[1]="dato columna 3";
modelo.addRow ( fila );// Añade una fila al final
modelo.setValueAt ("nuevo valor", 0, 1);//Cambia el valor de la fila 1, columna 2.
modelo.removeRow (0);// Borra la primera fila
Todo lo que hagamos se reflejará de inmediato en el JTable.
Obtener fila y columna del JTable en la que se hace click
A veces nos interesa seleccionar una fila del JTable para hacer algo con ella (sacar un menú, recoger
datos para mostrarlos en otro sitio, etc).
Una forma de hacerlo es añadiendo un MouseListener al JTable, de esta manera:
tabla.addMouseListener(new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
int fila = tabla.rowAtPoint(e.getPoint());
int columna = tabla.columnAtPoint(e.getPoint());
if ((fila > -1) && (columna > -1))
System.out.println(modelo.getValueAt(fila,columna));
}
});
Hemos añadido un MouseAdapter para no tener que implementar todos los métodos del
MouseListener.
Con el método tabla.rowAtPoint() es posible enterarnos en qué fila de del JTable ha ocurrido el evento
del ratón (el click en este caso). Para ello basta llamar a este método pasándole las coordenadas x,y del
evento de ratón, que se obtienen con el método e.getPoint().
Una vez que sabemos la fila, debemos comprobar si es mayor que -1. El método rowAtPoint() nos
devuelve -1 si pinchamos en el JTable, pero fuera de cualquier fila. Es el caso de que el JTable tenga un
tamaño en pixels superior al que le corresponde según su número de filas.
Lo mismo vale para columnAtPoint().
Una vez que tenemos la fila y sabemos que no es -1, es fácil a través del modelo obtener los datos
correspondientes. En este caso se escribe por pantalla con un System.out.prinln() el valor de la fila y
columna que se ha seleccionado.
Hacer que una celda del JTable no sea editable
Si usamos DefaultTableModel las celdas del JTable son editables por defecto. A veces esto no nos
interesa y JTable no tiene métodos para impedirlo. La forma de decidir qué celdas son o no editables es
hacer nuestro propio modelo de datos, nuestro TableModel. La forma sencilla de hacerlo es heredar de
DefaultTableModel y redefinir el método isCellEditable() para que sirva a nuestros propósitos
public class MiModelo extends DefaultTableModel {
public boolean isCellEditable (int row, int column) {
//Aquí devolvemos true o false según queramos que una celda
//identificada por fila,columna (row,column), sea o no editable
if (column == 3)
return true;
return false
}
}
En este ejemplo, hemos creado nuestro propio modelo de datos que hace que la columna 4 (los índices
empiezan en cero) de la tabla sea editable y el resto no. Ahora simplemente instanciamos el JTable
usando este modelo y rellenamos los datos igual que antes.
MiModelo modelo = new MiModelo();
JTable tabla = new JTable(modelo);

Cambiar el tipo de dato con DefaultTableModel


DefaultTableModel por defecto le dice al JTable que todos los datos que tiene son Object. A veces,
porque queramos cambiar el TableCellRenderer o cualquier otro motivo, nos interesa que determinadas
columnas se consideren como Boolean, como Integer o cualquier otro tipo de dato.
Para modificar esto, tenemos que crearnos nuestro propio modelo de Datos. La forma más sencilla es
heredar de DefaultTableModel y redefinir el método getColumnClass().
public class MiModelo extends DefaultTableModel {
/**Primera columna Boolean, segunda Integer y el resto Object */
public Class getColumnClass(int columna) {
if (columna == 0) return Boolean.class;
if (columna == 1) return Integer.class;
return Object.class;
}
}
En el ejemplo se ha hecho que la primera columna sea de Boolean, la segunda de Integer y el resto de
Object.
Una cosa curiosa de los Boolean, es que el JTable al pintarlos los pone como JCheckBox.
Hacer visible una fila concreta del JTable dentro de un JScrollPane
Para que un JTable tenga barras de scroll y tenga una "cabecera" con las etiquetas de las columnas, es
necesario meterla en un JScrollPane. Esto se puede hacer de dos formas.
JTable tabla = new JTable();
JScrollPane scroll = new JScrollPane(tabla);
o bien
JTable tabla = new JTable();
JScrollPane scroll = new JScrollPane();
scroll.setViewportView(tabla);
es bastante habitual al principio equivocarse y usar el método add(), que NO funcionará correctamente
JTable tabla = new JTable();
JScrollPane scroll = new JScrollPane();
// Esto NO funciona.
scroll.add(tabla);
Cuando tenemos un JTable metido dentro de un JScrollPane, a veces queremos que las barras de scroll
se desplacen para que una determinada celda sea visible.
No conozco una forma inmediata de hacerlo, pero una posible solución es esta.
...
// Nos devuelve la posición en pixels de una celda en fila,columna
Rectangle r = tabla.getCellRect( fila, columna, true);
// Mueve el scroll para que el rectangulo sea visible
scrollPane.getViewport().scrollRectToVisible (r);
http://www.chuidiang.com/chuwiki/index.php?title=JTable#JTable
La JTable controla cómo se presentan los datos, siendo el TableModel quien controla los datos en sí
mismos. Para crear una JTable habrá pues que crear un TableModel antes, normalmente. Se puede
implementar, para ello, el interfaz TableModel, pero es mucho más simple heredar de la clase ayuda
AbstractTableModel. El ejemplo java1416.java muestra esta circunstancia.
import java.awt.*;
import java.awt.event.*;
import com.sun.java.swing.*;
import com.sun.java.swing.table.*;
import com.sun.java.swing.event.*;
//El Modelo de la Tabla es el que controla todos los
// datos que se colocan en ella
class ModeloDatos extends AbstractTableModel {
Object datos[][] = {
{"uno","dos","tres","cuatro"},
{"cinco","seis","siete","ocho"},
{"nueve","diez","once","doce"},
};
//Esta clase imprime los datos en la consola cada vez
//que se produce un cambio en cualquiera de las
//casillas de la table
class TablaListener implements TableModelListener {
public void tableChanged( TableModelEvent evt ) {
for( int i=0; i < j="0;" tabla =" new" panel =" new" frame =" new">

Una vez que se tiene un TableModel, ya sólo resta colocarlo en el constructor de JTable. Todos los
detalles de presentación, edición y actualización están ocultos al programador. En este ejemplo, se
coloca la JTable en un JScrollPane, por lo que es necesario un método especial en JTable.
Las tablas pueden soportar un comportamiento más complejo. En el ejemplo java1417.java, se utiliza
un método para cargar un array de ocho columnas por un ciento de filas y, posteriormente, la tabla es
configurada para que muestre solamente las líneas verticales y permita la selección simultánea de la fila
y columna en que se encuentre la celda marcada.
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import com.sun.java.swing.*;
import com.sun.java.swing.table.*;
class java1417 extends JPanel {
private JTable tabla;
private JScrollPane panelScroll;
private String titColumna[];
private String datoColumna[][];
public java1417() {
setLayout( new BorderLayout() );
//Creamos las columnas y las cargamos con los datos que van a
//aparecer en la pantalla
CreaColumnas();
CargaDatos();
//Creamos una instancia del componente Swing
tabla = new JTable( datoColumna,titColumna );
//Aquí se configuran algunos de los parámetros que permite
//variar la JTable
tabla.setShowHorizontalLines( false );
tabla.setRowSelectionAllowed( true );
tabla.setColumnSelectionAllowed( true );
//Cambiamos el color de la zona seleccionada (rojo/blanco)
tabla.setSelectionForeground( Color.white );
tabla.setSelectionBackground( Color.red );
//Incorporamos la tabla a un panel que incorpora ya una barra
//de desplazamiento, para que la visibilidad de la tabla sea
//automática
panelScroll = new JScrollPane( tabla );
add( panelScroll, BorderLayout.CENTER );
}
//Creamos las etiquetas que sirven de título a cada una de
//las columnas de la tabla
public void CreaColumnas() {
titColumna = new String[8];
for( int i=0; i < datocolumna =" new" iy="0;" ix="0;" ventana =" new">

Aunque el ejemplo contiene un array relativamente grande de datos, la clase JTable no manipula
demasiado bien grandes cantidades de información, resultando un rendimiento bastante pobre cuando
se sobrepasan los 2000 elementos. http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte14/cap14-
13.html
Fuente: http://yohanamoreno.blogspot.com/2008/04/jtable.html

Ahora te pongo un pequeño ejemplo para que veas como obtener la tecla pulsada:
private void formKeyReleased(java.awt.event.KeyEvent evt) {
int code = evt.getKeyCode();
char caracter = evt.getKeyChar();}
Fuente: http://www.lawebdelprogramador.com/foros/Java/1017791-Evento_KeyPressed.html

JavaScript » Capturar la tecla F5 con Javascript


Veamos cuales son los pasos.
Lo primero será saber que el usuario ha pulsado una tecla. Es por ello que deberemos de estar al tanto
del evento onkeydown. Al cual le asignaremos una función de escucha. Bueno, el evento lo capturamos
a nivel de página:
document.onkeydown=capturarf5;
Como podemos ver, la función recibe el objeto event. Este será el que contenga la información de la
tecla que el usuario ha pulsado.
Empecemos a detallar la función capturarf5(). Lo primero que hay que saber es que el código de la
tecla pulsada viaja en la propiedad event.which y que la tecla F5 tiene el código 116. Como la
propiedad event.which no está recogida en ninguna especificación (de momento es del DOM Gecko,
aunque ampliamente reconocida) también tenemos que utilizar la propiedad e.keycode (de las
implementaciones para el Internet Explorer)
Así, para capturar el código de la tecla utilizamos la siguiente línea:
var code = (e.keyCode ? e.keyCode : e.which);

Y si es el código 116.... pues, lo que queramos. ¿avisamos al usuario?


if(code == 116) {
alert("Pulsada la tecla F5");
}
Como podemos apreciar... un código muy sencillo.
Por cierto, ¿esto evita un refresco de la página?
Fuente: http://lineadecodigo.com/categoria/javascript/page/2/

Redondear decimales en Java


Hola, en vista de diversas curiosidades para poder reducir los decimales en Java Netbeans, les dejo
un pequeño tutorial donde explico paso a paso como redondear decimales en Java a la cantidad de
decimales que se desee.
Para los que deseen el código fuente del metodo redondear se los dejo a continuación:
public double redondear(double numero, double ndecimal) {
double factor = Math.pow(10, ndecimal);
return (Math.round(numero * factor) / factor);
}
Ahora procedo a explicar la función redondear:
Para poder redondear un decimal es necesario aplicar el método Math.round (la cual redondea
decimales al valor entero más próximo), cuando deseabamos redondear a 2 decimales multiplicabamos
por 100 y luego procediamos a dividir entre 100, pero si lo pensamos detalladamente, 100 es igual que
102 por lo cual utilizamos la variable factor que será la encargada de multiplicar y dividir el numero
10 elevado a la cantidad de decimales que se desee.
Es decir 102 = Math.pow(10,2)
Si no entienden el método matemático solo tomen en cuenta que la cantidad de ceros es la cantidad de
decimales luego de la coma, ahora procedo a desarrollarlo en java.
Paso 1:

Paso 2:
Paso 3:

Paso 4:
Paso 5:

Paso 6:
Paso 7:

Paso 8:
Paso 9:

Fuente: http://delmon.huachoplus.com/redondear-decimales-en-java.html

Como pasar datos de un JFrame a otro JFrame o un JDialog en NetBeans??


Hola! Primero creo que necesitaríamos saber qué datos quieres pasar, si los tomas de campos de texto,
o cuando das un click o que onda.
Pero bueno si deseas digamos que al dar click en un botón te cree un nuevo frame con datos del viejito
solo debes mandar el frame del que quieres obtener los datos como parámetro y variable de instancia
del nuevo frame.
Ejemplo:
public class JFrame1 extends JFrame{
//este es tu frame del que obtendrás datos
}
public class JFrame2 extends JFrame{
JFrame frame; //la variable de instancia del Júrame
public JFrame2(JFrame frame,...){
this.frame = frame;
}
}
Entonces si tienes un programa puedes crear un Frame1 y cuando creas el nuevo, le mandas el primero
de parámetro y de esta forma puedes acceder a todos los datos del primero.
JFrame1 miFrame = new JFrame1();
JFrame2 tuFrame = new JFrame2(miFrame);
Fuente: http://mx.answers.yahoo.com/question/index?qid=20080727101244AAtMmRz

Pasar Datos de un jDialog a otro jDialog


Instanciar el jdialog_secundario desde el jdialog_principal y pasar los parámetros que deseas obtener
en el jdialog_secundario y ya estando en el jdialog_secundario lo atrapas por su método constructor.
public class jdialog_principal ...{
...
private button pasar_datosAction....
{
String nombre="David";
int edad=20;

jdialog_secundario ref=new jdialog_secundario(null,true,nombre,edad);


}
...
}

public class jdialog_secundario ...


{
private String nombre;
private int edad;

public jdialog_secundario(...,...,String nombre,int edad);


{
this.nombre=nombre;//Aqui la variable this.nombre es David.
this.edad=edad;//Aqui la variable this.edad es 20.
//Una vez capturado las variables puedes mostrarlo en JTextField.
}
...
}
Fuente: http://forodejava.com/showthread.php/631-Pasar-Datos-de-un-jDialog-a-otro-jDialog