Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Con el programa en pantalla vamos al men principal y seleccionamos File > New Project.
Tendremos una ventana como en la siguiente figura dnde seleccionamos el tipo de proyecto: Java >
Java Application y damos clic en el botn Next.
Categories: Java
Projects: Java Application
En este paso vamos a escribir el nombre del proyecto que por convencin Java, las primeras
letras de las palabras que contenga sern en maysculas: ProyectoPrueba.
Project Name: ProyectoPrueba
Tambin deseleccionamos las casillas: Create Main Class y Set as Main Proyect.
Damos clic en el botn Finish.
Definimos el nombre del paquete, de misma forma que con los proyectos, por convencin
Java, el nombre de los paquetes debe estar totalmente en minsculas: 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 convencin Java, las letras iniciales de cada
palabra que contenga el nombre estarn en maysculas y sin espacios.
Class Name: Main.
Ahora vamos a agregar o aadir codigo a nuestra clase para que tenga algn comportamiento en
su ejecucin.
Mtodo main()
1 public static void main(String[] args) {
2 System.out.println("Proyecto en NetBeans terminado(:");
3 }
Esperamos que se termine la ejecucin y veremos el resultado que nos ha mostrado nuestra
clase. En este caso slo imprimimos un mensaje por consola.
Fuente: http://mikengel.com/tutorial-como-crear-y-ejecutar-un-proyecto-java-en-netbeans
Instrucciones
Paso 1:
Antes de empezar veamos un poco de contexto sobre el lengauje de programacin y el IDE que vamos
a utilizar.
Java es un lenguaje de programacin orientado a objetos que comaprte gran parte de su sintaxis con C y
C++. Java es uno de los lenguajes ms poderosos que existen actualmente y desde la versin 6 es un
proyecto open source, por lo que tiene el soporte de toda una comunidad de programadores, adems 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 mquina virtual de Java, adems
de que todos los celulares y una gran cantidad de dispositivos mviles tambin cuentan con Java.
NetBeans es un entorno de desarrollo integrado(IDE por sus siglas en ingls). Esto quiere decir que
integra todas las herramientas que necesitamos para poder desarrollar. Originalmente la programacin
en Java era algo complicada porque Java cuenta con una enorme cantidad de librearas y funciones que
era preciso aprenderse de memoria, viendo esto muchas compaas construyeron diferentes entornos de
programacin para facilitar la tarea del programador. Entre los ms populares surgi Eclipse que rein
como el nico y ms importante IDE de Java durante varios aos. Sun Microsystems desarrollo su
propio IDE, que tena la ventaja de que fue creado por las mismas personas que crearon Java aos
antes, este IDE fue NetBeans y despus de varios aos de desarrollo ha llegado a ser tan til y poderoso
como Eclipse o quizs un poco ms.
Paso 2:
Lo primero que debemos hacer es descargar el kit de desarrollo de Java y el entorno de programacin
NetBeans. Podemos conseguir estas dos herramientas en el site oficial de Sun Microsystems. Dentro de
la pgina de descargas debemos descargar el JDK con NetBeans.
Una vez que hayamos descargado el paquete debemos correr el instalador. Despus de aceptar la
licencia nos pregunta dnde 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 grfico 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 ms fcil de utilizar y
estas mejoras van a ser implementadas en la versin 6.0 de NetBeans. Si ests utilizando una versin
anterior a la 6.0 puedes seguir los siguientes pasos para instalarlo:
1. Descarga el archivo con los mdulos 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 mdulos presiona el botn Add y selecciona los mdulos 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
cdigo y compilar, en este caso se refiere a NetBeans.
Paso 3:
Ahora vamos a continuar con la creacin 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 botn 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 ms adelante puedas acceder a tus
archivos o puedas agregar imgenes y sonidos.
Al terminar aparecer la ventana de cdigo en la que podemos comenzar a codificar nuestra aplicacin.
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 ms adelante). Las clases son el fundamento de la programacin
orientada a objetos y podramos decir que son el molde con el que hacemos nuevos objetos. Las clases
tienen atributos y mtodos. Los atributos son lo que nos dice cmo es esa clase, por ejemplo, los
atributos de una persona son el color de ojos y el alto(entre muchos otros), los mtodos son las acciones
que puede realizar una clase, por ejemplo correr.
En el cdigo que se genera automaticamente por NetBeans tenemos dos mtodos, el mtodo Main()
que tambin se conoce como el constructor de la clase y el mtodo main() que es el punto de inicio del
programa(por las maysculas y minsculas Main es diferente de main).
Paso 4:
Dentro del mtodo main() escribe el siguiente cdigo:
Felicidades! Has creado tu primera aplicacin 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 grfica as que vamos a utilizar Swing para crear una interfaz grfica que nos muestre el
mismo mensaje.
Swing es un conjunto de libreras con las que cuenta Java para crear y mostrar una interfaz grfica.
Dentro de estas libreras hay varias clases(recuerda, una clase es como un molde con el que podemos
hacer objetos) que nos permiten mostrar ventanas, mensajes, botnes, cajas de texto e incluso
imgenes, audio o video. Una de las clases ms 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 grfica. Ahora veamos otro control importante en la generacin de
interfaces grficas. 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
posicin, agregar imgenes y muchas cosas ms. Vamos a crear una clase que sea un JFrame y despus
vamos a agregarle un JLabel para mostrar nuestro mensaje.
Paso 5:
Vuelve al cdigo 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 lnea extends JFrame en la parte de arriba despus
de dnde dice public class Main como se ve en la imgen.
Es importante notar que dejar un rengln entre el nombre de la clase y el extends no es necesario,
nicamente es para darle una mejor presentacin al cdigo, pero ustedes pueden seguir cualquier estilo
que ustedes consideren ms claro. Despus de escribir esta lnea NetBeans la va a subrayar con una
lnea roja, esto significa que el cdigo tiene un error. Poniendo el mouse sobre el error podemos
obtener ms informacin sobre l.
Paso 6:
El error que nos marca NetBeans es que no conoce el smbolo. Esto quiere decir que no sabe qu es un
JFrame, para resolver este tipo de errores debemos agregar la librera de la que hablaba hace unos
momentos, en estos momentos todava no sabemos dnde est, pero por suerte NetBeans tambin nos
muestra un foquito a la izquierda en el que, al hacer click, nos brinda una solucin. No siempre
podemos confiar en las soluciones que brinda NetBeans porque despus de todo es una herramienta y
no una persona que nos est haciendo la recomendacin, pero muchas veces su sugerencia es acertada,
como en este caso que dice que debe agregar un import(veremos ms sobre este tema ms adelante).
Selecciona la opcin y debe aparecer una lnea al principio de nuestra clase en la que resuelve el error.
Paso 7:
Como vimos en la parte de arriba el mtodo Main(con mayscula) es el constructor de la clase. Este es
el mtodo con el que vamos a crear nuevos objetos de nuestra clase(que es una ventana). Dentro de este
mtodo debemos escribir algunas lneas de cdigo para darle un tamao a la ventana y para que se
muestre. Copia el cdigo que se muestra en la siguiente imgen:
En el cdigo estamos utilizando la palabra clave this, que hace referencia a la misma clase que lo llama,
es decir, a nuestra ventana. La primera lnea va a cambiar el tamao de nuestra ventana a 200 x 200.
Escribe this.setS y espera unos momentos. Aparecer una pantalla que te muestra opcines de auto
completar. Esta pantalla es muy til al programar ya que cuando no conocemos un mtodo nos brinda
informacin sobre qu significan los parmetros y cmo utilizar el mtodo.
Por ejemplo, en esta imgen nos indica que el mtodo setSize() debe recibir dos nmeros enteros(int
quiere decir nmero entero), y nos dice que el mtodo va a cambiar el tamao del componente(en este
caso nuestra ventana) para que tenga el ancho y alto especificados. Tamben nos indica que podemos
conseguir ms informacin viendo los mtodos getSize(), setBounds() y setMinimumSize(). Utilizando
esta herramienta completa el cdigo para mostrar la ventana.
La segunda lnea nos permite cambiar el ttulo de nuestra aplicacin. Podemos utilizar cualquier ttulo
que nos guste, lo nico importante es pasarlo entre comillas porque es texto. La tercera lnea le dice a
nuestra aplicacin 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 aplicacin termine con
EXIT_ON_CLOSE. La cuarta lnea 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 lnea que se ve en la imgen dentro del mtodo main()(con minscula).
Esta lnea est creando un nuevo objeto de la clase Main mandando llamar el constructor que acabamos
de crear. Compila tu programa haciendo click en el botn compilar
en el botn correr
.
Con esto se muestra una ventana vaca, ya casi hacemos el programa que queramos, 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 cdigo como se ve en la imagen:
Una vez ms la primera lnea va a ser subrayada en rojo porque nos falta importar una librera. Ahora
vamos a utilizar otra tcnica para resolver este mismo error. Haz click derecho sobre el cdigo y
selecciona la opcin "Fix Imports". Con esto NetBeans revisar todo el cdigo y automaticametne va a
agregar todas las librearas que necesitamos.
En el cdigo lo que estamos haciendo es crear un nuevo JLabel. Su nombre ser lblHola(por
convencin todos los JLabel deben empezar su nombre con lbl) y este JLabel va a ser un nuevo JLabel
que diga "Hola". Despus agregamos el JLabel al contenedor de la ventana.
Felicidaes, hemos terminado nuestra primera aplicacin en NetBeans utilizando interfaz grfica!
Una vez que hayas terminado tu programa debes comprimir el directorio de la aplicacin que
seleccionaste en el paso 2 y mandarlo por blackboard.
Fuente: http://www.magusoft.net/compuv/01_Netbeans.html
Como se puede observar un String para el nombre del servidor, otro para la base de datos, un entero
para el nmero del puerto(que por default el 3306 siempre es de MySQL).
Este JFrame sirve como la base de algn programa, pues como lleva Strings Estticos 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-conJava.html
TaT CambiarIconoJFrame
Cmo cambiar el cono de un JFrame en cinco pasos.
Paso 1
El cono debe ser una imagen de extensin PNG. Esto se hace ms fcil, 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 ms. Si
estuviera dentro de un paquete, sera mucho mejor.
Paso 3
En el cdigo del JFrame que vamos a poner el cono, sobreescribimos el mtodo getIconImage()
conteniendo el siguiente cdigo: (notar cmo 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 diseo del JFrame, lo seleccionamos y vamos sus propiedades, buscamos la propiedad
"iconImagen" y hacemos clic en el botn de puntos suspensivos. Se mostrar una ventana de dilogo
como esta:
De la lista desplegable, seleccionamos "Valor de componente existente". Esto har que cambie la
ventana a la siguiente forma:
Seleccionamos la opcin "Propiedad" y hacemos clic en el botn de puntos suspendidos. Aparecer una
ventana de dilogo ms pequea, y seleccionamos la propiedad "iconImage" que aparece ah.
Paso 5
Ejecutamos la aplicacin con el JFrame, y voila! nuestro JFrame con un cono diferente
Fuente: http://wiki.netbeans.org/TaT_CambiarIconoJFrame
JFrame y JDialog
Cundo usar JFrame y cundo JDialog
En una aplicacin java con ventanas debera haber un nico JFrame, correspondiente a la ventana
principal de la aplicacin. El resto de ventanas secundarias deberan 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 botn de aplicacin abierta. En una
aplcacin lo normal es que slo haya un botn ah. Si creamos varios JFrame en nuestra aplicacin,
apareceran varios botnes, uno por cada JFrame.
El JDialog no muestra este botn. Por ello, el resto de las ventanas de nuestra aplicacin deberas ser
JDialog.
Hay otro motivo ms. 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 estarn visibles por encima del JFrame. No se podrn ir "detrs" de l.
Si adems, en el constructor del JDialog ponemos a true el flag que indica que es modal, adems de
pasarle una ventana padre, entonces el JDialog impedir el acceso a las otras ventanas hasta que se
cierre.
Puedes ver esto ms 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 fcil. Basta con
llamar al mtodo setIconImage() del JFrame.
frame.setIconImage (new ImageIcon("fichero.gif").getImage());
Los JDialog no tienen este mtodo, pero heredan el icono de su ventana padre. Por ello, basta con
crearlos pasndoles 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);
java.awt.event.ActionEvent;
java.awt.event.ActionListener;
java.awt.event.WindowAdapter;
java.awt.event.WindowEvent;
import
import
import
import
import
javax.swing.JButton;
javax.swing.JDialog;
javax.swing.JFrame;
javax.swing.JLabel;
javax.swing.WindowConstants;
});
En primer lugar se construyen la ventana primaria y secundaria, una con un botn y la otra con una
etiqueta.
Luego al botn se le aade un ActionListener para que oculte la principal y muestre la secundaria
cuando se pulsa.
Finalmente se aade un WindowAdapter a la ventana secundaria para enterarnos de cundo 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 ms
remedio que echar unas cuentas. El cdigo poda ser como este:
// Se da a la ventana el tamao, 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 mtodo pack() d un tamao 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 versin 1.4 del JDK existe un mtodo de la clase JWindow que realiza la operacin de centrar
la ventana sobre otro componente especifico. Este mtodo 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 botn unBotn.
v.setLocationRelativeTo (unBotn);
Si se pasa null como valor a este parmetro, 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
Creacin 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 botn derecho del ratn seleccionamos el paquete paqawt.
Entonces elegimos New | Other...
se abre el cuadro de dilogo New File y abrimos las carpetas Java GUI Forms y AWT Forms. Entonces
elegimos Frame Form y hacemos clic sobre el botn
se abre el cuadro de dilogo New Frame Form. En el campo de texto Class Name: introducimos el
nombre de la Clase SelectorColoresMarc y finalmente hacemos clic sobre el botn
Este Asistente (Wizard) nos ha creado una pestaa llamada SelectorColoresMarc, la cual contiene dos
botnes Design y Source.
Cuando el botn Design est activo entonces el IDE nos proporciona un entorno grfico para disear
nuestras aplicaciones visuales. Si hacemos clic sobre el marco que tenemos en el rea de diseo
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 botn Source para ver el cdigo fuente Java generado por el
Asistente
NetBeans, al igual que otros entornos de desarrollo Java, no permite que el desarrollador pueda
modificar cdigo en algunos mtodos que estn relacionados con el entorno grfico.
La causa de esta restriccin es debido a la sincronizacin que el entorno de desarrollo tiene que realizar
cuando pasa de Diseo a Cdigo fuente y viceversa.
Para evitar posibles errores en la escritura de cdigo relacionado con la parte visual, NetBeans prefiere
que el trabajo visual se realice directamente en este caso en el entorno grfico en vez de codificarlo
nososotros mismos.
NetBeans nos indica que no podemos modificar o aadir nuevo cdigo con un fondo de color azul
}
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 invocacin al
mtodo initComponents()
en entornos de desarrollo como por ejemplo JBuilder, en vez de llamar a este mtodo hubiera llamada
al mtodo jbInit(). Estos IDEs se crean un mtodo propio donde depositan el cdigo Java referente a la
parte visual. As cuando pasamos del entrono de codificacin al entrono visual el parsing de cdigo
java a entorno visual lo realizan de una forma ms rpida y optimizada.
el cdigo de este mtodo ya lo estudiaremos ms adelante.
new SelectorColoresMarc().setVisible(true);
como podemos observar el Asistente no nos ha creado un cdigo 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 lnea de cdigo ya habla con uno
de sus mtodos sin necesidad de utilizar una variable de referencia.
el mtodo setVisible(true) se utiliza para mostrar en pantalla el Objeto SelectorColoresMarc que ya est
instanciado en memoria. Ms adelante ya veremos como las aplicaciones grficas primero se
construyen en memoria y seguidamente cuando todos sus componentes ya estn 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 cdigo perteneciente al
mtodo 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 tambin lo hacan pero ahora hay mas opcines de administracin).
2.-Al dar en nueva conexn nos saldr la siguiente interfaz donde tendremos que colocar la
informacin 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 slo ponemos click
derecho EJECUTAR COMANDO...
Como ven hay ms opcines que en las versiones anteriores como en el 5.5 slo 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
Luego presionamos el Botn 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 conexin
conn.close();
}
//Si se produce una Excepcin 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/
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 tambin
crearemos una tabla que se llamara "producto"
Para ir a la Action del botn debemos hacer clic derecho en el botn de ah seleccionamos Events,
luego Action y finalmente ActionPerformed
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 aparecern 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);
}
}
Si ahora especificamos por medio del mtodo 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);
}
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
mtodo, pero esta vez especificando que la posicion de apertura del JDialog ser con respecta al
JFrame:
import javax.swing.JFrame;
public class Prueba{
public static void main(String[] args){
}
}
Fuente: http://lefunes.wordpress.com/2008/02/11/centrar-un-jframejdialog-en-pantalla/
Asesoramiento en programa
Hice el acceso al programa mediante una contrasea(necesaria) con dos clases.
la q contiene el metodo main:
Cdigo:
public class aplicacion {
public static void main(String[] args) {
contrasea obj=new contrasea();
}
}
Y la q contiene las especificaciones de la ventana:
Cdigo:
import java.awt.Color;
import javax.swing.*;
import javax.swing.JFrame;
import java.awt.event.*;
public class contrasea {
public contrasea(){
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 econtrasea=new JLabel("Contrasea:");
final JTextField usuario=new JTextField();
final JPasswordField contrasea = 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);
econtrasea.setBounds(10, 50, 100, 30);
contrasea.setBounds(90,50,190,30);
cerrar.setBounds(180, 100, 100, 30);
ingresar.setBounds(10, 100, 100, 30);
que lo identifica y con la terminacin FRAME por ejemplo MAINFRAME es el FRAMA principal, o
NEWITEMFRAME u FRAME para crear un nuevo tem.
Los DIALOGOS son ventanas tambin 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 travs de un botn en
el FRAME principal.
Creamos un nuevo proyecto:
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:
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 travs 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 botn al otro NEWJFRAME al primero que creamos y abrimos su cdigo de su
evento con clic derecho como en la siguiente imagen:
Listo con eso cuando hagamos clic en el botn 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 botn en el NEWJFRAME y en su
evento escribimos el siguiente cdigo:
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
Ahora escoge JAVA y despus JAVA APPLICATION como se muestra en la siguiente imagen:
Luego de hacer clic en NEXT te saldr otra ventana ponle un nombre a tu aplicacin en nuestro caso
ser APLICACIONCONFONDO y deja las dems opcines como en la siguiente imagen:
Despus 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 despus en NEW FILE como
en la siguiente imagen:
Escogemos en categoras 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 configuracin 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:
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 ttulo JLABEL1 y hacemos clic en la propiedad ICON en su botn buscar
que est representado por un botn 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 botn IMPORT TO PROJECT y escogemos la imagen que queramos de
nuestro ordenador como en la siguiente imagen:
Luego clic en el botn 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 cdigo:
Y escribimos las siguientes lneas de cdigo dentro de las llaves de amarillo que se muestran en la
imagen de arriba:
El cdigo debe quedar as:
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 botnes y todo lo dems 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 prctica es relativamente
corto y sencillo.
Fuente: http://www.mailxmail.com/como-poner-fondo-formulario-java-netbeans_h
II.- MTODOS
ATRIBUTOS
static int
EXIT_ON_CLOSE
CONSTRUCTORES
JFrame()
JFrame(String ttulo)
MTODOS
Tipo de retorno
Container
Mtodo
getContentPane()
int
getDefaultCloseOperation()
Descripcin
Retorna el objeto contentPane.
Retorna la operacin que ocurre cuando el usuario hace la operacin
de cerrar la ventana del frame
jMenuBar
getJMenuBar()
Void
remove(Component comp)
Void
Void
Void
Void
setContentPane(Container
contentPane)
setDefaultCloseOperation(int
operation)
setJMenuBar(JMenuBar menu)
Modo de uso: supongamos que tenemos un JTextField llamado txtNombres, entonces lo que tenemos
que hacer es:
txtNombres.setDocument(new LimitadorSoloLetras());
/**
* @author Hernn
*/
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 adems limitar la cantidad de caracteres
ingresados.
Nombre de la clase: LimitadorSoloLetrasNroMax.java
import
import
import
import
javax.swing.JTextField;
javax.swing.text.AttributeSet;
javax.swing.text.BadLocationException;
javax.swing.text.PlainDocument;
/**
* @author Hernn
*/
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.length())>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 adems cuando
se llegue al nmero maximo pasar al prximo campo.
Nombre de la clase: LimitadorSoloLetrasNroMaxV2.java
import
import
import
import
javax.swing.JTextField;
javax.swing.text.AttributeSet;
javax.swing.text.BadLocationException;
javax.swing.text.PlainDocument;
/**
* @author Hernn
*/
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
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 opcines: 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 rpida y sencilla de cambiar el icono de los JFrame que viene por defecto
desarrollando aplicaciones Java, con algo de cdigo. 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());
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 smbolo 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 podramos cambiar el
icono que usa Java por defecto para sus aplicaciones, aunque claro que seria algo drstico.
Cambiando el icono en nuestro JFrame
Para personalizar nuestro icono en un JFrame utilizaremos el mtodo 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
extensin .PNG en el paquete programa.imagenes.
En el cdigo que hemos visto prestemos atencin sobre:
Image icon = new ImageIcon(getClass().getResource("/programa/imagenes/love.png")).getImage();
setIconImage(icon);
Al mtodo void setIconImage() hay que pasarle nuestra imagen como argumento, utilizamos new
ImageIcon(URL location).getImage() donde el argumento location lo obtenemos a travs del mtodo
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 mtodo retornara null y la JVM nos arrojara una NullPointerException.
Tanto JDialogs como JInternalFrames que tengan este JFrame como padre llevaran el mismo icono.
Veamos como queda ahora nuestra ventana:
Y como alternativa al cdigo 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 continuacin.
NetBeans
En el caso que estemos trabajando con el editor visual de NetBeans (Matisse) no podemos modificar
manualmente el cdigo generado, as que seleccionamos el JFrame en la pestaa Inspector y luego en
la pestaa de propiedades (JFrame Properties) buscamos la propiedad iconImage seleccionando
donde se ve a continuacin:
Se nos abrir una ventana con nuevas opcines en la cual seleccionamos Custom Code y como
veremos tenemos un campo de texto donde podremos escribir nuestro cdigo para aplicar el mtodo
void setImageIcon(). Siguiendo con mi ejemplo donde tengo el archivo de imagen love.png en el
paquete programa.imagenes el cdigo a introducir sera:
new ImageIcon(getClass().getResource("/programa/imagenes/love.png")).getImage()
Fuente: http://jc-mouse.blogspot.com/2010/02/obtener-tamanodimension-de-la-pantalla.html
Convertir nmeros 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 */
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.
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
Maysculas y minsculas 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 nmeros
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
Hola Mas vale tarde que nunca aqui hay otro ejemplo que en mi programa funciona al 100%
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
public
public
public
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
Fuente: http://forodejava.com/showthread.php/960-Evento-keypress
Validacin de formularios en Java
CdiLa validacin de formularios nos permite asegurarnos que los datos que, por ejemplo, un usuario
ingrese en un campo de texto sean vlidos. Dicha validacin 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 mtodo 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 mtodo keyReleased. As, en nuestro cdigo de ejemplo
tenemos un JTextField al que le aadimos un Listener que escuchar los eventos del teclado, y
verificar si la tecla presionada es un caractr vlido (solo letras), de lo contrario lo elimina.
No hay nada especial en el cdigo de ejemplo salvo por un par de lneas:
Lnea 17: se utiliza el mtodo anidado getToolkit().beep(), que har que el sistema alerte al
usuario con un pitido cada vez que un dato errneo.
Lnea 25: comparamos el char que digite el usuario con el entero 8, que es el cdigo resultado
al usar el Backspace (tecla para borrar hacia la izquierda); lo cual permite al usuario borrar
caracteres.
Cdigo
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);
}
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 cmo puedo transformar un String a Date? Para hacer ms
interesante el asunto el valor de la variable String estaba en el siguiente formato ao-mes-da. En
cdigo se vera algo as:
String strFecha 2007-12-25;
Con anterioridad conoca 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 cdigo sera 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 da/mes/ao (21/11/2007) que se especifica como parmetro
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
cmo se puede hacer.
1. Creamos un objeto SimpleDateFormat y el parmetro 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 mtodo parse de la clase SimpleDateFormat, tener en cuenta que puede lanzar
excepcines.
En cdigo:
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 minscula estamos diciendo minutos, si utilizamos M
mayscula decimos meses. Aqu pueden encontrar mayores detalles
Fuente: http://cafelojano.wordpress.com/2007/11/21/transformando-string-a-date-uso-de-simpledateformat/
Operadores aritmticos, lectura, conversin 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 estarn en capacidad de:
Definir las operaciones elementales que ofrece el lenguaje seleccionado.
Realizar ejercicios de programacin en el lenguaje seleccionado.
Crear programas simples usando lectura y escritura de datos y las operaciones bsicas en el lenguaje
seleccionado.
Trabajando con JAVA.
Importante tener presente la bibliografa 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 importacin 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 especficas. la clase esta determinada as:
public class NombreAlgoritmo{
aqu adentro va todo el programa dividido en partes especficas.
}
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 cdigo 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 ms detalle en los prximos 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 carcter incluido los extendidos (2 bytes 0 to 65535)
byte: esta en el rango (-128 a 127)
boolean: valor lgico true-false (Corresponde a un bit)
Los extendidos:
Los tipos de datos extendidos son infinitos, dado que cualquier usuario puede definir el propio segn la
orientacin a objetos. Los ms usados para el curso pueden ser.
String: para el manejo de cadenas de texto.
Double: para la conversin de tipos double
Integer: para la conversin de tipos int
Short: para conversin de tipos short
Long: para la conversin de tipos long
Float: para la conversin de tipos float.
Definir una variable Global
Estas variables se debe colocar dentro de la clase y fuera de cualquier mtodo.
forma general tipo nombre = valorInicial;
tipo: es cualquiera de los antes mencionados.
nombre: debe ser alfanumrico, puede contender letras y nmeros 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 dems es el lugar en donde se colocan. Toda variable local debe
colocarse dentro de un mtodo 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
mtodo 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
mtodo. La palabra static significa que la variable pertenece a la clase y no a las instancias de la misma
aunque esta es teora orientada a objetos aplica para un mejor entendimiento.
Las variables locales: son accesibles solo para el mtodo 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 resolucin de ambigedad this, con fines prcticos 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 ms adelante trabajaremos en el curso.
Las formas de conversin de textos a numricos son las siguientes:
Usando If en Java-Netbeans
Objetivo:
Reconocer la toma de decisiones en el lenguaje seleccionado.
Al finalizar la clase los estudiantes estarn en capacidad de:
Utilizar las decisiones que ofrece el lenguaje seleccionado.
Realizar ejercicios de programacin 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 lgicos
&&............................................................................and
||.................................................................................or
!.................................................................................not
Los valores lgicos boolean
true
false
Las funciones para comparar textos
Para verificar si es igual texto.equals( textoComparacin )
para verificar si es mayor, menor incluso igual texto.compareTo( textoComparacin)
Las decisiones.
Las sentencias de decisin se denominan SI DE LO CONTRARIO. Su finalidad es la de hacer una
pregunta lgica o relacional y con base en dicha pregunta hacer un bloque de cdigo u otro. Se dice que
un si esta anidado cuando se encuentra dentro de otro bloque si o por de lo contrario.
Esta decisin solo aplica para una lnea que se encuentra exactamente despus del if, tambin aplica
para else, cuando sea de una sola lnea no necesita las llaves.
Si de un bloque
La finalidad de este es evaluar la expresin 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 expresin si es verdadera ingresa al bloque que est debajo del if desde {abre
hasta }cierra. En caso de ser la expresin 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 exclusin mutua.
Si de lo contrario Si... else.
Esta decisin es especial en la medida que muestra un anidamiento implcito. 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 ningn 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 lmite dado. Una clave es respetar la
indentacin:
Claves necesarias para las decisiones
1. Siempre la expresin del if debe estar encerrada entre parntesis ( expresin) 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 sangra, tabulacin o indentacin.
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+"expresin")){
//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 instruccin 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 despus del literal determinan el inicio. En
el grfico lo que aparece con corchetes significa que puede estar pero no es obligatorio.
default es el caso por defecto si despus 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 tabulacin 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 lmite. 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;
El constructor recibe un int, que indica el lmite de caracteres que se permitir ingresar en el JTextField
JTextFieldLimit(int limit)
Ahora veamos como se usa esta clase con aplicndolo 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 podrn ver el ejemplo completo, y abajo los encontraran el cdigo
empleando.
Fuente: http://www.apuntes.delibertad.com/java/limitar-los-caracteres-en-un-jtextfield/
Segunda captura que corresponde al botn proveedores, el cual contiene los datos mas resaltantes de un
proveedor de productos:
Tercera captura que le corresponde al botn de clientes, el cual contiene los datos principales de los
clientes que se tiene:
La cuarta captura corresponde al botn 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 botn 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 botn 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 versin 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 pequeo icono de advertencia en la taza de caf, pero correr sin ningn problema..
Una vez que hayan cargado el aplicativo a su lista de proyectos en NetBeans aparecern 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 despus de la presentacin una pequea ventana que pedir la validacin y existen dos tipos
como acceder como administrador o como vendedor, si se selecciona vendedor se activara el cuadro
donde les pide el cdigo del vendedor, pero en este caso ingresaremos como administrador, para eso en
nivel de acceso seleccionamos "ADMINISTRADOR" y la contrasea es "ACREDITACIN" le dan a
"OK" y listo.
Justamente despus 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 sera excelente, pero hay esta solo para resaltar ese atributo dentro del aplicativo, entonces
solo colocan un valor numrico cualquiera al tipo de cambio y le san en "SAVE" y se abrir recin el
formulario de control, asimismo la fecha que aparece es "ficticia" ya que no encontr el mtodo 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 botn 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 travs de un campo de texto (TextField) para que el metodo de bsqueda
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 extensin ".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 agradecera 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 cdigo de cada producto se genera aleatoriamente con el mtodo "Randon" para que no existan
problemas al momento de crear uno manualmente.
Por motivos de tiempo no implemente el botn de Kardex, ademas por falta de conocimiento en la
parte temtica ya que es un tema mas de contabilidad, ya que si alguien podra darme ideas de como
implementar un Kardex se podra trabajar en ello.
En conclusin este es un pequeo aplicativo que desarroll, con la intencin que sea totalmente
intuitivo para un usuario, con el genial NetBeans IDE y lo posteo con la intencin tambien de mejorarlo
y asimismo aprender mas de este programa tan completo e interesante, cualquier aporte al aplicativo,
comentario, crtica constructiva y puntos se agradecern mucho, saludos.
Fuente: http://www.taringa.net/posts/info/10095225/Software-de-inventario-desarrollado-en-java---NetBeans.html
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 grfica 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:
4.- NetBeans nos debe confirmar que ya se construyo el archivo jar de nuestra aplicacin con un
mensaje de BUILD SUCCESSFUL el cual nos indica que la construccin 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.
Tambin 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 nmero de la ltima fila, lo que no s es si tendrs que
sumarle 1, restarle 1, o quedarte con ese nmero 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 tambin un
componente JTextArea.
La mejor manera de afrontar este diseo es crear desde NetBeans un proyecto nuevo siguiendo la
plantilla correspondiente a Proyecto Nuevo, Java y Java Desktop Aplication. (Aplicacin
bsica).
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
extensin SingleFrameApplication, definida en el paquete org.jdesktop.application.SingleFrameApplication. Ntese 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 definicin de la clase SingleFrameApplication que buscamos.
Esta clase contiene el mtodo esttico main (mtodo vinculado a la clase y no a sus instancias u
objetos) necesario para arrancar, a travs de la mquina virtual de Java, el proyecto. Qu hace
exactamente el mtodo main?. Pues llamar a launch(ApliEjemploApp.class, args);
Esto crea una instancia de la clase ApliEjemploApp y llama al mtodo startup de la instancia u objeto
recin creado. En el mtodo startup tenemos el mtodo 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 Diseo) veremos el siguiente rbol
Un menu principal (JMenuBar) con dos opciones fileMenu y helpMenu (los dos son
componentes JMenuItem y los dos tienen a su vez una opcin 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
informacin bsica de nuestra aplicacin.
Esta interfaz est compuesta bsicamente 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 imgenes. Como es natural, para una aplicacin 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 opcin File por Archivo. Para ello seleccionamos el JMenu
correspondiente a File y desde la caja de propiedades cambiamos la propiedad text. Despus
seleccionamos desde la paleta de mens un componente men en el men principal al que le
asignaremos la propiedad text en Editar. Hacemos lo mismo con una opcin de Cerrar.
Cambiamos el texto de la opcin Help y finalmente reorganizamos la opciones. Es decir:
Ahora en la opcin 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 aplicacin respectivamente. Finalmente, cambiamos las propiedades
accelerator de cada una de las opciones de Archivo a travs 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 representarn 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 ocasin veremos como ejecutar sentencias SQL en Java, tomando en cuenta la conexin 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 contrasea
El cdigo de la clase es el siguiente:
import java.sql.*;
public class Conexion {
private String user;
private String password;
private String db;
nicamente resta crear una instancia de la clase y empezar a utilizar sus mtodos.
Fuente: http://fragowb.wordpress.com/2008/05/08/ejecutar-sql-en-java/
Ejemplo de Java + SQL + Netbeans
Despus 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 propsito de este post es crear
una clase que realmente realiza las acciones bsicas (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, contrasea.
Diagrama de clases:
Bueno, primero que nada empezaremos con nuestra clase que contendr los mtodos 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 contrasea, String bd)
{
this.user = usuario;
this.password = contrasea;
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(Conexin 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);
}
}
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 ningn parmetro y definirlos mediante los mtodos set y get para despus llamar al mtodo
conectar. La segunda es enviarle directamente los valores al constructor y, al igual que en la forma
anterior, ejecutar el mtodo 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,contrasea,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 tambin implementamos una opcin que nos permite realizar bsquedas por medio de
nombres(es el campo de la base de datos que eleg para este ejemplo); ha este mtodo le mandamos 2
parmetros, 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(contrasea,xxx);
con.insertar(usuario);
Para actualizar un registro le tenemos que pasar 3 parmetros al mtodo. EL primero es el nombre de
la tabla; el segundo es un Hastable en el que se incluya la modificacin que se quiere realizar y el tercer
es, en este caso, el nombre de la persona a la que se le va realizar la modificacin:
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 contrasea.
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.
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 aplicacin hecha en JAVA con la
Base de Datos de PostgreSQL.
Primero, es necesario descargarse el JDBC Driver para PostgreSQL. Este se encuentra en la pgina
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 ubicacin de nuestro Driver y con el proyecto abierto, en el Panel de Proyectos,
ubicamos en el rbol de Proyecto la opcin 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 conexin 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 continuacin 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 conexin a nuestra Base de Datos, si esta estuviera en otra
mquina, 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");
//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 conexin
stmt.execute("END");
stmt.close();
con.close();
}
catch( Exception e ){
System.out.println(e.getMessage());
e.printStackTrace();
}
}
}
//Acceso al Driver
Class.forName("org.postgresql.Driver");
stmt.executeQuery(query);
//Cerramos la conexin
stmt.execute("END");
stmt.close();
con.close();
}
catch( Exception e ){
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 parmetro un DefaultTableModel
DefaultTableModel modelo = new DefaultTableModel();
JTable tabla = new JTable(modelo);
Nos queda resolver como llenar el DefaultTableModel. Bsicamente, 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 posicin del array con una de las columnas de la tabla en
base de datos.
for (int i=0;i<3;i++)
Fuente: http://www.lawebdelprogramador.com/foros/JBuilder/738305-Llamar_Otro_JFrame___.html
Mandar llamar a otra ventana desde un boton utilizando NetBeans.
Saludos compaeros , en la universidad apenas comienzo a ver java, y no hemos visto mucho sobre
este lenguaje.
Me impuse un pequeo 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:
Cdigo 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();
}
catch(Exception e){
JOptionPane.showMessageDialog(this,e.getMessage());
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("");
}
}
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;
Fuente: http://forodejava.com/showthread.php/2313-Mandar-llamar-a-otra-ventana-desde-un-botonutilizando-NetBeans.
Tamao del resultset
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 conexin a la base de datos con un cdigo 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.
Elcdigo es el siguiente
Statements=conexion.createStatement();
ResultSetrs=s.executeQuery("select*fromtablaprueba");
//ParameterlosdatosenelJTable,usaremoslaclaseDefaultTableModel.Paraellobast
aconinstanciarelJTablecomosemuestraenelcodigo
DefaultTableModelmodelo=newDefaultTableModel();
JTabletabla=newJTable(modelo);
//AhoraslohayquerellenarelDefaultTableModelconlosdatosdelResultSet.
//Creamoslascolumnas.
modelo.addColumn("id");
modelo.addColumn("nombre");
modelo.addColumn("telefono");
//Recorremoslosregistrosconunciclowhile
while(rs.next())
{
//Secreaunarrayqueserunadelasfilasdelatabla.
Object[]fila=newObject[3];//Haytrescolumnasenlatabla
//Serellenacadaposicindelarrayconunadelascolumnasdelatablaenbasededatos.
for(inti=0;i<3;i++)
fila[i]=rs.getObject(i+1);//Elprimerindiceenrsesel1,noelcero,poresosesuma1.
//NoescomoenPHPootroslenguajesdondelosindicesiniciancon0
//Seaadealmodelolafilacompleta.
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 ms elegante de presentar los datos a un
usuario es usando tablas usando la clase JTable.
Lo que haremos ser bsicamente crear una clase que herede de la clase AbstractTableModel:
Esta clase abstracta provee la implementacin por defecto de la mayora de los mtodos en la interfaz
TableModel. Para crear un TableModel como subclase de AbstractTableModel necesitars implementar
nicamente los sigientes tres mtodos:
public int getRowCount();
getValueAt(int row, int column);
public
int
getColumnCount();public
Object
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 cdigo:
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 nmero 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 conexin a la base de datos
private boolean conectadoALaBaseDeDatos = false;
// inicializar conjuntoResultados y obtener su objeto de meta datos;
// determinar el nmero 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 conexin 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 conexin 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 nmero de columnas en el objeto ResultSet
public int getColumnCount() throws IllegalStateException {
// asegurar que la conexin a la base de datos est disponible
if ( !conectadoALaBaseDeDatos )
throw new IllegalStateException( "No hay conexion a la base de datos" );
// determinar el nmero 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 nmero de columnas
return 0;
}
// obtener el nombre de una columna especfica en el objeto ResultSet
public String getColumnName( int columna ) throws IllegalStateException {
// asegurar que la conexin 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 vaca para el nombre de la columna
return "";
}
// devolver el nmero de filas en el objeto ResultSet
public int getRowCount() throws IllegalStateException {
// asegurar que la conexin 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 especficas
public Object getValueAt( int fila, int columna ) throws IllegalStateException {
// asegurar que la conexin 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 especficas del objeto ResultSet
try {
conjuntoResultados.absolute( fila + 1 );
Si tienes dudas respecto a las operaciones hechas con el API de JDBC significa que debes leer
esto primero: Ejemplo Programacin con JDBC
public Class getColumnClass(); con este mtodo obtendremos el tipo de dato de la columna
(Integer, String, Float, etc).
public int getColumnCount(); este mtodo devuelve el nmero de columnas que tendr la
tabla.
public int getRowCount(); este mtodo devuelve el nmero 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.
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;password=";
// la consulta predeterminada recupera todos los datos de la tabla autores
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 ttulo...
Lo que quiero hacer es que una caja de texto (JTextField) no me permita colocar ms de un caracter, lo
que he logrado hacer es validar eso pero recin cuando se presenta algn evento:
Ejemplo:
Cdigo:
if(JTextField.getText().length() != 1)
//aca la excepcin
Else
//aca sigue todo normal
Pero yo quisiera que no se pudiera colocar ms de un caracter, sin necesidad de hacer vlido 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:
Cdigo:
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):
Cdigo:
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 funcin 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 cdigos ASCII de una cadena de texto
En este ejemplo vamos a ver como obtenemos los cdigos ASCII de una cadena de texto con Java. Para
ello recorreremos los caracteres de la cadena e iremos obteniendo el cdigo. Para ello nos apoyamos en
el mtodo.codePointAt().
El mtodo .codePointAt() devuelve el cdigo ASCII de un carcter en concreto. El carcter ser el que
coincida con el ndice que se pasa como parmetro al mtodo.
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 mtodo
.length(), el cual nos ayuda a conocer el tamao de la cadena. En el interior del bucle, y apoyndonos
en el elemento de interaccin vamos obteniendo el cdigo ASCII de los caracteres con el
mtodo.codePointAt()
for (int x=0;x<sCadena.length();x++)
System.out.println(sCadena.charAt(x) + " = " + sCadena.codePointAt(x));;
Vemos que utilizamos el mtodo.charAt() para sacar el carcter asociado al cdigo 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-detexto/
* @description Extraer los cdigos ASCII de una cadena de texto
*/
public class CodigosASCIICadena {
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/
Cdigo Ascii
No hace falta ningn mtodo para obtener esto. Debes tener en cuenta que el tipo char es un nmero de
0 a 255, simplementes debes hacer un casting, algo como:
char a = 'a';
System.out.println((int)a);
Fuente: http://www.forosdelweb.com/f45/convertir-char-string-180106/
Mtodos de la clase String
Mtodo Descripcin
+ Concatenacin (unin de hilera).Tambin permite concatenar una hilera con un dato numrico o
booleano.
EJEMPLO
1-) String cadena = Universidad " + Tcnica";
Ahora cadena contendr: "Universidad Tcnica"
Cadena += Nacional;
Ahora cadena contiene Universidad Tcnica 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 Tcnica;
int a = cadena.length();
La variable a contendr 19
int indexOf(String char) Retorna el ndice o posicin donde aparece por primera vez la String o
char
que se recibe como parmetro, o un -1 si no la encuentra
EJEMPLO
1-) String cadena = "San Jose";
int posicion = cadena.indexOf("Jose" );
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 = " Programacin 1 ";
cadena = cadena.trim();
Ahora cadena contiene Programacin 1
String substring(int indiceInicial, int indiceFinal) Retorna el segmento de la String entre la posicin
indiceInicial inclusive hasta una posicin anterior a indiceFinal.
EJEMPLO
1-) String cadena = "Desarrollo Orientado a Objetos";
out.println(cadena.substring(11,20));
Impresin: Orientado
char charAt (int indice) Devuelve el carcter que ocupa la posicin indicada por el ndice.
EJEMPLO
1-) String cadena = "Polimorfismo";
out.println(cadena.charAt(4));
Impresin : m
2-) char caracter = cadena.charAt(7);
Ahora carcter 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 mtodo pertenece a la clase String directamente, no hay que utilizar el nombre del objeto creado
(es un mtodo esttico).
EJEMPLO
String numero = String.valueOf(1234);
String fecha = String.valueOf(new Date());
Mtodos de la clase Carcter
bolean isLetter(char caracter))
Retorna un verdadero si el carcter del parmetro 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 carcter del parmetro es un dgito
EJEMPLO
1-) char caracter;
if (Character.isDigit(caracter))
out.println(caracter +" es un dgito" ;
bolean isUpperCase(char caracter)
Retorna un verdadero si el carcter del parmetro es una letra mayscula
EJEMPLO
1-) char caracter;
if (Character.isUpperCase(caracter))
out.println(caracter +" es una letra mayscula" ;
boolean isLowerCase(char caracter)
Retorna un verdadero si el carcter del parmetro es una letra minscula
EJEMPLO
1-) char caracter;
if (Character.isLowerCase(caracter))
Fuente: http://www.lawebdelprogramador.com/foros/Java/1269731-Ayuda_JTable_en_Netbeans.html
Java: JTable
Las tablas nos permiten tener tabulados de informacin 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 informacin; o en programas de administracin donde pueden haber varios productos que
tienen un conjunto de caractersticas, o en programas de ventas, donde pueden haber varios vendedores
con nmero 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 agrgalo 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 esttico
El modelo nos permite indicarle a la tabla qu informacin va a contener. Si slo queremos presentar
informacin esttica (que nunca cambia) al cliente entonces podemos usar un modelo esttico, 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 cmo queremos que se vea
la tabla. En esta pantalla podemos seleccionar el nemro de columnas, el nombre de las columnas e
incluso podemos agregar algunos datos.
En la pantalla anterior podemos ver cmo manejar el nmero de columnas (con los botones de Insert,
Delete o con los botones de +, -) y tambin podemos ver una rejilla donde podemos poner el ttulo 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 esttica que siempre va a iniciar con los mismos datos.
Creando un modelo dinmico
La mayora de las veces un usuario no va a querer una tabla esttica (en la que aunque pueda editar los
valores no se muestren los valores que se haban guardado previamente). Es por esto que es necesario
crear un modelo dinmico. Para poder crear un modelo dinmico es necesario implementar la interfaz
TableModel que nos obliga a sobrecargar un gran nmero de mtodos:
getColumnClass(): Es un mtodo que nos permite saber qu clase tiene guardada cada
columna, esto es para que sean ms fciles de pintar para java.
getColumnCount(): Es un mtodo que nos permite saber cuntas columnas tiene la tabla.
getColumnName(): Es un mtodo que nos permite saber el encabezado de la tabla para una
cierta columna.
getRowCount(): Es un mtodo que nos permite saber cuntas filas tiene la tabla.
getValueAt(): Es un mtodo que nos devuelve el valor que se encuentra en la posicin pasada
como parmetro.
setValueAt(): Es un mtodo que nos permite cambiar el valor que se encuentra en la posicin
pasada como parmetro mediante cdigo (el usuario puede cambiar los datos dependiendo del
mtodo isCellEditable()).
getValueAt(): Es un mtodo que nos devuelve el valor que est guardado en la celda pasada
como parmetro, este valor va a ser de la clase que indica getColumnClass() para esa columna.
Adems de todos los mtodos anteriores, la interfaz TableModel tiene un par de mtodos para manejar
eventos (como por ejemplo, que el usuario haga click, que edite una celda). Estos mtodos involucran
agregar cdigo a nuestra clase que cuando modifique algn valor o que agregue nuevos datos tenga que
disparar eventos. Este cdigo, aunque no es muy complicado, no tendra ninguna utilidad (a menos que
vayamos a escribir una manera de deshacer acciones o algo similar), sin embargo como tenemos que
implementar TableModel tendramos 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 mtodos, entonces, en lugar de implmentar la interfaz TableModel vamos a extender la clase
DefaultTableModel que ya implementa la interfaz anterior.
Implementando el modelo dinmico
Normalmente las tablas slo crecen en una direccin (hacia abajo, aumentando el nmero de filas). Por
ejemplo, en el reporte de empleados, es probable que contratemos o despidamos empleados, por lo que
vamos a tener que agregar ms filas, sin embargo sera raro que apareciera un nuevo atributo que
quisiramos manejar del empleado (y ms raro an que el cliente pudiera modificar el programa de tal
manera que lo agregue). Entonces, como la mayora de las tablas crecen en una sola dimensin(slo
aumenta el nmero 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.
Nuestro modelo debe tener alguna manera de almacenar los datos (ya vimos cmo vamos a resolver
este problema) y adems debe contar con variables de control que nos faciliten la tarea de saber cul es
el nombre de las columnas, qu tipo de dato guarda cada columna (importante para poder guardar
nmeros o booleanos) y si la columna es editable (la mayora de las veces este parmetro va a ser
verdadero, pero podran haber ocasiones en que necesitramos que fuera falso).
private
private
private
private
private
ArrayList<Object[]> data;
int numColumns;
String columnNames[];
Class classes[];
boolean editable[];
El constructor que recibe todos los parmetros debe de crear un tabla de datos en blanco y debe de leer
los parmetros que manda el usuario. Como vamos a tener varios constructores que reciban diferente
nmero de parmetros debemos construir un mtodo que nos permita iniciar el objeto y llamarlo desde
todos los constructores, el mtodo sera algo similar a:
private void initComponents(String columnNames[], Class classes[], boolean
editable[])
throws IllegalArgumentException {
this.numColumns = columnNames.length;
this.columnNames = columnNames;
this.classes = classes;
this.editable = editable;
La mayora de los mtodos son simples getters y setters (por ejemplo getRowCount() slo debe
regresar el tamao de data con data.size(), getValueAt() slo debe obtener el valor de la celda
con data.get(row)[col]), por lo que estos mtodos no van a ser consultados con ms detenimiento.
Sin embargo, para permitir que la tabla pueda crecer debemos crear mtodos que nos permitan agregar
o quitar filas. Estos mtodos 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);
En los mtodos anteriores no est sucediendo mucho que no sepamos, excepto por los mtodos
fireTableRowsInserted() y fireTableRowsDeleted(). Estos dos mtodos 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 hiciramos esta llamada entonces no veramos los cambios hasta que
modifiquemos los datos en la lista, que sera cuando la tabla se dara cuenta de que el modelo cambi.
Otro mtodo que quizs sera importante implementar sera 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);
}
Quizs tambin sera 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 cmo estn
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 grfica
pueda acceder a ella (esto es conveniente porque as los botones van a poder usarlo directamente, sin
tener que sacarlo de la tabla pero podra considerarse una mala prctica de programacin).
private EditableTableModel model;
Como podemos ver, el cdigo est creando tres arreglos, el primero tiene los nombres de las columnas
(son tres columnas: nombre, edad y telfono), 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. Fjate que despus 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 mayora de los casos s).
Ahora vamos a implementar el botn para agregar filas:
private void btnAddRowActionPerformed(java.awt.event.ActionEvent evt) {
model.addRow();
}
Como nuestro modelo est bien implementado esto fue sencillsimo, ahora vamos a implementar el
botn 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
haban puesto la vez anterior). Para guardar los datos vamos a crear un mtodo en el modelo que se
encargue de poner los datos en una matriz (para que sea ms fcil de manejar) y despus, utilizando
este mtodo vamos a utilizar un par de ciclos para guardar los datos en un archivo.
En el modelo vamos a agregar el siguiente mtodo:
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 grfica hay que crear un nuevo botn que sea el que guarda y debemos poner el
siguiente cdigo:
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 mtodo anterior debera mostrar una ventana para seleccionar el archivo y debera de proporcionar
informacin ms 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
Cmo seleccionar una fila de un JTable de Java
A veces nos vemos en la necesidad de seleccionar o resaltar mediante cdigo una fila de un JTable, ya
sea porque necesitamos realizar una bsqueda en la tabla o por cualquier otro motivo. Si el JTable se
encuentra dentro de un JScrollPane, las barras de desplazamiento se deben mover automticamente
para que se vea la fila que se seleccion.
Para realizar sta tarea tenemos el mtodo changeSelection de la clase JTable, el cual cuenta con 4
parmetros: rowIndex, columnIndex, toggle y extend; los dos primeros son dos nmeros 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 mtodo realizaremos un ejemplo prctico, que consistir
en realizar la bsqueda de un elemento qumico dentro de una tabla. Es decir tendremos una tabla con
cierta cantidad de elementos qumicos, para buscar un determinado elemento deberemos introducirlo
dentro del campo de texto respectivo, seguidamente deberemos presionar el botn Buscar e
inmediatamente se resaltar la fila en la cual se encuentra el dato que estbamos buscando (si fue
encontrado).
La interfaz grfica quedara 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 automticamente hasta hacer visible la fila
donde se encuentra el dato.
Si realizamos una nueva bsqueda, la fila seleccionada anteriormente se deseleccionar y se
seleccionar la fila donde se encuentra el dato de la ltima bsqueda, como podemos ver en la siguiente
imagen:
El cdigo que va dentro del botn 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 cdigo podemos observar en la lnea de cdigo 7 que los parmetros toggle y extend del
mtodo changeSelection deben estar en false, para trabajar de la manera que nos propusimos en el
ejemplo: mantener seleccionada solamente una fila por cada bsqueda.
Sin embargo puede haber otras ocasiones en las que se necesita seleccionar ms de una fila a la vez,
para ello pueden "jugar" con el cdigo de ejemplo que les estoy pasando, cambiando los valores de los
parmetros toggle y extend para poder visualizar mejor qu "papel juegan" dentro del mtodo.
Les recomiendo leer la documentacin oficial del mtodo selectionChange de la clase JTable, donde
encontrarn una breve explicacin sobre el mismo y sus parmetros.
No se preocupen que no me olvido de dejarles el cdigo fuente programado en Java utilizando
NetBeans 6.5 para que puedan practicar. Espero les haya sido de utilidad, cualquier acotacin o aporte
ser bienvenido, hasta la prxima.
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:
Cdigo:
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);
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, hgalo usted mismo en 5 simples pasos
El objetivo de este artculo 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
if(isSelected)
{
l.setBackground(t.getSelectionBackground());
l.setForeground(t.getSelectionForeground());
}
else
{
l.setBackground(t.getBackground());
l.setForeground(t.getForeground());
}
}
Como vemos, redefinimos dos mtodos de DefaultTableCellRenderer, el primero indica que y como
vamos a mostrar la celda (y vemos que trabajamos con JLabel) y el segundo mtodo 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, podramos
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);
Ahora podemos cambiar un poco el tamao de la tabla para que quede acorde a los datos y el tamao
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 tamao mnimo, sugerido y mximo.
Todo lo bueno tiene fin, y este fue el nuestro, ya con esto tenemos nuestro JTable modificado
completamente y si seguimos bien los pasos deberamos 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-en5-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
dinmica una tabla en java?, y la mas frecuente como puedo hacer dinmica 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 grfica dando click-derecho
sobre la tabla que creamos
Aparecer un cuadro de dialogo que describe las propiedades de la tabla, en la primera pestaa "modelo
de la tabla" se indica de donde se obtendrn los datos de la tabla, la verdad, de esa pestaa no se casi
nada si embargo si nos pasamos a la pestaa 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 tamao de la celda y por supuesto el nombre de
la columna y los nmeros 3,4,5,6 en la seleccin de modelo indican la forma en que se podrn
seleccionar las celdas de la tabla; a continuacin una descripcin de lo que hacen:
3 solo permite la seleccin de filas
Si se selecciona 4 solo se podr seleccionar una sola celda
Si se selecciona 5 se podr seleccionar mltiples celdas, pero estas debern 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 adicin, al seleccionar
boolean el valor de las columnas cambiaran por un checkbox donde la palomita significa true, y vaci
false
Despus de cambiarle el formato a la tabla todo lo que quieras, podemos seguir con lo dinmico, ahhh
la pestaa 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 versin grfica, 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 fcilmente. solo necesitamos pues sacarlo de ah, ya que si revisas el cdigo
que genero el netbeans en la funcin de initComponents dice algo como
new jtable(new DefaultTableModel{cosas raras de netbeans});
Main.java
Cmo utilizar un JList?
Construir un JList
es muy sencillo si
no queremos que
sea dinmico, es
decir: si queremos
que el usuario no
pueda agregar ms items. Para hacerlo basta con declarar un arreglo de String y pasarlo como
parmetro 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 algn trial ms 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 aade 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 librera:
javax.swing.event.* despus la clase
tiene que implementar ListSelection-
Listener y por ltimo tenemos que hacer un mtodo valueChanged() que recibe un objeto
ListSelectionEvent.
Dentro de este mtodo podemos utilizar la variable ListSelectionEvent para saber cul fue el JList que
mand llamar el mtodo mediante el mtodo getSource() que es igual que el que habamos utilizado
hasta ahora.
Un paso ms 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 habamos visto en la primera parte.
Como podemos ver aqui podemos agregar elementos
al DefaultListModel utilizando el mtodo
addElement() que recibe un String con el elemento a
aadir.
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 cdigo es un objeto tipo DefaultListModel.
Una vez que ya creamos la lista
podemos utilizar nuestro DefaultListModel para eliminar los eleventos que queramos, si sabemos el ndice en que lugar fueron agregados
(que es la misma posicin en la que
aparecen en el JList) con el mtodo
removeElementAt() que recibe ni-camente un nmero que es el ndice a borrar. Tambin hay un
mtodo del JList que nos permite saber qu elemento est seleccionado. El mtodo 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 mtodo para borrar el
registro en un ndice y el mtodo 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 ms de un
elemento entonces el mtodo getSelectedIndex() no funciona, para leer un poco ms acerca de cmo
manejar listas donde se puedan manejar multiples selecciones consulten la clase Main.java que se les
da al principio.
Tambin es importante saber cmo
guardar
los
datos
de
un
DefaultListModel a un archivo.
Tambin hay un mtodo que nos
devuelve que tantos elementos se han
agregado al DefaultListModel llamado
getSize(), este mtodo lo podemos utilizar para hacer un for que guarde desde 0 hasta el tamao todos
los registros que encuentre, es ms 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 mtodos 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 mtodo isCellEditable() para que sirva a nuestros propositos
public class MiModelo extends DefaultTableModel
{
public boolean isCellEditable (int row, int column)
{
// Aqu devolvemos true o false segn 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 ms 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:
Bsicamente 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
Borrar datos
modelo.removeRow(FILA);
Modificar
modelo.setValueAt ("nuevo dato", fila, columna);
Agregarle un Scroll
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 mtodo 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
Fuente: http://es.answers.yahoo.com/question/index?qid=20090929081101AAblmTu
Puedes reemplazar el mtodo isCellEditable y poner en prctica 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
import
import
import
java.awt.event.MouseEvent;
java.awt.event.MouseListener;
javax.swing.event.TableModelEvent;
javax.swing.event.TableModelListener;
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 parmetros que
deseas obtener en el jdialog_secundario y ya estando en el jdialog_secundario lo atrapas por su mtodo
constructor.
Algo asi:
Cdigo 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
especfico? o posee un tamao obligatorio al cual debe llegar? Claros ejemplos de esto son al querer
capturar un nmero de telefno o un nmero de cdula (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 patrn 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 nmeros.
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;
}
}
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 ratn en
otros sitio (se dice que el JFormattedTextField pierde el foco), por ejemplo, en un botn 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 mtodo getValue() nos devolver
el nuevo valor. Si es incorrecto, pondr automticamente 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 mtodo setFocusLostBehavior(), al que podemos pasar
varios valores:
Para que el JFormattedTextField nos acepte esto en sus mtodos 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.AbstractFormatter y definir los dos mtodos 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 Mayscula
*/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
pasndole en el constructor nuestra clase Formateador y con setValue() darle un primer valor vlido
para evitar problemas.
JFormattedTextField textField = new JFormattedTextField(new Formateador());
textField.setValue(new Mayusculas("hola"));
El mtodo getValue() nos devolver una clase Mayusculas y a travs de setValue() podemos pasarle
una clase Mayusculas sin problemas.
Puedes ver un Applet con este editor funcionando y descargarte sus fuentes.
JFormattedTextField con mscara para Float
Existen varios JFormattedTextField.AbstractFormatter adems de los que podamos hacernos
nosotros. Uno de los ms conocidos es el MaskFormatter. Este formateador restringe el texto vlido
incluso mientras lo estamos tecleando. Al instanciar el MaskFormatter le damos un "patrn" sobre
cmo queremos que sea el texto. Una vez configurado todo, el usuario no podr escribir en el
FormattedTextField nada que se salga de ese "patrn". Veamos con un ejemplo qu quiero decir.
Supongamos que quiero un editor que me permita escribir un nmero con dos cifras enteras y dos
decimales. No queremos que el usuario escriba algo que no sea un nmero y no queremos que escriba
ni ms 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 pasrselo al JFormattedTextField en el
constructor. Para evitar problemas, le damos un valor vlido inicial vlido al editor. El new
MaskFormatter lanza una excepcin, as que debemos capturarla.
try
{
/* El "patrn" para el editor. Las # representan cifras. En la API puedes ver
ms. Ojo con el punto decimal, segn el idioma puede ser una coma.*/
MaskFormatter mascara = new MaskFormatter("##.##");
// Se construye el JFormattedTextField pasndole la mscara
JFormattedTextField textField = new JFormattedTextField(mascara);
// Se da un valor inicial vlido para evitar problemas
textField.setValue(new Float("12.34"));
}
catch (...)
Ya est listo. Nuestro editor slo admite nmeros de dos cifras enteras y dos decimales y no nos deja
escribir otra cosa. Los mtodos getValue() y setValue() devuelven y admiten Floats.
Podemos usar el MaskFormatter con cualquier tipo de dato que:
El mtodo toString() devuelva algo que cuadre con el patrn que hemos puesto.
JFormattedTextField con mscara para nuestra propia clase.
El MaskFormatter nos vale tambin 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 cmodos 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
}
catch (...)
El InternationalMaskFormatter
Una AbstractFormatter interesante es el InternationalMaskForamatter. Adems de otras muchas
cosas, nos permite editar un nmero 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 slo admite
nmeros 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
Fuente: http://grupos.emagister.com/debate/convertir_a_mayusculas_en_jtextfield_en_netbeans/6709-719070
Formatear una fecha en dd/mm/yyyy
import
import
import
import
java.text.DateFormat;
java.text.SimpleDateFormat;
java.util.Calendar;
java.util.Date;
Fuente: http://www.java2s.com/Tutorial/Java/0040__Data-Type/Formatadateintoddmmyyyy.htm
Ingresar la fecha
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));
}
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 (tambin usando el mismo formato).
Aqu dejo un pequeo cdigo (adaptado del libro de certificacin SCJP 5.0 de Katty Sierra - Pgina
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 cdigo, analzalo y luego piensa
cmo 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();
}
}
}
getDateInstance(DateFormat.SHORT)=22/04/09
getDateInstance(DateFormat.MEDIUM)=22/04/2009
getDateInstance(DateFormat.LONG)=22 de abril de 2009
getDateInstance(DateFormat.FULL)=mircoles 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 librera 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("###,###.##");
En la API de DecimalFormat podemos ver todos los posibles caracteres que admite la mscara.
Si usamos ceros en vez de #, los huecos se rellenarn 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 caracterstica curiosa, es que si usamos en la mscara el signo de porcentaje %, el nmero se
multiplicar automticamente 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 espaol, se usar la coma para los decimales y
el punto para los separadores de miles. Si estamos en ingls, se usar el punto decimal.
Una opcin para cambiar esto, es crear una clase DecimalFormatSymbols, que vendr rellena con lo
del idioma por defecto, y cambiar en ella el smbolo que nos interese. Por ejemplo, si estamos en
espaol 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));
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, ms o menos as 26/10/2006
System.out.println(formateador.format(new Date()));
Por supuesto, podemos jugar con la mscara 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 mscara 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
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 mtodo
setLenient(false);
SimpleDateFormat formateador = new SimpleDateFormat("dd/MM/yyyy");
formateador.setLenient(false);
en vez de
SimpleDateFormat formateador = new SimpleDateFormat("dd/MM/yyyy");
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 sealo en el
ttulo, 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 quisisemos poner la fecha en formato anglosajn, simplemente habra que cambiar la lnea
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 cdigo sera que automaticamente cada vez que se agrega una fila, ponerla en foco
El Uso:
Una tabla que vaya registrando eventos de bitcora ( Un Log ) e ir viendo en tiempo real que sucede sin
tener que estar usando la barra.
El Cdigo:
public void agregarFilaTabla(...) {
//Cdigo 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-seagrega-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
nmero, etc.
http://www.abcdatos.com/tutoriales/tutorial/z3128.html
Definicin Jtable
Jtable es una clase que me permite organizar una determinada informacin en tabla, esta difiere de una
base de datos normal porque al utilizar Jtable tu puedes visualizar esta tabla, brindndole a el usuario
organizacin de informacin, oportunidades de editar y cambiar el tamao 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 travs de "Java
Database Connectivity" (JDBC), y as evita la complejidad que exista par el manejo de datos, dando
as al programador mucha mas facilidad a la hora de trabajar con este tipo de informacin.
Jtable le da al programador muchas facilidades, pues este posee varias caractersticas que permiten
hacer desde tablas con informacin compleja y muy estructurada hasta tablas con informacin sencilla
y "bsica".
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 caractersticas para el Jtable es decir que tu puedes poner ciertos
parmetros 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 informacin de la
tabla pero estos datos son los visualizados por el computador, es decir, para visualizar una tabla el
TABLEMODEL puede tener la informacin pero sin el Jtable no se puede visualizar para el usuario.
EDITABLE O NO?
Jtable tiene una caracterstica 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 automticamente 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 segn 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 INFORMACIN, Y LAS COLUMNAS?.
Jtable te brinda muchas facilidades para poder crear una table, y as mismo de llenarla con la
informacin que desees ( nmeros, letras etc...) por lo que sencillamente dentro de una tabla esta
automticamente a travs de la informacin debidamente separada - por ""(comillas) o por , (coma) - es
capaz de contabilizarlas y al mismo tiempo llenarla con la informacin que se le dio; es decir el
programador solo se debe encargar de poner los ttulos de las tablas y as mismo de escribir la
informacin en el mismo orden en que desee que salga de acuerdo con los ttulos y Jtable se encargara
automticamente de colocar la informacin 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 fcil, y para esto
cito el caso de un CHECK BOX(casilal de verificacin) el cual es un componente grafico generado por
Jtable despus de que identifica una informacin tipo boolean, dndole as la apariencia de un cuadro
rellenable, un check box no es mas que eso, una opcin - 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 informacin que deseamos que el usuario complete,
necesitamos darle a el usuario, cierto tipo de opciones cosa que a travs de un List Box tu puedes
ofrecer al usuario el tipo de respuestas que tu desees que el selecciones, este tipo de organizacin de
informacin ya no es tan sencillo como declarar una informacin tipo boolean, toca crear la lista.
http://www.gfc.edu.co/estudiantes/anuario/2002/sistemas/alejandra/Jtable.junk/c2.html
La forma ms sencilla de usar un JTable y tener toda su funcionalidad es instanciar un DefaultTableModel y meterlo en el JTable, en el constructor
DefaultTableModel modelo = new DefaultTableModel();
JTable tabla=new JTable(modelo);
Hemos aadido un MouseAdapter para no tener que implementar todos los mtodos del MouseListener.
Con el mtodo tabla.rowAtPoint() es posible enterarnos en qu fila de del JTable ha ocurrido el evento
del ratn (el click en este caso). Para ello basta llamar a este mtodo pasndole las coordenadas x,y del
evento de ratn, que se obtienen con el mtodo e.getPoint().
Una vez que sabemos la fila, debemos comprobar si es mayor que -1. El mtodo rowAtPoint() nos
devuelve -1 si pinchamos en el JTable, pero fuera de cualquier fila. Es el caso de que el JTable tenga un
tamao en pixels superior al que le corresponde segn su nmero de filas.
Lo mismo vale para columnAtPoint().
Una vez que tenemos la fila y sabemos que no es -1, es fcil a travs 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 mtodos 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 mtodo isCellEditable() para que sirva a nuestros propsitos
public class MiModelo extends DefaultTableModel {
public boolean isCellEditable (int row, int column) {
//Aqu devolvemos true o false segn 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);
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();
o bien
JTable tabla = new JTable();
JScrollPane scroll = new JScrollPane();
scroll.setViewportView(tabla);
es bastante habitual al principio equivocarse y usar el mtodo 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 solucin es esta.
...
// Nos devuelve la posicin 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 cmo 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 ms 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 slo resta colocarlo en el constructor de JTable. Todos los
detalles de presentacin, edicin y actualizacin estn ocultos al programador. En este ejemplo, se
coloca la JTable en un JScrollPane, por lo que es necesario un mtodo especial en JTable.
Las tablas pueden soportar un comportamiento ms complejo. En el ejemplo java1417.java, se utiliza
un mtodo para cargar un array de ocho columnas por un ciento de filas y, posteriormente, la tabla es
configurada para que muestre solamente las lneas verticales y permita la seleccin simultnea 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;
Aunque el ejemplo contiene un array relativamente grande de datos, la clase JTable no manipula
demasiado bien grandes cantidades de informacin, resultando un rendimiento bastante pobre cuando
se sobrepasan los 2000 elementos. http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte14/cap1413.html
Fuente: http://yohanamoreno.blogspot.com/2008/04/jtable.html
Ahora te pongo un pequeo 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 funcin de escucha. Bueno, el evento lo capturamos
a nivel de pgina:
document.onkeydown=capturarf5;
Como podemos ver, la funcin recibe el objeto event. Este ser el que contenga la informacin de la
tecla que el usuario ha pulsado.
Empecemos a detallar la funcin capturarf5(). Lo primero que hay que saber es que el cdigo de la
tecla pulsada viaja en la propiedad event.which y que la tecla F5 tiene el cdigo 116. Como la
propiedad event.which no est recogida en ninguna especificacin (de momento es del DOM Gecko,
aunque ampliamente reconocida) tambin tenemos que utilizar la propiedad e.keycode (de las
implementaciones para el Internet Explorer)
As, para capturar el cdigo de la tecla utilizamos la siguiente lnea:
var code = (e.keyCode ? e.keyCode : e.which);
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 necesitaramos 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 botn te cree un nuevo frame con datos del viejito
solo debes mandar el frame del que quieres obtener los datos como parmetro y variable de instancia
del nuevo frame.
Ejemplo:
public class JFrame1 extends JFrame{
//este es tu frame del que obtendrs datos
}
public class JFrame2 extends JFrame{
JFrame frame; //la variable de instancia del Jrame
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 parmetro 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 parmetros que deseas obtener
en el jdialog_secundario y ya estando en el jdialog_secundario lo atrapas por su mtodo constructor.
public class jdialog_principal ...{
...
}
...
Fuente: http://forodejava.com/showthread.php/631-Pasar-Datos-de-un-jDialog-a-otro-jDialog