Tutorial: Como crear y ejecutar un proyecto Java en NetBeans Dandole seguimiento a la situacin escolar en la que se encuentra nuestra amiga Liz.Quinto, me he puesto manos a la obra y traigo ante ustedes un breve pero completo tutorial, manual o gua para crear un proyecto Java en NetBeans. Acontinuacin las capturas de los pasos a seguir y sus explicaciones: Ejecutamos el IDE NetBeans. Ya saben doble clic sobre el cono en el escritorio o Inicio > Todos los programas > NetBeans > NetBeans IDE 6.7.1. Y esperamos a que cargue completamente.

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

Tendremos una ventana como en la siguiente figura 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.

Teniendo el proyecto creado, ahora agregaremos(creamos) un paquete diferente al predefinido. Damos clic derecho sobre : New > Java Package.

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 }

Para ejecutar un proyecto Java en NetBeans tenemos dos opcines: Clic en el botn Run Project, el cal ejecutar la clase que contenga el mtodo main(). Seleccionamos la clase que contenga el mtodo main() y deseemos ejecutar, damos clic derecho sobre dicha clase y seleccionamos Run File.

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

Java the Hutt Objetivo Aprender a utilizar Java y NetBeans para crear nuestra primera aplicacin. Producto a Entregar Un archivo comprimido con el programa generado en la actividad. Forma de Trabajo Individual Tiempo estimado 1 hora Forma de Entrega Por Blackboard Recomendaciones Sigue las instrucciones de la actividad y ejercita la lectura crtica. Intenta familiarizarte con la herramienta ya que te ayudar a trabajar menos NetBeans te permtie trabajar escribiendo menos cdigo. Recuerda utilizar la ayuda y el autocompletado Realiza otros ejercicios para obtener ms prctica

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:

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

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 y luego crrelo haciendo click 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

Conexin a una base de datos en MySQL con Java Para poder hacer una conexin a una base de datos, tendramos que importar una librera, que por lo generalmente se encuentra en NetBeans y se le conoce por mysql-connector-java-5.1.6-bin, buena para el programa voy a utilizar de ejemplo un JFrame como el siguiente: Lo que est utilizando son 1 JPanel, 4 JLabels, 2 JTextfields, 1jPasswordField(para la contrasea claro). Utilizaremos el siguiente cdigo:static String Exe3 = ""; static String Exe4 = ""; static String Exe5 = ""; /** Creates new form conx */ public conx() { initComponents(); } public void conex1() throws SQLException { try { Exe3 = this.jTextField1.getText(); Exe4 = this.jPasswordField1.getText(); Exe5 = this.jTextField2.getText(); String serverName = Exe5; int port = 3306; String dataBase = "ejem"; Class.forName("com.mysql.jdbc.Driver"); String url = "jdbc:mysql://" + serverName + ":" + port + "/" + dataBase; Connection con = DriverManager.getConnection(url, Exe3, Exe4); Statement stm = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); if(con != null) { usu ex= new usu(); ex.setVisible(true); this.dispose(); } if(con == null) { this.jTextField1.setText(""); this.jPasswordField1.setText(""); this.jLabel4.setText("Error vuelve a intentarlo"); } stm.close(); con.close(); }catch(ClassNotFoundException ex) { System.out.println(ex); System.out.println("error en la linea Entrada"); } }

Como se puede observar un String para el nombre del servidor, otro para la base de datos, un entero para el 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.

Clic en Aceptar, y se ver as:

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

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 iconoJDialog dialog = new JDialog (frame);

Abrir y cerrar ventanas secundarias (JDialog) desde la primaria (JFrame) En el siguiente cdigo de ejemplo, una ventana principal JFrame tiene un botn para abrir una ventana secundaria JDialog.import import import import import import import import import java.awt.event.ActionEvent; java.awt.event.ActionListener; java.awt.event.WindowAdapter; java.awt.event.WindowEvent; javax.swing.JButton; javax.swing.JDialog; javax.swing.JFrame; javax.swing.JLabel; javax.swing.WindowConstants;

public class DosVentanas { private JFrame ventanaPrincipal; private JDialog ventanaSecundaria; /** * @param args */ public static void main(String[] args) { new DosVentanas(); } public DosVentanas() { // Construccin de ventana principal ventanaPrincipal = new JFrame("Ventana principal"); JButton botn = new JButton("Abre secundaria"); ventanaPrincipal.getContentPane().add(botn); ventanaPrincipal.pack(); // Construccin de ventana secundaria ventanaSecundaria = new JDialog(ventanaPrincipal,"Ventana secundaria"); JLabel etiqueta = new JLabel("Hola"); ventanaSecundaria.getContentPane().add(etiqueta); ventanaSecundaria.pack();

// Hacer que el botn abra la ventana secundaria y cierre la // principal botn.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { ventanaPrincipal.setVisible(false); ventanaSecundaria.setVisible(true); } }); // Hacer que al cerrarse la secundaria con la x de arriba a la // derecha, se muestre la primaria ventanaSecundaria.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { ventanaPrincipal.setVisible(true); ventanaSecundaria.setVisible(false); } public void windowClosed(WindowEvent e) { ventanaPrincipal.setVisible(true); ventanaSecundaria.setVisible(false); }

});

// Mostrar la ventana principal ventanaPrincipal.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); ventanaPrincipal.setVisible(true); } }

En primer lugar se construyen la ventana primaria y secundaria, una con un 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

Este es el cdigo de la Clase SelectorColoresMarc creado por el Asistentepackage paqawt; public class SelectorColoresMarc extends java.awt.Frame { public SelectorColoresMarc() { initComponents(); } private void initComponents() { addWindowListener(new java.awt.event.WindowAdapter() { public void windowClosing(java.awt.event.WindowEvent evt) { exitForm(evt); } }); pack(); } private void exitForm(java.awt.event.WindowEvent evt) { System.exit(0); } public static void main(String args[]) { java.awt.EventQueue.invokeLater(new Runnable() { public void run() { new SelectorColoresMarc().setVisible(true); } }); }

} new SelectorColoresMarc().setVisible(true); se crea una instancia de la Clase SelectorColoresMarc public SelectorColoresMarc() { }

initComponents();

cuando se est creando el Objeto se llama al Constructor y ste a su vez realiza una 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 ejemploSelectorColoresMarc 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.html 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).

1.-Como siempre nos vamos a la opcin Presentaciones(ejecucin o RUNTIME). Seguidamente en le icono de Base de datos(click derecho y buscar en Nueva Conexin)

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

4.-Escribimos la sentencia y ejecutamos.

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

Conectando PostgreSQL con NETBEANS JAVA En este pequeo tutorial ensear la forma de conectar nuestra base de datos PostgreSQL 8.3 con el IDE Netbeans, es muy sencillo, antes que todo necesitamos bajar nuestro Driver, el cual nos permitira conectarnos y hacer puente entre ambos DESCARGAR Una vez ya descargado estaramos en condiciones para poder conectarnos. Abrimos NetBeans y vamos al Men Herramientas (Tools) y luego a Libreras, ah seleccionamos Nueva Librera nos aparece Nombre de librera digitamos PostgreSQL y dejamos la opcin por default en el campo tipo de librera y presionamos el botn Ok.

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/

Conectar Java con MySQL en NetBeans Dentro de unas semanas tendr que desarrollar, junto con un equipo de trabajo, un sistema de un almacen en Java bajo la plataforma de NetBeans. Es por eso que comenzar a pubicar una serie de post sobre cmo manejar bases de datos de MySQL con Java, y en los cuales poco a poco ir agregando nuevas funcionalidades. Por ahora solo mostrar cmo realizar la conexin a la base de datos de MySQL. Para comenzar debemos de tener instalado NetBeans, en lo particular yo tengo instalada la versin 6.0. Posteriormente debemos descargar un Driver o Conector para poder conectarnos a la base de datos. Se puede decir que ese Driver sabe cmo hablar con la base de datos, yo descargu la versin 5.0. Una vez descargado el archivo, extraemos los componentes, de estos el archivo que nos interesa es mysql-connector-java-5.0.5-bin.jar, este jar es la clase o Driver que nos permitir conectarnos a la base de datos. Ahora tenemos que hacer que esa clase est accesible para nuestros proyectos, as que la vamos a guardar en la carpeta /jre/lib/ext. Si has realizado una instalacin por defecto del NetBeans en Windows, entonces estar en: C:\Archivos de programa\Java\jdk1.6.0_04\jre\lib\ext. En esta carpeta es donde se agregan los jar adicionales, y as ya los tendremos disponibles para cuando necesitemos usarlos de nuevo. Ahora que ya tenemos el conector a la base de datos pasaremos a la parte del NetBeans: 1. Creamos un nuevo proyecto: New Project -> Java -> Desktop Application (Basic application). 2. Agregamos un botn al formulario y le cambiamos su label a Cargar datos. 3. Agregamos una nueva clase llamada TestConnectionimport java.sql.*; public class TestConnection { public String bd = "nombre_bd"; public String login = "usuario"; public String password = "contrasea"; public String url = "jdbc:mysql://localhost/"+bd; public void conectar() { Connection conn = null; try { Class.forName("org.gjt.mm.mysql.Driver"); conn = DriverManager.getConnection(url, login, password); if (conn != null) { System.out.println("Conexin a base de datos "+url+" ... Ok"); conn.close(); } } catch(SQLException ex) { System.out.println("Hubo un problema al intentar conectarse con la base de datos "+url); } catch(ClassNotFoundException ex) { System.out.println(ex); } } }

4. Hacemos doble clic en el botn Cargar datos y colocamos el siguiente cdigo:sourcecode language=java [ TestConnection conexion = new TestConnection(); conexion.conectar(); ]

Y listo!!!. Con esto ya tenemos realizada la conexin a la base de datos de MySQL Fuente: http://fragowb.wordpress.com/2008/05/01/conectar-java-con-mysql-en-netbeans/

Java - LLenar un JTable con ResultSet 1. Entorno JDK 6 Update 21 Netbeans 6.9.1 MySQL 5.1. 2. Introduccin Lo que se desea demostrar en este tutorial es como mostrar los datos de una consulta en un JTable. Haciendo uso de la clase ResultSetMetaData que nos brinda la informacin de una tabla de la base de datos y la clase ResultSet que nos devuelve la data producto de una consulta hacia la base de datos. 3. Desarrollo 3.1. Crear el proyecto Primero debemos de crear un proyecto en Netbeans para eso nos vamos a "File->New Project" y seleccionamos la opcin de crear un "Java Application"

Y como nombre al proyecto le ponemos "LlenarJTable"

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

3.2. Diseo del Formulario Debemos de disear el siguiente formulario:

Donde: El JTextBox: Recibe el nombre de txtQuery El JTable: Recibe el nombre de jtQuery El JButton: Recibe el nombre de btnConsultar 3.3. Crear base de datos en MySQL Debemos de crear una base de datos en MySQL. A la base de la llamaremos "bdproductos" y tambin crearemos una tabla que se llamara "producto"

3.4. Codificando el action del botn "Consultar" Debemos de codificar la accin del botn "Consultar" que va a llenar al JTable con la data producto de la consulta que vamos a hacer a la base de datos bdproductos que esta en MySQL. No olvidar agregar el conector al Netbeans para poder comunicarnos con MySQL.

Para ir a la Action del botn debemos hacer clic derecho en el botn de ah seleccionamos Events, luego Action y finalmente ActionPerformed

Y luego dentro de ese evento ponemos el siguiente codigo try { //Para establecer el modelo al JTable DefaultTableModel modelo = new DefaultTableModel(); this.jtQuery.setModel(modelo); //Para conectarnos a nuestra base de datos DriverManager.registerDriver(new com.mysql.jdbc.Driver()); Connection conexion = DriverManager.getConnection("jdbc:mysql://localhost/bdproductos", "usuario", "clave"); //Para ejecutar la consulta Statement s = conexion.createStatement(); //Ejecutamos la consulta que escribimos en la caja de texto //y los datos lo almacenamos en un ResultSet ResultSet rs = s.executeQuery(txtQuery.getText()); //Obteniendo la informacion de las columnas que estan siendo consultadas ResultSetMetaData rsMd = rs.getMetaData(); //La cantidad de columnas que tiene la consulta int cantidadColumnas = rsMd.getColumnCount(); //Establecer como cabezeras el nombre de las colimnas for (int i = 1; i NEW PROJECT:

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:

Le arrastramos un JLabel1 y le ampliamos su tamao por todo el formulario agarrndole de una esquina y agrandndole hasta que tape todo el formulario Fondo:

Ahora nos vamos a las propiedades del JLabel1 que est en la parte derecha y borramos su propiedad TEXT para que no se vea el 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 hacemos clic en NEXT y despus clic en FINISH:

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:

Luego buscamos las lneas siguientes:

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:

Ahora haz clic en el botn PLAY que es un tringulo verde: Y te pedir que elijas en formulario principal:

Escoges Principal y listo ya tienes tu fondo pero solo se ver cuando se ejecute tu proyecto, recuerda que tienes que trabajar pone ido tus 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

Cmo ocultar el botn cerrar del JFrame? en NetBeans? Puedes quitar el marco completo de la ventana con la siguiente propiedad del Jframe miventana.setUndecorated(true); Fuente: http://es.answers.yahoo.com/question/index?qid=20110312080706AA40Qqw Inhabilitar botn cerrar Java en JFrame Trata el siguiente cdigo, a mi me funciono sin problema alguno, colcalo en la clase principal donde inicie el cdigo del programa. setDefaultCloseOperation(0); ejemplo: class Programa extends JFrame{ Programa(){ setDefaultCloseOperation(0); } } Fuente: http://www.todoexpertos.com/categorias/tecnologia-e-internet/programacion/java/respuestas/1018742/inhabilitarbotn-cerrar-java-en-jframeg

JFrame, JDialog y otras ventanas Cuando queremos hacer ventanitas en java nos encontramos con dos ventanas: El JFrame y el JDialog. Cundo se usa una u otra?, Qu diferencias hay entre ellas?. Los JDialog admiten un padre y pueden ser o no modales. Para qu sirve ese padre? Puedo hacer cualquier JDialog modal? Otras veces queremos hacer una ventana de error, de aviso, para pedir un dato o confirmar algo. Pongo JFrame o JDialog para esas ventanas? Tengo que construirla? Vamos a tratar en este tutorial de echar un vistazo a JFrame y JDialog, as como a JOptionPane y ver cundo usamos una u otra. Trataremos de responder a todas estas preguntas. JFrame y JDialog Los dos tipos de ventanas principales que tenemos en java son JFrame y JDialog. Hay varias diferencias entre ellas y en funcin de estas diferencias vamos a ver para qu sirven Si instanciamos un JFrame, en la barra de abajo de windows (creo que se llama "barra de herramientas") nos aparece un nuevo "botncito" correspondiente a nuestra aplicacin. Si instanciamos un JDialog, no aparece nada. Un JFrame tiene un mtodo setIconImage() para cambiar el icono por defecto de la taza de caf. JDialog no tiene este mtodo. Un JDialog admite otra ventana (JFrame o JDialog) como padre en el constructor. JFrame no admite padres. Un JDialog puede ser modal, un JFrame no. Todo esto nos indica lo siguiente: Un JFrame debe ser la ventana principal de nuestra aplicacin y slo debe haber una. Las ventanas secundarias de nuestra aplicacin deben ser JDialog. Los motivos de esto son los siguientes. Al mostrar el JFrame un botn en la barra de herramientas de windows y tener mtodo para cambiar el icono, es la ventana ideal como ventana principal de nuestra aplicacin y slo debe haber una. Nos permite cambiar el icono y slo debe haber un botn en la barra de herramientas de windows para nuestra aplicacin. Si usamos un JDialog como ventana principal, no tenemos botn en la barra de herramientas y no hay forma fcil de cambiarle el icono. Los JDialog son ideales para ventanas secundarias porque admiten una ventana padre. Si la VentanaA es padre del JDialogB, entonces el JDialogB siempre estar por delante de VentanaA, nunca quedar por detrs. Lo ideal es que hagamos nuestras ventanas secundarias como JDialog cuyo padre sea el JFrame principal. De esta forma los JDialog siempre sern visibles por encima del JFrame y no se irn detrs ni quedarn ocultos por el JFrame. Otra ventaja de admitir un padre es que heredan el icono de l. Si hemos cambiado el icono del JFrame con el mtodo setIconImage(), entonces todos los JDialog que hagamos como hijos de este JFrame heredarn el icono. Todas las ventanas de nuestra aplicacin tendrn el mismo icono en lugar de la taza de caf por defecto.

Jerarqua de padres y ventanas modales Un JDialog puede ser modal, pasndole un true en el constructor en el sitio adecuado o hacindolo modal con el mtodo setModal(). Si hacemos un JDialog modal, todas las dems ventanas se deshabilitarn hasta que el usuario de nuestro programa cierre el JDialog. Esto est estupendo para pedir un dato al usuario y evitar que toque otras cosas hasta que haya introducido el dato. Sin embargo, tiene un peligro. Supongamos un JDialog que lo hacemos modal para pedir unos datos al usuario. Este JDialog tiene un botn de "Aceptar" para que el usuario lo pulse cuando haya terminado de introducir los datos. Supongamos que en el cdigo de ese botn "Aceptar" comprobamos los datos que ha metido el usuario y vemos que son incorrectos. Le sacamos un segundo JDialog modal para indicarle el error y no cerramos el primero. Quin debe ser el padre de ese segundo JDialog modal?. Si hacemos que el padre sea el JFrame tendremos dos JDialog modales hijos del JFrame, es decir, dos JDialog modales hermanos. Esto nos dar problemas, como que ambas ventanas queden deshabilitadas, que al cerrar una de ellas se nos oculten todas, que parte de la ventana quede deshabilitada mientras que otra parte no, etc. Entonces, cmo hacemos?. Para que java no haga cosas raras, el padre del segundo JDialog modal debe ser el primer JDialog modal. De esta forma, el segundo tiene "prioridad" sobre el primero. Todo queda deshabilitado excepto este segundo JDialog. Cuando lo cerremos, ser el primero el que mande. Resumiendo, si queremos varias ventanas modales simultneamente en pantalla, cada ventana que se muestre debe ser padre de la siguiente, de forma que la cadena de ventanas modales sean padre, hijo, nieto, etc. Tener dos ventanas modales simultaneas que sean hermanas o primas o cualquier otra relacin que no sea directa, nos dar problemas. JOptionPane Para hacer ventanas sencillas que avisen de un error al usuario y tengan un botn de "Cerrar", o que le pidan una confirmacin para hacer algo (como borrar un fichero) y tengan dos botnes de "Si" y "No", o para pedirle que elija una opcin entre varias disponibles ... tenemos suerte. No hay que construir la ventana. La clase JOptionPane de java tiene mtodos showConfirmDialog(), showInputDialog(), showOptionDialog(), showMessageDialog(). Estos mtodos mostarn una ventana modal que pide al usuario una confirmacin, que le pide un dato o le muestra un mensaje. En caso de que el usuario tenga que elegir algo, el mtodo usado devuelve el valor elegido. Por ejemplo, para mostrar un aviso de error, nos basta esta simple lnea de cdigo JOptionPane.showMessageDialog(ventanaPadre, "mensaje de error", "ttulo de la ventana", JOptionPane.ERROR_MESSAGE); Esto mostrar el mensaje de error y detendr la ejecucin del cdigo hasta que el usuario cierre la ventana. Ahora viene el dato importante. Esta ventana es modal y admite un padre. Si ya hay una ventana modal visible en pantalla, deberas pasar esa ventana como padre de esta para no tener problemas. JInternalFrame El JInternalFrame es una ventana especial que ni es ventana ni es nada. De hecho, no hereda de Window. En realidad es un componente java que se dibuja dentro de otro componente, pero adornado con la barra de ttulo de una ventana y sus botnes de maximizar, minimizar y cerrar. Puede incluso arrastrarse y modificarse de tamao siempre que se mete dentro del componente adecuado. El sitio bueno para meter los JInternalFrame es el JDesktopPane. Este panel admite JInternalFrame y sabe manejarlos. JFrame ventana = new JFrame(); JDesktopPane desktop = new JDesktopPane(); ventana.getContentPane.add(desktop); JInternalFrame internal = new JInternalFrame(); desktop.add(internal); En este cdigo el JInternalFrame se comportar como una ventana, pero que no puede salirse del JDesktop que la contiene. Resumen En nuestra aplicacin debe haber un JFrame y slo uno, que ser la ventana principal. Todas las ventanas secundarias deben ser JDialog y todos los JDialog deberan tener padre. Todos los JDialog modales visibles a la vez en pantalla, deben ser unos hijos de otros en una cadena "padre-hijo-nieto" directa. No pueden ser "hermanos", ni "primos" ni "sobrinos". Fuente: http://www.chuidiang.com/java/novatos/JFrame_JDialog.php

Cerrar la ventana JFrame o JDialog al pulsar la tecla ESCAPE KeyboardFocusManager kb = KeyboardFocusManager.getCurrentKeyboardFocusManager(); kb.addKeyEventPostProcessor(new KeyEventPostProcessor(){ public boolean postProcessKeyEvent(KeyEvent e){ if (e.getKeyCode() == KeyEvent.VK_ESCAPE && this != null){ System.out.println("probando..."); dispose(); return false; } return true; } }); Fuente: http://foro.chuidiang.com/java-j2se/cerrar-la-ventana-jframe-o-jdialog-al-pulsar-la-tecla-escape/ JAVA desde cero Clase JFrame Por herencia la clase JFrame y sus clases descendientes (subclases directas ) pueden utilizar los datos y/o mtodos de la superclase Frame, Window, Container, Component y Object de la librera awt. La clase JFrame es ligeramente incompatible con la clase Frame. Como todo otro contenedor de alto nivel de la librera Swing, un JFrame contiene un JRootPane como su nico elemento. El contentPane proporcionado por el rootPane debera, como una regla, contener todos los componentes que no sean men mostrados por el JFrame. A diferencia del Frame, un JFrame tiene alguna nocin de como responder cuando el usuario intenta cerrar la ventana. El comportamiento por defecto es simplemente ocultar el JFrame cuando el usuario cierra la ventana. Para cambiar el comportamiento por defecto se debe invocar al mtodo setDefaultCloseOperation(). I.- JERARQUA DE CLASES

II.- MTODOS ATRIBUTOS static int EXIT_ON_CLOSE CONSTRUCTORES JFrame() JFrame(String ttulo) MTODOSTipo de retorno Container int Mtodo getContentPane() getDefaultCloseOperation()

La salida por defecto al cerrar una ventana. Crea un nuevo frame que es inicialmente visible Crea un nuevo frame con el ttulo indicado como parmetroDescripcin Retorna el objeto contentPane. Retorna la operacin que ocurre cuando el usuario hace la operacin de cerrar la ventana del frame

jMenuBar Void Void Void Void Void

getJMenuBar() remove(Component comp) setContentPane(Container contentPane) setDefaultCloseOperation(int operation) setJMenuBar(JMenuBar menu)

Retorna el menBar establecido en el frame Remueve el componente indicado como parmetro de ste contenedor Establece la propiedad del contentPane

Establece la operacin que suceder por defecto cuando el usuario cierra la ventana Establece la barra de men para el frame Por defecto, la distribucin de los paneles de ste componente no setLayout(LayoutManager layout) debe cambiarse; en su lugar, debera ser cambiada la distribucin de su contentPane que generalmente es un panel.

III.- OTROS MTODOS Para Colocar el nombre en la ventana del JFrame: 1 this.setTitle(Ttulo del frame); Para maximizar la ventana de JFrame 1 this.setExtendedState(this.MAXIMIZED_BOTH); Para desactivar el botn de cierre del JFrame 1 this.setDefaultCloseOperation(0) 1 this.setDefaultCloseOperation(this.DO_NOTHING_ON_CLOSE); Para hacer visible al frame 1 this.setVisible(true); OBSERVACION: Todos estos mtodos se deben invocar en el constructor del JFrame; es decir: public Principal() { panAcces = new panAcceso(); admin = new Administrador(); listadoAlu = new ListaAlumnos(); initComponents(); fecha = new Fecha(); //Maximizar la ventana del JFrame this.setExtendedState(this.MAXIMIZED_BOTH); //Evita que se cierrre el frame con el botn salir esquivale a this.setDefaultCloseOperation(0); this.setDefaultCloseOperation(this.DO_NOTHING_ON_CLOSE); this.setTitle("SISTEMA INTEGRAL DE NOTAS - SIN"); lblFecha.setText("" + fecha.iniciarComponentes()); try { UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()); } catch (Exception e) { e.printStackTrace(); } } IV.- EJEMPLOS 1. Disee una aplicacin con dos frames, uno de bienvenida y otro de despedida activados a travs de botnes como se muestra a continuacin : Fuente: http://javax0711.blogspot.com/2009/10/clase-jframe.html

Java - deshabilitar maximizar en frame public Login() { initComponents(); setSize(400,300); this.setResizable(false);// esto hara que el frame no se pueda maximizar } Fuente: http://www.lawebdelprogramador.com/foros/Java/930097-deshabilitar_maximizar_en_frame.html Jframe sin el boton de cerrar, maximizar y minimizar Facil y sencillo setUndecorated(true); getRootPane().setWindowDecorationStyle(JRootPane.NONE); se le pone al frame y listo Fuente: http://skuarch.blogspot.com/2011/03/jframe-sin-el-botn-de-cerrar-maximizar.html Limitar caracteres en un JTextfield Por diversas razones tenemos la necesidad de evitar que un usuario ingrese ya sea nmeros, letras, ciertos caracteres especiales o ms de un nmero mximo de caracteres. Para lograr estos objetivos voy a mostrar algunos de ejemplos de clases que implementan algun tipo de limitacin en los datos ingresados. Primer ejemplo: Limitar el jTextField a solo letras y espacios. Nombre de la clase: LimitadorSoloLetras.javaimport javax.swing.text.AttributeSet; import javax.swing.text.BadLocationException; import javax.swing.text.PlainDocument; /** * @author Hernn */ public class LimitadorSoloLetras extends PlainDocument{ public void insertString(int arg0, String arg1, AttributeSet arg2) throws adLocationException { for (int i=0;i 0,00 y 999 999 999,00 if (Pattern.matches("\\d{1,9},\\d{1,2}", numero)) { //se divide el numero 0000000,00 -> entero y decimal String Num[] = numero.split(","); //de da formato al numero decimal parte_decimal = Num[1] + "/100 Bolivianos."; //se convierte el numero a literal if (Integer.parseInt(Num[0]) == 0) {//si el valor es cero literal = "cero "; }else if (Integer.parseInt(Num[0]) > 999999) {//si es millon literal = getMillones(Num[0]); }else if (Integer.parseInt(Num[0]) > 999) {//si es miles literal = getMiles(Num[0]); }else if (Integer.parseInt(Num[0]) > 99) {//si es centena literal = getCentenas(Num[0]); }else if (Integer.parseInt(Num[0]) > 9) {//si es decena literal = getDecenas(Num[0]); }else {//sino unidades -> 9 literal = getUnidades(Num[0]); } //devuelve el resultado en mayusculas o minusculas if (mayusculas) { return (literal + parte_decimal).toUpperCase(); }else { return (literal + parte_decimal); } }else {//error, no se puede convertir return literal = null; } } /* funciones para convertir los numeros a literales */

private String getUnidades(String numero) {// 1 - 9 //si tuviera algun 0 antes se lo quita -> 09 = 9 o 009=9 String num = numero.substring(numero.length() - 1); return UNIDADES[Integer.parseInt(num)]; } private String getDecenas(String num) {// 99 int n = Integer.parseInt(num); if (n < 10) {//para casos como -> 01 - 09 return getUnidades(num); }else if (n > 19) {//para 20...99 String u = getUnidades(num); if (u.equals("")) {//para 20,30,40,50,60,70,80,90 return DECENAS[Integer.parseInt(num.substring(0, 1)) + 8]; }else { return DECENAS[Integer.parseInt(num.substring(0, 1)) + 8] + "y " + u; } }else {//numeros entre 11 y 19 return DECENAS[n - 10]; } } private String getCentenas(String num) {// 999 o 099 if( Integer.parseInt(num)>99 ){//es centena if (Integer.parseInt(num) == 100) {//caso especial return " cien "; }else { return CENTENAS[Integer.parseInt(num.substring(0, 1))] + getDecenas(num.substring(1)); } }else{//por Ej. 099 //se quita el 0 antes de convertir a decenas return getDecenas(Integer.parseInt(num)+""); } } private String getMiles(String numero) {// 999 999 //obtiene las centenas String c = numero.substring(numero.length() - 3); //obtiene los miles String m = numero.substring(0, numero.length() - 3); String n=""; //se comprueba que miles tenga valor entero if (Integer.parseInt(m) > 0) { n = getCentenas(m); return n + "mil " + getCentenas(c); }else { return "" + getCentenas(c); } } private String getMillones(String numero) {//000 000 000 //se obtiene los miles String miles = numero.substring(numero.length() - 6); //se obtiene los millones String millon = numero.substring(0, numero.length() - 6); String n = ""; if(millon.length()>1){ n = getCentenas(millon) + "millones "; }else{ n = getUnidades(millon) + "millon "; } return n + getMiles(miles); }

}

Esta clase, recibe un numero de 0,00 a 999999999.00 en formato String, el separador decimal puede ser un punto (.) o una coma (,), ademas tiene un parametro booleano "mayusculas" el cual sea verdadero (true) o falso (false), retorna el resultado en mayusculas o minusculas, esta clase no acepta numeros negativos ni tampoco numero mayores o iguales a mil millones, aunque claro trate de escribir esta clase para que sea facilmente comprensible y asi pueda ser ampliado o modificado segun sus necesidades.

La forma de llamara a esta clase es:Numero_a_Letra NumLetra = new Numero_a_Letra(); String numero = "20004.70"; System.out.println( numero + " literal = " + NumLetra.Convertir(numero,true));

y probando para un rango mayor de numeros tenemos como resultado:352822,50 literal = TRECIENTOS CINCUENTA Y DOS MIL OCHOCIENTOS VEINTE Y DOS 50/100 BOLIVIANOS. 370,50 literal = trecientos setenta 50/100 Bolivianos. 74883,50 literal = SETENTA Y CUATRO MIL OCHOCIENTOS OCHENTA Y TRES 50/100 BOLIVIANOS. 354801,50 literal = trecientos cincuenta y cuatro mil ochocientos un 50/100 Bolivianos. 12,50 literal = DOCE 50/100 BOLIVIANOS. 511812060,50 literal = QUINIENTOS ONCE MILLONES OCHOCIENTOS DOCE MIL SESENTA 50/100 BOLIVIANOS. 285364,50 literal = doscientos ochenta y cinco mil trecientos sesenta y cuatro 50/100 Bolivianos. 97,50 literal = NOVENTA Y SIETE 50/100 BOLIVIANOS. 882,50 literal = OCHOCIENTOS OCHENTA Y DOS 50/100 BOLIVIANOS. 28,50 literal = VEINTE Y OCHO 50/100 BOLIVIANOS. 395362869,50 literal = TRECIENTOS NOVENTA Y CINCO MILLONES TRECIENTOS SESENTA Y DOS MIL OCHOCIENTOS SESENTA Y NUEVE 50/100 BOLIVIANOS. 687611,50 literal = SEISCIENTOS OCHENTA Y SIETE MIL SEISCIENTOS ONCE 50/100 BOLIVIANOS. 46,50 literal = CUARENTA Y SEIS 50/100 BOLIVIANOS. 394625,50 literal = trecientos noventa y cuatro mil seiscientos veinte y cinco 50/100 Bolivianos. 686671871,50 literal = seiscientos ochenta y seis millones seiscientos setenta y un mil ochocientos setenta y un 50/100 Bolivianos. 860233047,50 literal = OCHOCIENTOS SESENTA MILLONES DOSCIENTOS TREINTA Y TRES MIL CUARENTA Y SIETE 50/100 BOLIVIANOS. 656477159,50 literal = SEISCIENTOS CINCUENTA Y SEIS MILLONES CUATROCIENTOS SETENTA Y SIETE MIL CIENTO CINCUENTA Y NUEVE 50/100 BOLIVIANOS. 99037,50 literal = NOVENTA Y NUEVE MIL TREINTA Y SIETE 50/100 BOLIVIANOS. 159180,50 literal = ciento cincuenta y nueve mil ciento ochenta 50/100 Bolivianos. 69993,50 literal = SESENTA Y NUEVE MIL NOVECIENTOS NOVENTA Y TRES 50/100 BOLIVIANOS. 76,50 literal = setenta y seis 50/100 Bolivianos. 74,50 literal = setenta y cuatro 50/100 Bolivianos. 4,50 literal = cuatro 50/100 Bolivianos. 572356,50 literal = QUINIENTOS SETENTA Y DOS MIL TRECIENTOS CINCUENTA Y SEIS 50/100 BOLIVIANOS. 85,50 literal = OCHENTA Y CINCO 50/100 BOLIVIANOS. 678977004,50 literal = seiscientos setenta y ocho millones novecientos setenta y siete mil cuatro 50/100 Bolivianos. 311275,50 literal = TRECIENTOS ONCE MIL DOSCIENTOS SETENTA Y CINCO 50/100 BOLIVIANOS. 888,50 literal = OCHOCIENTOS OCHENTA Y OCHO 50/100 BOLIVIANOS. 861740125,50 literal = OCHOCIENTOS SESENTA Y UN MILLONES SETECIENTOS CUARENTA MIL CIENTO VEINTE Y CINCO 50/100 BOLIVIANOS. 370246,50 literal = trecientos setenta mil doscientos cuarenta y seis 50/100 Bolivianos. 986444,50 literal = novecientos ochenta y seis mil cuatrocientos cuarenta y cuatro 50/100 Bolivianos. 202,50 literal = DOSCIENTOS DOS 50/100 BOLIVIANOS. 407295,50 literal = CUATROCIENTOS SIETE MIL DOSCIENTOS NOVENTA Y CINCO 50/100 BOLIVIANOS. 522,50 literal = QUINIENTOS VEINTE Y DOS 50/100 BOLIVIANOS. 378878653,50 literal = TRECIENTOS SETENTA Y OCHO MILLONES OCHOCIENTOS SETENTA Y OCHO MIL SEISCIENTOS CINCUENTA Y TRES 50/100 BOLIVIANOS. 712142,50 literal = SETECIENTOS DOCE MIL CIENTO CUARENTA Y DOS 50/100 BOLIVIANOS. 588737075,50 literal = QUINIENTOS OCHENTA Y OCHO MILLONES SETECIENTOS TREINTA Y SIETE MIL SETENTA Y CINCO 50/100 BOLIVIANOS. 946540,50 literal = novecientos cuarenta y seis mil quinientos cuarenta 50/100 Bolivianos. 34667457,50 literal = treinta y cuatro millones seiscientos sesenta y siete mil cuatrocientos cincuenta y siete 50/100 Bolivianos. 391874,50 literal = trecientos noventa y un mil ochocientos setenta y cuatro 50/100 Bolivianos. 745,50 literal = SETECIENTOS CUARENTA Y CINCO 50/100 BOLIVIANOS. 670024,50 literal = seiscientos setenta mil veinte y cuatro 50/100 Bolivianos. 703029,50 literal = setecientos tres mil veinte y nueve 50/100 Bolivianos. 745,50 literal = setecientos cuarenta y cinco 50/100 Bolivianos. 975415558,50 literal = NOVECIENTOS SETENTA Y CINCO MILLONES CUATROCIENTOS QUINCE MIL QUINIENTOS CINCUENTA Y OCHO 50/100 BOLIVIANOS. 294,50 literal = DOSCIENTOS NOVENTA Y CUATRO 50/100 BOLIVIANOS. 559794,50 literal = quinientos cincuenta y nueve mil setecientos noventa y cuatro 50/100 Bolivianos. 23,50 literal = veinte y tres 50/100 Bolivianos.

586335,50 literal = QUINIENTOS OCHENTA Y SEIS MIL TRECIENTOS TREINTA Y CINCO 50/100 BOLIVIANOS. 14174901,50 literal = catorce millones ciento setenta y cuatro mil novecientos un 50/100 Bolivianos. 529551002,50 literal = quinientos veinte y nueve millones quinientos cincuenta y un mil dos 50/100 Bolivianos. 930,50 literal = NOVECIENTOS TREINTA 50/100 BOLIVIANOS. 581617,50 literal = quinientos ochenta y un mil seiscientos diecisiete 50/100 Bolivianos. 44,50 literal = CUARENTA Y CUATRO 50/100 BOLIVIANOS. 727302804,50 literal = SETECIENTOS VEINTE Y SIETE MILLONES TRECIENTOS DOS MIL OCHOCIENTOS CUATRO 50/100 BOLIVIANOS. 66,50 literal = SESENTA Y SEIS 50/100 BOLIVIANOS. 34618398,50 literal = TREINTA Y CUATRO MILLONES SEISCIENTOS DIECIOCHO MIL TRECIENTOS NOVENTA Y OCHO 50/100 BOLIVIANOS. 477354079,50 literal = CUATROCIENTOS SETENTA Y SIETE MILLONES TRECIENTOS CINCUENTA Y CUATRO MIL SETENTA Y NUEVE 50/100 BOLIVIANOS. 813,50 literal = OCHOCIENTOS TRECE 50/100 BOLIVIANOS. 634888270,50 literal = SEISCIENTOS TREINTA Y CUATRO MILLONES OCHOCIENTOS OCHENTA Y OCHO MIL DOSCIENTOS SETENTA 50/100 BOLIVIANOS. 219544,50 literal = DOSCIENTOS DIECINUEVEMIL QUINIENTOS CUARENTA Y CUATRO 50/100 BOLIVIANOS. 51,50 literal = cincuenta y un 50/100 Bolivianos. 435640,50 literal = CUATROCIENTOS TREINTA Y CINCO MIL SEISCIENTOS CUARENTA 50/100 BOLIVIANOS. 557896,50 literal = quinientos cincuenta y siete mil ochocientos noventa y seis 50/100 Bolivianos. 36,50 literal = TREINTA Y SEIS 50/100 BOLIVIANOS. 710,50 literal = SETECIENTOS DIEZ 50/100 BOLIVIANOS. 850,50 literal = OCHOCIENTOS CINCUENTA 50/100 BOLIVIANOS. 230498844,50 literal = doscientos treinta millones cuatrocientos noventa y ocho mil ochocientos cuarenta y cuatro 50/100 Bolivianos. 104296,50 literal = ciento cuatro mil doscientos noventa y seis 50/100 Bolivianos. 1,50 literal = UN 50/100 BOLIVIANOS. -0100100,70 literal = null 003,70 literal = tres 70/100 Bolivianos. 28,745 literal = null 0,5 literal = CERO 5/100 BOLIVIANOS. 999999999 literal = NOVECIENTOS NOVENTA Y NUEVE MILLONES NOVECIENTOS NOVENTA Y NUEVE MIL NOVECIENTOS NOVENTA Y NUEVE 00/100 BOLIVIANOS. 9999999999 literal = null 48803770 literal = cuarenta y ocho millones ochocientos tres mil setecientos setenta 00/100 Bolivianos. 20004.70 literal = VEINTE MIL CUATRO 70/100 BOLIVIANOS.

Fuente: http://jc-mouse.blogspot.com/2011/04/convertir-numeros-letras-en-java-tipo.html Datos en un jtexfield Maysculas y minsculas en jtextfield -Para mayusculasprivate void txtNombreTipoMantenimientoKeyReleased(java.awt.event.KeyEvent evt) { txtNombreTipoMantenimiento.setText(txtNombreTipoMantenimiento.getText().toUpperCase ()); }

Para minusculasprivate void txtNombreTipoMantenimientoKeyReleased(java.awt.event.KeyEvent evt) { txtNombreTipoMantenimiento.setText(txtNombreTipoMantenimiento.getText().toLowerCase ()); }

No permitir nmerosprivate void txtNombreCargoKeyTyped(java.awt.event.KeyEvent evt) { // lee la tecla presionada int k=(int)evt.getKeyChar(); // chequea en ASCII si esta entre los numeros de las teclas q son numeros if (k > 47 && k < 58) { evt.setKeyChar((char)KeyEvent.VK_CLEAR); JOptionPane.showMessageDialog(null,"No puede ingresar numeros!!!","Ventana Error Datos",JOptionPane.ERROR_MESSAGE); } // si la tecla presionada es enter transfiere el foco if(k==10){

} }

txtNombreCargo.transferFocus();

Fuente: http://www.forosdelweb.com/f45/auxilio-extraer-datos-jtable-jtextfield-624066/ jtextField solo numerico Bueno aqui te dejo un ejmplo lo debes poner en el Evento KeyTyped del jtextfield

private void txtCompraKeyTyped(java.awt.event.KeyEvent evt) { int k=(int)evt.getKeyChar(); if (k >= 97 && k =65 && k menor que....................................................................< mayor o igual que........................................................>= menor o igual que........................................................ valor -1 y < valor+1 6. Cuando se comparan textos == no funciona y debe ser utilizada la palabra equals as: forma 1String s="hola"; if (s.equals("prueba")==true){ //bloque de verdad

}

forma 2String variable=""; if ("prueba".equals(variable)){ //bloque de verdad }

forma 3String var1="",var2=""; if ( var1.equals(var2)){ //bloque de verdad }

forma 4String 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; if ((getLength() + str.length()) 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 MySQLpublic Vector ListaDeObjetosParaComboBox() { Connection conexion; conexion = ConexionBD.obtenerConexion(); try { ResultSet resultado; Statement sentencia; sentencia=conexion.createStatement(); resultado=sentencia.executeQuery("SELECT * FROM ObjetoParaComboBox"); Vector data=new Vector(); 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;

private String host; private String url; private Connection conn = null; private Statement stm; private ResultSet rs; public Conexion(String usuario, String contrasea, String bd, String servidor) { this.user = usuario; this.password = contrasea; this.db = bd; this.host = servidor; this.url = "jdbc:mysql://" + this.host + "/" + this.db; } public void conectar() { try { Class.forName("org.gjt.mm.mysql.Driver"); conn = DriverManager.getConnection(url, user, password); if (conn != null) { System.out.println("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); } } public void consultar() throws SQLException { rs = stm.executeQuery("SELECT * FROM usuarios"); while(rs.next()) { System.out.println(rs.getString("nombre")); System.out.println(rs.getString("contrasea")); } } public void actualizar() throws SQLException { stm.execute("UPDATE usuarios SET nombre='nombre usuario' WHERE id="+1); } public void insertar() throws SQLException { stm.execute("INSERT INTO usuarios (nombre, contrasea) VALUES ('new_name', 'new_Pass')"); } public void eliminar() throws SQLException { stm.execute("DELETE FROM usuarios WHERE id="+1); } }

nicamente resta crear una instancia de la clase y empezar a utilizar sus 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); } }

public String getDb() { return db; } public void setDb(String db) { this.db = db; } public String getHost() { return host; } public void setHost(String host) { this.host = host; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } public String getUser() { return user; } public void setUser(String user) { this.user = user; } public ResultSet consultar(String tabla) throws SQLException { rs = stm.executeQuery(SELECT * FROM + tabla); return rs; } public String buscarNombre(String tabla, String nombre) throws SQLException { String name = null; try{ rs = stm.executeQuery(SELECT * FROM + tabla + WHERE nombre = + nombre + LIMIT); rs.next(); name = rs.getString(2); }catch(SQLException ex){System.out.println(ex);} return name; } public void insertar(Hashtable usuario) { try { stm.execute(INSERT INTO usuarios (nombre, contrasea) VALUES ( + usuario.get(nombre) + , + usuario.get(contrasea) + )); }catch (SQLException ex) { System.out.println(ex); } } public void actualizar(String tabla, Hashtable usuario, String nombre) { try { stm.execute(UPDATE + tabla + SET nombre= + usuario.get(nombre) + WHERE nombre= + nombre + ); }catch (SQLException ex) { System.out.println(ex); } } public void eliminar(String tabla, String nombre) { try { stm.execute(DELETE FROM + tabla + WHERE nombre= + nombre + ); }catch (SQLException ex) { System.out.println(ex); } } }

Como podemos observar, esta clase cuenta con sobrecarga de constructores lo cual nos permite conectarnos de 2 maneras distintas a la base de datos. La primera es utilizar el constructor que no recibe 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 eliminar un registro simplemente le ejecutamos el mtodo correspondiente y le pasamos como parametros la tabla y el nomrbe del usuario a eliminar:con.eliminar(tabla, frago);

Para actualizar un registro le tenemos que pasar 3 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.

//Instanciamos la clase de conexion Conexion cxn = new Conexcion(); //Generamos un insert en la tabla de clientes usando el metodo ejecutar de la clase conexin string msg = cxn.Ejecutar(INSERT INTO tpjclientes (nombre,apellidos) VALUES (Juan,'Perez); //Generamos un select a la tabla de clientes, el resultado caera en resultset ResultSet = cxn.Consulta(SELECT * FROM tpjclientes);

NOTA IMPORTANTE: Las funciones o metodos utilizados, regresan un tipo de datos o componente especifico, es por ello que en ejecutar el resultado lo guardo en eun string y en consulta lo guardo en n ResultSet, ademas hay que resaltar algo, java obliga a los usuarioa utilizar el clasico catch y try para manejar correctamente las exepciones que puedan existir dentro de la llamada al metodo, eso es todo por el dia de hoy espero les sea de gran utilidad este codigo, dejen sus comentarion y/o sugerencias de que desean ver sobre tecnologia en el blog. Fuente: http://jhodrickgg.wordpress.com/2007/11/30/conectar-mysql-a-java-netbeans/ Conectando PostgreSQL con Java En este mini tutorial intentar explicar la manera en conectar nuestra 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");

//La conexin con los parmetros necesariosConnection con = DriverManager.getConnection( url,"postgres","postgres");

//Abrimos la conexin y la iniciamos

Statement stmt = con.createStatement();

/*Un ResultSet es como en .NET un DataSet, un arreglo temporal donde se almacenar el resultado de la consulta SQL*/ResultSet rs;

//Una variable String para almacenar la sentencia SQLrs = stmt.executeQuery(query);

String query = "select id as ID from moo.usuarios";

//En el ResultSet guardamos el resultado de ejecutar la consulta //En un ciclo while recorremos cada fila del resultado de nuestro Selectwhile ( 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 conexinstmt.execute("END"); stmt.close(); con.close(); } catch( Exception e ){

//Por si ocurre un error

System.out.println(e.getMessage());

e.printStackTrace(); } } }

Para realizar todo aquello diferente a un Select, utilzaremos lo siguiente: /*Variable para almacenar la URL de 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 DriverClass.forName("org.postgresql.Driver");

//La conexin con los parmetros necesarios //Abrimos la conexin y la iniciamos

Connection con = DriverManager.getConnection( url,"postgres","postgres"); Statement stmt = con.createStatement();

//Una variable String para almacenar la sentencia SQL //Ejecutamos la consulta SQL //Cerramos la conexinstmt.execute("END"); stmt.close(); con.close(); } catch( Exception e ){

String query = "update moo.usuarios set nombre = 'Mauricio' where id = '1'"; stmt.executeQuery(query);

//Por si ocurre un error System.out.println(e.getMessage()); e.printStackTrace(); } Es muy importante tener en cuenta que si este mtodo lo utilizas en una funcin para hacerla llamar cuando lo necesites, y quieras enviarle tanto argumentos como retornar resultados, en la funcin de Select las lneas siguientes NO deben de estar presentes:stmt.execute("END"); stmt.close(); stmt.execute("END");

Y en la parte de Update, Insert o Delete, solo la siguiente lnea: Espero que sea til esta informacin. Fuente: http://mygnet.net/articulos/java/conectando_postgresql_con_java.1162 ResultSet & JTable Basado en el tutorial Meter un ResultSet en un JTable veremos muy brevemente como hacerlo, destacando las principales lneas del cdigo.

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 -1) && (columna > -1)) System.out.println(modelo.getValueAt(fila,columna)); } });

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

Cambiar el tipo de dato con DefaultTableModel DefaultTableModel por defecto le dice al JTable que todos los datos que tiene son Object. A veces, porque queramos cambiar el TableCellRenderer o cualquier otro motivo, nos interesa que determinadas columnas se consideren como Boolean, como Integer o cualquier otro tipo de dato. Para modificar esto, tenemos que crearnos nuestro propio modelo de Datos. La forma ms sencilla es heredar de DefaultTableModel y redefinir el mtodo getColumnClass().public class MiModelo extends DefaultTableModel { /**Primera columna Boolean, segunda Integer y el resto Object */ public Class getColumnClass(int columna) { if (columna == 0) return Boolean.class; if (columna == 1) return Integer.class; return Object.class; } }

En el ejemplo se ha hecho que la primera columna sea de Boolean, la segunda de Integer y el resto de Object. Una cosa curiosa de los Boolean, es que el JTable al pintarlos los pone como JCheckBox. Hacer visible una fila concreta del JTable dentro de un JScrollPane Para que un JTable tenga barras de scroll y tenga una "cabecera" con las etiquetas de las columnas, es necesario meterla en un JScrollPane. Esto se puede hacer de dos formas.JTable tabla = new J