• Categories
• Net Beans
• Java (Lenguaje de programación)
• Entorno de desarrollo integrado
• Ventana (Computación)
• Programa de computadora

Citation preview

Tutorial: Como crear y ejecutar un proyecto Java en NetBeans Dandole seguimiento a la situación 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 guía para crear un proyecto Java en NetBeans. Acontinuación las capturas de los pasos a seguir y sus explicaciones: Ejecutamos el IDE NetBeans. Ya saben doble clic sobre el ícono en el escritorio o Inicio > Todos los programas > NetBeans > NetBeans IDE 6.7.1. Y esperamos a que cargue completamente. •

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

Tendremos una ventana como en la siguiente figura dónde seleccionamos el tipo de proyecto: Java > Java Application y damos clic en el botón Next. Categories: Java Projects: Java Application

En este paso vamos a escribir el nombre del proyecto que por convención Java, las primeras letras de las palabras que contenga serán en mayúsculas: ProyectoPrueba. Project Name: ProyectoPrueba También deseleccionamos las casillas: Create Main Class y Set as Main Proyect. Damos clic en el botón Finish. •

•

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

Definimos el nombre del paquete, de misma forma que con los proyectos, por convención Java, el nombre de los paquetes debe estar totalmente en minúsculas: proyectoprueba. Package Name: proyectoprueba •

•

Creamos(agregamos) una clase a nuestro proyecto dando clic derecho sobre el paquete del paso anterior: New > Java Class.

Definimos el nombre de nuestra clase, que por convención Java, las letras iniciales de cada palabra que contenga el nombre estarán en mayúsculas y sin espacios. Class Name: Main. •

Ahora vamos a agregar o añadir codigo a nuestra clase para que tenga algún comportamiento en su ejecución. Método main() 1 public static void main(String[] args) { 2 System.out.println("Proyecto en NetBeans terminado(:"); 3 } •

Para ejecutar un proyecto Java en NetBeans tenemos dos opciónes: Clic en el botón Run Project, el cúal ejecutará la clase que contenga el método main(). Seleccionamos la clase que contenga el método main() y deseemos ejecutar, damos clic derecho sobre dicha clase y seleccionamos Run File. •

•

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

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

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

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

Una vez que hayamos descargado el paquete debemos correr el instalador. Después de aceptar la licencia nos pregunta dónde queremos instalar y al final instala todos los componentes necesarios. Una vez terminado de instalar debemos buscar el ícono de NetBeans en el escritorio o en el menú inicio.

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

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

En la ventana de seleccionar módulos presiona el botón Add y selecciona los módulos que se encontraban dentro del archivo que descargaste en el primer paso.

5. Acepta el contrato de licencia y reinicia el IDE. Un IDE es una herramienta que nos permite escribir código y compilar, en este caso se refiere a NetBeans.

Paso 3: Ahora vamos a continuar con la creación del proyecto en sí. En esta pantalla podemos encontrar todas las herramientas necesarias para crear y manejar nuestros proyectos hechos en Java. Por el momento presiona el botón de nuevo proyecto. En la ventana que aparece selecciona un nuevo proyecto de Java.

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

Al terminar aparecerá la ventana de código en la que podemos comenzar a codificar nuestra aplicación.

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

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

(o presiona F6). En la parte inferior de la pantalla debe aparecer el

¡Felicidades! Has creado tu primera aplicación Java con NetBeans, pero esto no es lo que queremos que vea un cliente final. Para que un programa sea útil para cualquier persona es necesario que tenga una

interfaz gráfica así que vamos a utilizar Swing para crear una interfaz gráfica que nos muestre el mismo mensaje. Swing es un conjunto de librerías con las que cuenta Java para crear y mostrar una interfaz gráfica. Dentro de estas librerías hay varias clases(recuerda, una clase es como un molde con el que podemos hacer objetos) que nos permiten mostrar ventanas, mensajes, botónes, cajas de texto e incluso imágenes, audio o video. Una de las clases más importantes de Swing es JFrame. Esta clase es una ventana que tiene un contenedor en el que podemos poner controles.

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

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

Paso 6: El error que nos marca NetBeans es que no conoce el símbolo. Esto quiere decir que no sabe qué es un JFrame, para resolver este tipo de errores debemos agregar la librería de la que hablaba hace unos momentos, en estos momentos todavía no sabemos dónde está, pero por suerte NetBeans también nos muestra un foquito a la izquierda en el que, al hacer click, nos brinda una solución. No siempre podemos confiar en las soluciones que brinda NetBeans porque después de todo es una herramienta y no una persona que nos está haciendo la recomendación, pero muchas veces su sugerencia es acertada, como en este caso que dice que debe agregar un import(veremos más sobre este tema más adelante). Selecciona la opción y debe aparecer una línea al principio de nuestra clase en la que resuelve el error.

Paso 7: Como vimos en la parte de arriba el método Main(con mayúscula) es el constructor de la clase. Este es el método con el que vamos a crear nuevos objetos de nuestra clase(que es una ventana). Dentro de este método debemos escribir algunas líneas de código para darle un tamaño a la ventana y para que se muestre. Copia el código que se muestra en la siguiente imágen:

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

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

Paso 8: Por último debemos crear un nuevo objeto de nuestra ventana, esto es muy sencillo y lo logramos agregando la línea que se ve en la imágen dentro del método main()(con minúscula).

Esta línea está creando un nuevo objeto de la clase Main mandando llamar el constructor que acabamos de crear. Compila tu programa haciendo click en el botón compilar

y luego córrelo haciendo click en

el botón correr . Con esto se muestra una ventana vacía, ya casi hacemos el programa que queríamos, pero nos falta un mensaje. Para eso vamos a utilizar otra clase de Swing que se llama JLabel. En la parte superior del constructor escribe el código como se ve en la imagen:

Una vez más la primera línea va a ser subrayada en rojo porque nos falta importar una librería. Ahora vamos a utilizar otra técnica para resolver este mismo error. Haz click derecho sobre el código y selecciona la opción "Fix Imports". Con esto NetBeans revisará todo el código y automaticametne va a agregar todas las librearías que necesitamos. En el código lo que estamos haciendo es crear un nuevo JLabel. Su nombre será lblHola(por convención todos los JLabel deben empezar su nombre con lbl) y este JLabel va a ser un nuevo JLabel que diga "Hola". Después agregamos el JLabel al contenedor de la ventana. ¡Felicidaes, hemos terminado nuestra primera aplicación en NetBeans utilizando interfaz gráfica! Una vez que hayas terminado tu programa debes comprimir el directorio de la aplicación que seleccionaste en el paso 2 y mandarlo por blackboard. Fuente: http://www.magusoft.net/compuv/01_Netbeans.html

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

Como se puede observar un String para el nombre del servidor, otro para la base de datos, un entero para el número del puerto(que por default el 3306 siempre es de MySQL). Este JFrame sirve como la base de algún programa, pues como lleva Strings Estáticos no hay necesidad de volverlo a crear solo de exportar, por ejemplo si alguno de ustedes necesita que invocar en otro Frame el nombre del servidor lo único que debes de hacer es poner lo siguiente: String url = "jdbc:mysql://" + conx.Exe5 + ":" + port + "/" + dataBase; Fuente: http://www.taringa.net/posts/info/6407848.R/Conexion-a-una-base-de-datos-en-MySQL-conJava.html

TaT CambiarIconoJFrame Cómo cambiar el ícono de un JFrame en cinco pasos. Paso 1 El ícono debe ser una imagen de extensión PNG. Esto se hace más fácil, ya que conseguir una figura y convertirlo en formato .ico es muy complicado. Los PNG nos ayudan bastante. Paso 2 La imagen que será el ícono debe estar dentro del paquete de fuentes, como si fuera una clase más. Si estuviera dentro de un paquete, sería mucho mejor.

Paso 3 En el código del JFrame que vamos a poner el ícono, sobreescribimos el método getIconImage() conteniendo el siguiente código: (notar cómo se está llamando a la imagen .png) @Override public Image getIconImage() { Image retValue = Toolkit.getDefaultToolkit(). getImage(ClassLoader.getSystemResource("resources/icono.png")); return retValue; }

Paso 4 En la vista de diseño del JFrame, lo seleccionamos y vamos sus propiedades, buscamos la propiedad "iconImagen" y hacemos clic en el botón de puntos suspensivos. Se mostrará una ventana de diálogo como esta:

De la lista desplegable, seleccionamos "Valor de componente existente". Esto hará que cambie la ventana a la siguiente forma:

Seleccionamos la opción "Propiedad" y hacemos clic en el botón de puntos suspendidos. Aparecerá una ventana de diálogo más pequeña, y seleccionamos la propiedad "iconImage" que aparece ahí.

Clic en Aceptar, y se verá así:

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

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

Fuente: http://wiki.netbeans.org/TaT_CambiarIconoJFrame

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

Los JDialog no tienen este método, pero heredan el icono de su ventana padre. Por ello, basta con crearlos pasándoles como padre en el constructor un JFrame que tenga el icono cambiado, o bien otro JDialog que a su vez se le haya cambiado el icono JDialog dialog = new JDialog (frame);

Abrir y cerrar ventanas secundarias (JDialog) desde la primaria (JFrame) En el siguiente código de ejemplo, una ventana principal JFrame tiene un botón para abrir una ventana secundaria JDialog. import import import import

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;

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

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

});

public void windowClosed(WindowEvent e) { ventanaPrincipal.setVisible(true); ventanaSecundaria.setVisible(false); }

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

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

Para que el método pack() dé un tamaño adecuado a la ventana es necesario que la ventana ya tenga dentro los componentes y que estemos usando un Layout que no sea null. Desde la versión 1.4 del JDK existe un método de la clase JWindow que realiza la operación de centrar la ventana sobre otro componente especifico. Este método es setLocationRealtiveTo(JComponenet otroComponente), donde otroComponente es cualquier componente sobre el que queremos que salga centrada la ventana p.e: JFrame, JDialog, JButton, JTextField, etc... // La ventana saldrá centrada sobre el botón unBotón. v.setLocationRelativeTo (unBotón);

Si se pasa null como valor a este parámetro, entonces la ventana se centrara justo al centro de la pantalla del PC... // La ventana saldrá centrada en pantalla. v.setLocationRelativeTo (null);

Fuente: http://chuwiki.chuidiang.org/index.php?title=JFrame_y_JDialog Creación de la Clase SelectorColoresMarc El selector de colores lo crearemos en una ventana siguiendo los siguientes pasos: nos situamos en la ventana Projects y con el botón derecho del ratón seleccionamos el paquete paqawt. Entonces elegimos New | Other...

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

.

se abre el cuadro de diálogo New Frame Form. En el campo de texto Class Name: introducimos el nombre de la Clase SelectorColoresMarc y finalmente hacemos clic sobre el botón

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

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

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

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

initComponents();

}

cuando se está creando el Objeto se llama al Constructor y éste a su vez realiza una invocación al método initComponents() en entornos de desarrollo como por ejemplo JBuilder, en vez de llamar a este método hubiera llamada al método jbInit(). Estos IDEs se crean un método propio donde depositan el código Java referente a la parte

visual. Así cuando pasamos del entrono de codificación al entrono visual el parsing de código java a entorno visual lo realizan de una forma más rápida y optimizada. el código de este método ya lo estudiaremos más adelante. new SelectorColoresMarc().setVisible(true); como podemos observar el Asistente no nos ha creado un código con una variable de referencia como por ejemplo SelectorColoresMarc marco = new SelectorColoresMarc(); marco.setVisible(true);

por que en este caso ha considerado que la variable de referencia marc no la necesita. Simplemente crea un Objeto de tipo SelectorColoresMarc y seguidamente en la misma línea de código ya habla con uno de sus métodos sin necesidad de utilizar una variable de referencia. el método setVisible(true) se utiliza para mostrar en pantalla el Objeto SelectorColoresMarc que ya está instanciado en memoria. Más adelante ya veremos como las aplicaciones gráficas primero se construyen en memoria y seguidamente cuando todos sus componentes ya están inicializados se muestran dichos componentes en la pantalla. Ahora ejecutamos esta Clase, y vemos una ventana sin dimensiones

Para que el Frame (marco, ventana) tenga dimensiones, vamos a modificar el código perteneciente al método main(...) package paqawt; public class SelectorColoresMarc extends java.awt.Frame { public SelectorColoresMarc() { initComponents(); } private void initComponents() { addWindowListener(new java.awt.event.WindowAdapter() { public void windowClosing(java.awt.event.WindowEvent evt) { exitForm(evt); } }); pack(); } private void exitForm(java.awt.event.WindowEvent evt) { System.exit(0); } public static void main(String args[]) { SelectorColoresMarc marco = new SelectorColoresMarc(); marco.setSize(300,200); marco.setTitle("Selector de colores"); marco.setVisible(true); } }

Y ahora ya podemos ejecutar esta Clase para ver una ventana con dimensiones. Fuente: http://www.javadabbadoo.org/cursos/infosintesis.net/javase/paqawt/selectorcolores/paso01operativa.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 también lo hacían pero ahora hay mas opciónes de administración).

1.-Como siempre nos vamos a la opción Presentaciones(ejecución o RUNTIME). Seguidamente en le icono de Base de datos(click derecho y buscar en Nueva Conexión)

2.-Al dar en nueva conexón nos saldrá la siguiente interfaz donde tendremos que colocar la información de tu BD(en este caso MySql).

Adicionalmente decir que te piden el driver dependiendo de la conexion en este caso del mysql conector. 3.-Al conectarte te saldrá el icono con el nombre de tu BD, para ejecutar comandos sólo ponemos click derecho EJECUTAR COMANDO...

4.-Escribimos la sentencia y ejecutamos.

Como ven hay más opciónes que en las versiones anteriores como en el 5.5 sólo teniamos para ser sentencia entre otras cosas.Pero ahora tenemos para limpiar Tabla,actualizar registros,insertar registros,entre otros. Fuente: http://javaycafe.blogspot.com/2009/01/comandos-sql-desde-netbeans.html

Conectando PostgreSQL con NETBEANS JAVA En este pequeño tutorial enseñaré la forma de conectar nuestra base de datos PostgreSQL 8.3 con el IDE Netbeans, es muy sencillo, antes que todo necesitamos bajar nuestro Driver, el cual nos permitira conectarnos y hacer puente entre ambos DESCARGAR Una vez ya descargado estaríamos en condiciones para poder conectarnos. Abrimos NetBeans y vamos al Menú Herramientas (Tools) y luego a Librerías, ahí seleccionamos “Nueva Librería” nos aparece “Nombre de librería” digitamos PostgreSQL y dejamos la opción por default en el campo tipo de librería y presionamos el botón Ok.

Luego presionamos el Botón Add Jar/Folder, ahí seleccionamos nuestro driver que acabamos de descargar, el cual se deberia llamar postgresql-8.3-603.jdbc4.jar y presionamos OK. y en la siguiente ventana tambien OK. Con esto estamos en condiciones de hacer nuestro primer programa que se conecte con la base de datos desde java. Ahora haremos la conexion con nuestra base de datos package ejemplo; import java.sql.*; // importamos java.sql para poder trabajar con SQL public class Main { public Main() { } public static void main(String[] args) { String driver = “org.postgresql.Driver”; // el nombre de nuestro driver Postgres. String connectString = “jdbc:postgresql://localhost:5432/ejemplo/”; // llamamos nuestra bd String user = “postgres”; // usuario postgres String password = ” “; // no tiene password nuestra bd. try { Class.forName(driver); //Hacemos la coneccion. Connection conn = DriverManager.getConnection(connectString, user, password); //Si la conexion fue realizada con exito, muestra el sgte mensaje. System.out.println(“Conexion a la base de datos Ejemplo realizada con exito! “); //Cerramos la conexión conn.close(); } //Si se produce una Excepción y no nos podemos conectar, muestra el sgte. mensaje. catch(SQLException e) { System.out.println(“Se ha producido un error en la conexion a la base de datos Ejemplo! “); } } Fuente: http://migue85.wordpress.com/2008/07/11/conectando-postgresql-con-netbeans-java/

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

4. Hacemos doble clic en el botón “Cargar datos” y colocamos el siguiente código: sourcecode language=’java’ [ TestConnection conexion = new TestConnection(); conexion.conectar(); ]

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

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

Y como nombre al proyecto le ponemos "LlenarJTable"

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

3.2. Diseño del Formulario Debemos de diseñar el siguiente formulario:

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

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

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

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

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

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

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

Ahora vamos a crear nuestro formulario principal, haciendo clic en FILE después en NEW FILE como en la siguiente imagen:

Escogemos en categorías escogemos SWING GUI FORMS y tipo de archivo JDIALOG FORM y de pues hacemos clic en NEXT> como en la siguiente imagen:

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

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

Peo esta vez no escogemos JDIALOG FORM si no que JPANEL FORM de SWING GUI FORM como se muestra en la siguiente imagen:

Luego clic en NEXT y luego le ponemos un nombre en mi caso “Fondo” como en la siguiente imagen:

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

Le arrastramos un JLabel1 y le ampliamos su tamaño por todo el formulario agarrándole de una esquina y agrandándole hasta que tape todo el formulario Fondo:

Ahora nos vamos a las propiedades del JLabel1 que está en la parte derecha y borramos su propiedad TEXT para que no se vea el título JLABEL1 y hacemos clic en la propiedad ICON en su botón buscar que está representado por un botón de tres puntos suspensivos como se muestra en la figura:

Luego nos saldrá una ventana done tenemos que elegir la imagen de fondo que queremos, como en la siguiente imagen:

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

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

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

Hacemos clic en Principal para entrar en el formulario Principal luego en clic en SOURCE para entrar en su código:

Luego buscamos las líneas siguientes:

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

Ahora haz clic en el botón PLAY que es un triángulo verde: Y te pedirá que elijas en formulario principal:

Escoges Principal y listo ya tienes tu fondo pero solo se verá cuando se ejecute tu proyecto, recuerda que tienes que trabajar pone ido tus botónes y todo lo demás en el formulario Principal y n así en el formulario Fondo. Para cada formulario que quieres con fondo tienes que crear otro formulario Fondo. Bueno es muy largo porque en Java de esa forma se pone un fondo, en la práctica es relativamente corto y sencillo. Fuente: http://www.mailxmail.com/como-poner-fondo-formulario-java-netbeans_h

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

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

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

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

II.- MÉTODOS ATRIBUTOS static int EXIT_ON_CLOSE

La salida por defecto al cerrar una ventana.

CONSTRUCTORES JFrame() JFrame(String título)

Crea un nuevo frame que es inicialmente visible Crea un nuevo frame con el título indicado como parámetro

MÉTODOS Tipo de retorno Container

Método getContentPane()

int

getDefaultCloseOperation()

Descripción Retorna el objeto contentPane. Retorna la operación que ocurre cuando el usuario hace la operación 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)

Retorna el menúBar establecido en el frame Remueve el componente indicado como parámetro de éste contenedor Establece la propiedad del contentPane

Establece la operación que sucederá por defecto cuando el usuario cierra la ventana Establece la barra de menú para el frame Por defecto, la distribución de los paneles de éste componente no setLayout(LayoutManager layout) debe cambiarse; en su lugar, debería ser cambiada la distribución de su contentPane que generalmente es un panel.

III.- OTROS MÉTODOS Para Colocar el nombre en la ventana del JFrame: 1 this.setTitle(“Título del frame”); Para maximizar la ventana de JFrame 1 this.setExtendedState(this.MAXIMIZED_BOTH); Para desactivar el botón de cierre del JFrame 1 this.setDefaultCloseOperation(0) 1 this.setDefaultCloseOperation(this.DO_NOTHING_ON_CLOSE); Para hacer visible al frame 1 this.setVisible(true); OBSERVACION: Todos estos métodos se deben invocar en el constructor del JFrame; es decir: public Principal() { panAcces = new panAcceso(); admin = new Administrador(); listadoAlu = new ListaAlumnos(); initComponents(); fecha = new Fecha(); //Maximizar la ventana del JFrame this.setExtendedState(this.MAXIMIZED_BOTH); //Evita que se cierrre el frame con el botón salir esquivale a this.setDefaultCloseOperation(0); this.setDefaultCloseOperation(this.DO_NOTHING_ON_CLOSE); this.setTitle("SISTEMA INTEGRAL DE NOTAS - SIN"); lblFecha.setText("" + fecha.iniciarComponentes()); try { UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()); } catch (Exception e) { e.printStackTrace(); } } IV.- EJEMPLOS 1. Diseñe una aplicación con dos frames, uno de bienvenida y otro de despedida activados a través de botónes como se muestra a continuación : Fuente: http://javax0711.blogspot.com/2009/10/clase-jframe.html

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

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

}

private String getMillones(String numero) {//000 000 000 //se obtiene los miles String miles = numero.substring(numero.length() - 6); //se obtiene los millones String millon = numero.substring(0, numero.length() - 6); String n = ""; if(millon.length()>1){ n = getCentenas(millon) + "millones "; }else{ n = getUnidades(millon) + "millon "; } return n + getMiles(miles); }

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

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

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

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

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

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

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

txtNombreCargo.transferFocus();

} }

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

private void txtCompraKeyTyped(java.awt.event.KeyEvent evt) { int k=(int)evt.getKeyChar(); if (k >= 97 && k =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 1 String s="hola"; if (s.equals("prueba")==true){ //bloque de verdad

}

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

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

forma 4 String var1="",var2=""; if ( var1.equals(var2+"expresión")){ //bloque de verdad }

7. Cuando se define una variable dentro de un bloque, ésta solo "vive" para el bloque por tanto fuera de este sirve, para recordar el tema del ámbito ver clases anteriores La instrucción casos Es usada para determinar de entre un grupo de elementos cual de ellos es igual a uno dado. Su desventaja radica en que solo funciona para enteros int o char y en los casos solo pueden haber valores constantes, aclaro que este solo es un comportamiento de java otros lenguajes no la manejan o lo hacen de manera distinta.

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

private int limit; // optional uppercase conversion private boolean toUppercase = false; JTextFieldLimit(int limit) { super(); this.limit = limit; } JTextFieldLimit(int limit, boolean upper) { super(); this.limit = limit; toUppercase = upper; } @Override public void insertString (int offset, String str, AttributeSet attr) throws BadLocationException { if (str == null) return; if ((getLength() + str.length()) 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 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 ocasión veremos como ejecutar sentencias SQL en Java, tomando en cuenta la conexión que realizamos a la base de datos anteriormente. Para este ejemplo uso una tabla llamada “usuarios”, la cual tiene únicamente 3 campos: id(autoinc), nombre y contraseña El código de la clase es el siguiente: import java.sql.*; public class Conexion { private String user; private String password; private String db;

private String host; private String url; private Connection conn = null; private Statement stm; private ResultSet rs; public Conexion(String usuario, String contraseña, String bd, String servidor) { this.user = usuario; this.password = contraseña; this.db = bd; this.host = servidor; this.url = "jdbc:mysql://" + this.host + "/" + this.db; } public void conectar() { try { Class.forName("org.gjt.mm.mysql.Driver"); conn = DriverManager.getConnection(url, user, password); if (conn != null) { System.out.println("Conexión a base de datos "+url+" ... Ok"); stm = conn.createStatement(); } } catch(SQLException ex) { System.out.println("Hubo un problema al intentar conectarse con la base de datos +url); } catch(ClassNotFoundException ex) { System.out.println(ex); } } public void consultar() throws SQLException { rs = stm.executeQuery("SELECT * FROM usuarios"); while(rs.next()) { System.out.println(rs.getString("nombre")); System.out.println(rs.getString("contraseña")); } } public void actualizar() throws SQLException { stm.execute("UPDATE usuarios SET nombre='nombre usuario' WHERE id="+1); } public void insertar() throws SQLException { stm.execute("INSERT INTO usuarios (nombre, contraseña) VALUES ('new_name', 'new_Pass')"); } public void eliminar() throws SQLException { stm.execute("DELETE FROM usuarios WHERE id="+1); } }

Únicamente resta crear una instancia de la clase y empezar a utilizar sus métodos. Fuente: http://fragowb.wordpress.com/2008/05/08/ejecutar-sql-en-java/ Ejemplo de Java + SQL + Netbeans Después de un poco de retraso de este post y de tener un poco de tiempo sin postear algo, traigo este ejemplo (el tercero) de Java y MySQL bajo la plataforma Netbeans. El propósito de este post es crear una clase que realmente realiza las acciones básicas (agregar, modificar, eliminar, consultar) pero implementadas de una “mejor manera” comparada con los otros post que hay en este blog sobre este tema (tampoco quiero decir que sea la mejor ni mucho menos). La base de datos que usaremos para este ejemplo es la siguiente: • BD: prueba. • tabla: usuarios. • campos: id(autoinc), nombre, contraseña.

Diagrama de clases:

Bueno, primero que nada empezaremos con nuestra clase que contendrá los métodos de las acciones que vamos a realizar. import java.sql.*; import java.util.Hashtable; public class SQLconnection { private String user; private String password; private String db; private String host; private String url; private Connection conn = null; private Statement stm; private ResultSet rs; public SQLconnection() { this.url = “jdbc:mysql://” + this.host + “/” + this.db; } public SQLconnection (String server, String usuario, String contraseña, String bd) { this.user = usuario; this.password = contraseña; this.db = bd; this.host = server; this.url = “jdbc:mysql://” + this.host + “/” + this.db; } public void connectar() { try { Class.forName(“org.gjt.mm.mysql.Driver”); conn = DriverManager.getConnection(url, user, password); if (conn != null) { System.out.println(“Conexión a base de datos “+url+” … Ok”); stm = conn.createStatement(); } } catch(SQLException ex) { System.out.println(“Hubo un problema al intentar conectarse con la base de datos “+url); } catch(ClassNotFoundException ex) { System.out.println(ex); } }

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

Como podemos observar, esta clase cuenta con sobrecarga de constructores lo cual nos permite conectarnos de 2 maneras distintas a la base de datos. La primera es utilizar el constructor que no recibe ningún parámetro y definirlos mediante los métodos set y get para después llamar al método conectar.

La segunda es enviarle directamente los valores al constructor y, al igual que en la forma anterior, ejecutar el método conectar, y esta será la forma que usaremos para nuestro ejemplo. Primero que nada vamos a conectarnos a nuestra base de datos y realizaremos una consulta de todos los registros: SQLconnection con = new SQLconnection(“localhost”,“usuario”,“contraseña”,“prueba”); con.connectar(); ResultSet rs; rs = con.consultar(“usuarios”); while(rs.next()){ System.out.println(rs.getString(1)); System.out.println(rs.getString(2)); System.out.println(rs.getString(3)); }

En esta clase también implementamos una opción que nos permite realizar búsquedas por medio de nombres(es el campo de la base de datos que elegí para este ejemplo); ha este método le mandamos 2 parámetros, que son la base de datos y el nombre: System.out.println(con.buscarNombre(“usuarios”, “frago”));

Para insertar un nuevo registro vamos a hacer uso del Hastable para enviarle los valores que queremos agregar: Hashtable usuario = new Hashtable(); usuario.put(“nombre”,“frago”); usuario.put(“contraseña”,“xxx”); con.insertar(usuario);

Para eliminar un registro simplemente le ejecutamos el método correspondiente y le pasamos como parametros la tabla y el nomrbe del usuario a eliminar: con.eliminar(tabla, “frago”);

Para actualizar un registro le tenemos que pasar 3 parámetros al método. EL primero es el nombre de la tabla; el segundo es un Hastable en el que se incluya la modificación que se quiere realizar y el tercer es, en este caso, el nombre de la persona a la que se le va realizar la modificación: Hashtable usuario = new Hashtable(); usuario.put(“nombre”, “frago1″); con.actualizar(tabla, usuario, “frago”);

Fuente: http://fragowb.wordpress.com/2008/07/22/ejemplo-de-java-sql-netbeans/ CONECTAR MYSQL A JAVA (Netbeans) Conocemos la forma de conectar mysql o alguna base de datos como lo es Sql Server, Oracle, PosgreSQL a java perousando lis driversManager una forma visual muy practica pero muy compleja a la hora de mandar la aplicacion a alguna otra computadora, para olvidarnos de esto y no tener un desorden de codificaciones visuales en el form crearemos una clase de conexcion, en ella realizaremos un metodos para la conexion y otros dos para hacer las consultas y operaciones de insert y update a la base de datos. La Clase Para crear la clase de conexion en nuestra solucion damos clic en el boton de Agregar Archivo, o nos vamos a archivo una vez que nos aparesca la ventana de nuevo archivo escojemos la carpeta de Clases Java y el tipo de archivo Clase Java, una vez que nos ha creado la , empezamos bueno de esta seccion, la codificacion. Codificacion: Empezamos anexando la siguiente directiva que utilizaremos java.sql.*, esto nos permitira utilizar todos los componentes para la creacion de la conexion y otros metodos que utilizemos Ejemplo: Import java.sql.* Metodo de conexion , para el metodo de conexcion para ello utilizaremos los siguientes componentes: Connection, Statement y ResultSet, a continuacion generamos el metodo o en este caso el constructor de la clase. public Conexion() { try { Class.forName(“com.mysql.jdbc.Driver”); String url = “jdbc:mysql://localhost:3306/bdpruebrasjava”; cn= DriverManager.getConnection( url, “root”, “123456″ ); } catch(Exception ee)

{ System.out.println(“Error: ” + ee.getMessage()); } }

Si se observa detenidamente, se utiliza una variable string denominada url, que sera la direccion de nuestra base de datos, la primera linea nos crea la informacion del driver de conexion y por ultimo se genera dicha conexion usando la variable “cn” y asignandole los parametros de ruta de la base de datos,usuario y contraseña. Metodos Auxiliares Acontinuacion crearemos los metodos para generar los insert, update y deletes de los registros de la base de datos. public String Ejecutar(String sql) { String error=”"; Try { St=Conec.createStatement(); St.execute(sql); } catch(Exception ex) { error = ex.getMessage(); } return(error); }

El St es nuestro Statemen el cual generara el comando de ejecucion, para ello todo este comando lo mandamos en el parametro sql, la funcion es de tipo string, por ello se regresa la variable de tipo string error la cual contendra el error que pueda optenerce en el proceso de insert o update,o en su caso no traer nada debido a que la accion fue exitosa. Por ultimo creamos el metodo para ejecutar consultas para ello utilizaremos un componente llamado ResultSet. public ResultSet Consulta(String sql){ String error=”"; Try { St=Conec.createStatement(); reg=St.executeQuery(sql); } catch(Exception ee) { error = ee.getMessage(); } return(reg); }

Dentro de esta funcion volvemos a encontrar a nuestro Statement por lo anteriormente mencionado sera nuestro ejecutor de comandos del parametro sql el cual tendra como valor la consulta que deseamos ejecutar. Conclusion: Todas la variables de conexion (cn), Statement (St) y ResultSet(reg) fueron declaradas fuera de todos los metodos, es decir son globales y pueden verse en toda la clase no importa en que proceso lo utilizemos, y para saldar la duda, anteriormente dije que todos estos son metodos, asi es pero por que ejecutar y consulta los llame funciones, es sencillo recordemos algo de teoria, toda funcion retorna un valor es por ello que se le llama funciones a ejecutar y a consulta por que regresan el valor de la variable error y reg respectivamente. Uso Para terminar esta entrada, les dejo la forma de utilizar esta clase.

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

NOTA IMPORTANTE: Las funciones o metodos utilizados, regresan un tipo de datos o componente especifico, es por ello que en ejecutar el resultado lo guardo en eun string y en consulta lo guardo en n ResultSet, ademas hay que resaltar algo, java obliga a los usuarioa utilizar el clasico catch y try para manejar correctamente las exepciones que puedan existir dentro de la llamada al metodo, eso es todo por el dia de hoy espero les sea de gran utilidad este codigo, dejen sus comentarion y/o sugerencias de que desean ver sobre tecnologia en el blog. Fuente: http://jhodrickgg.wordpress.com/2007/11/30/conectar-mysql-a-java-netbeans/ Conectando PostgreSQL con Java En este mini tutorial intentaré explicar la manera en conectar nuestra aplicación hecha en JAVA con la Base de Datos de PostgreSQL. Primero, es necesario descargarse el JDBC Driver para PostgreSQL. Este se encuentra en la página http://jdbc.postgresql.org/index.html Obviamente, será necesario contar con nuestra Base de Datos funcionando para realizar las consultas necesarias. Posteriormente hay que determinar la manera de agregar este Driver a nuestro proyecto. NetBeans ofrece una manera mas que sencilla. Conociendo la ubicación de nuestro Driver y con el proyecto abierto, en el Panel de Proyectos, ubicamos en el Árbol de Proyecto la opción Libraries, clic Derecho en ella y seleccionamos Add JAR / Folder..., de esta manera estaremos agregando ej .JAR del Driver que descargamos. Esto nos crea en nuestro proyecto una carpeta llamada "dist" y en ella otra de nombre "lib" donde esta nuestro Driver. Ahora, teniendo lo necesario, podemos probar nuestra conexión con PostgreSQL y realizar lo que nos concierne, Altas, Bajas y Modificaciones a nuestras tablas. Para empezar, debemos de importar lo siguiente: import java.sql.*;

Cabe mencionar que hay una gran diferencia entre Select y Update, Insert o Delete, ya que no se aplican de igual manera. A continuación muestro el proceso para realizar un Select (en idioma geek, vamos a selectear) public class Main{ public static void main(String[] args){

/*Variable para almacenar la URL de conexión a nuestra Base de Datos, si esta estuviera en otra máquina, necesitariamos estar registrados en ella y contar con su IP*/ String url = "jdbc:postgresql://localhost/moo"; try{

//Acceso al Driver

Class.forName("org.postgresql.Driver");

//La conexión con los parámetros necesarios Connection con = DriverManager.getConnection( url,"postgres","postgres");

//Abrimos la conexión y la iniciamos

Statement stmt = con.createStatement();

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

//Una variable String para almacenar la sentencia SQL

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

//En el ResultSet guardamos el resultado de ejecutar la consulta rs = stmt.executeQuery(query);

//En un ciclo while recorremos cada fila del resultado de nuestro Select while ( rs.next()){

/*Aqui practicamente podemos hacer lo que deseemos con el resultado, en mi caso solo lo mande a imprimir*/ System.out.println(rs.getString("ID") + " " + rs.getString("ID")); }

//Cerramos la conexión stmt.execute("END"); stmt.close(); con.close(); } catch( Exception e ){

//Por si ocurre un error

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

e.printStackTrace(); } } }

Para realizar todo aquello diferente a un Select, utilzaremos lo siguiente: /*Variable para almacenar la URL de conexión a nuestra Base de Datos, si esta estuviera en otra máquina, necesitariamos estar registrados en ella y contar con su IP*/ String url = "jdbc:postgresql://localhost/moo"; try{

//Acceso al Driver Class.forName("org.postgresql.Driver");

//La conexión con los parámetros necesarios

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

//Abrimos la conexión y la iniciamos Statement stmt = con.createStatement();

//Una variable String para almacenar la sentencia SQL

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

//Ejecutamos la consulta SQL

stmt.executeQuery(query);

//Cerramos la conexión stmt.execute("END"); stmt.close(); con.close(); } catch( Exception e ){

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

Y en la parte de Update, Insert o Delete, solo la siguiente línea: stmt.execute("END");

Espero que sea útil esta información. Fuente: http://mygnet.net/articulos/java/conectando_postgresql_con_java.1162 ResultSet & JTable Basado en el tutorial Meter un ResultSet en un JTable veremos muy brevemente como hacerlo, destacando las principales líneas del código.

En primera instancia nos conectamos a la BD y ejecutamos la consulta SQL que nos llenará el ResultSet DriverManager.registerDriver(new com.mysql.jdbc.Driver()); //Reemplazar localhost, prueba, usuario y clave por los host de la base de datos, nombre de esquema, user y pass.

Connection conexion = DriverManager.getConnection("jdbc:mysql://localhost/prueba","usuario","clave"); Statement s = conexion.createº(); ResultSet rs = s.executeQuery("select * from persona"); Crear un JTable, pasando como parámetro un DefaultTableModel DefaultTableModel modelo = new DefaultTableModel(); JTable tabla = new JTable(modelo); Nos queda resolver como llenar el DefaultTableModel. Básicamente, la forma es esta: // Creamos las columnas. modelo.addColumn("id"); modelo.addColumn("nombre");

modelo.addColumn("nacimiento"); // Bucle para cada resultado en la consulta while (rs.next()) { // Se crea un array que será una de las filas de la tabla. Object [] fila = new Object[3]; // Hay tres columnas en la tabla

// Se rellena cada posición del array con una de las columnas de la tabla en base de datos. for (int i=0;i -1) && (columna > -1)) System.out.println(modelo.getValueAt(fila,columna)); } });

Hemos añadido un MouseAdapter para no tener que implementar todos los métodos del MouseListener. Con el método tabla.rowAtPoint() es posible enterarnos en qué fila de del JTable ha ocurrido el evento del ratón (el click en este caso). Para ello basta llamar a este método pasándole las coordenadas x,y del evento de ratón, que se obtienen con el método e.getPoint(). Una vez que sabemos la fila, debemos comprobar si es mayor que -1. El método rowAtPoint() nos devuelve -1 si pinchamos en el JTable, pero fuera de cualquier fila. Es el caso de que el JTable tenga un tamaño en pixels superior al que le corresponde según su número de filas. Lo mismo vale para columnAtPoint(). Una vez que tenemos la fila y sabemos que no es -1, es fácil a través del modelo obtener los datos correspondientes. En este caso se escribe por pantalla con un System.out.prinln() el valor de la fila y columna que se ha seleccionado. Hacer que una celda del JTable no sea editable Si usamos DefaultTableModel las celdas del JTable son editables por defecto. A veces esto no nos interesa y JTable no tiene métodos para impedirlo. La forma de decidir qué celdas son o no editables es hacer nuestro propio modelo de datos, nuestro TableModel. La forma sencilla de hacerlo es heredar de DefaultTableModel y redefinir el método isCellEditable() para que sirva a nuestros propósitos public class MiModelo extends DefaultTableModel { public boolean isCellEditable (int row, int column) { //Aquí devolvemos true o false según queramos que una celda //identificada por fila,columna (row,column), sea o no editable if (column == 3) return true; return false } }

En este ejemplo, hemos creado nuestro propio modelo de datos que hace que la columna 4 (los índices empiezan en cero) de la tabla sea editable y el resto no. Ahora simplemente instanciamos el JTable usando este modelo y rellenamos los datos igual que antes. MiModelo modelo = new MiModelo(); JTable tabla = new JTable(modelo);

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

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

JScrollPane scroll = new JScrollPane(tabla);

o bien JTable tabla = new JTable(); JScrollPane scroll = new JScrollPane(); scroll.setViewportView(tabla);

es bastante habitual al principio equivocarse y usar el método add(), que NO funcionará correctamente JTable tabla = new JTable(); JScrollPane scroll = new JScrollPane(); // Esto NO funciona. scroll.add(tabla);

Cuando tenemos un JTable metido dentro de un JScrollPane, a veces queremos que las barras de scroll se desplacen para que una determinada celda sea visible. No conozco una forma inmediata de hacerlo, pero una posible solución es esta. ... // Nos devuelve la posición en pixels de una celda en fila,columna Rectangle r = tabla.getCellRect( fila, columna, true); // Mueve el scroll para que el rectangulo sea visible scrollPane.getViewport().scrollRectToVisible (r);

http://www.chuidiang.com/chuwiki/index.php?title=JTable#JTable La JTable controla cómo se presentan los datos, siendo el TableModel quien controla los datos en sí mismos. Para crear una JTable habrá pues que crear un TableModel antes, normalmente. Se puede implementar, para ello, el interfaz TableModel, pero es mucho más simple heredar de la clase ayuda AbstractTableModel. El ejemplo java1416.java muestra esta circunstancia. import java.awt.*; import java.awt.event.*; import com.sun.java.swing.*; import com.sun.java.swing.table.*; import com.sun.java.swing.event.*; //El Modelo de la Tabla es el que controla todos los // datos que se colocan en ella class ModeloDatos extends AbstractTableModel { Object datos[][] = { {"uno","dos","tres","cuatro"}, {"cinco","seis","siete","ocho"}, {"nueve","diez","once","doce"}, }; //Esta clase imprime los datos en la consola cada vez //que se produce un cambio en cualquiera de las //casillas de la table class TablaListener implements TableModelListener { public void tableChanged( TableModelEvent evt ) { for( int i=0; i < j="0;" tabla =" new" panel =" new" frame =" new">

Una vez que se tiene un TableModel, ya sólo resta colocarlo en el constructor de JTable. Todos los detalles de presentación, edición y actualización están ocultos al programador. En este ejemplo, se coloca la JTable en un JScrollPane, por lo que es necesario un método especial en JTable. Las tablas pueden soportar un comportamiento más complejo. En el ejemplo java1417.java, se utiliza un método para cargar un array de ocho columnas por un ciento de filas y, posteriormente, la tabla es configurada para que muestre solamente las líneas verticales y permita la selección simultánea de la fila y columna en que se encuentre la celda marcada. import java.awt.*; import java.awt.event.*; import java.util.*; import com.sun.java.swing.*; import com.sun.java.swing.table.*; class java1417 extends JPanel { private JTable tabla; private JScrollPane panelScroll;

private String titColumna[]; private String datoColumna[][]; public java1417() { setLayout( new BorderLayout() ); //Creamos las columnas y las cargamos con los datos que van a //aparecer en la pantalla CreaColumnas(); CargaDatos(); //Creamos una instancia del componente Swing tabla = new JTable( datoColumna,titColumna ); //Aquí se configuran algunos de los parámetros que permite //variar la JTable tabla.setShowHorizontalLines( false ); tabla.setRowSelectionAllowed( true ); tabla.setColumnSelectionAllowed( true ); //Cambiamos el color de la zona seleccionada (rojo/blanco) tabla.setSelectionForeground( Color.white ); tabla.setSelectionBackground( Color.red ); //Incorporamos la tabla a un panel que incorpora ya una barra //de desplazamiento, para que la visibilidad de la tabla sea //automática panelScroll = new JScrollPane( tabla ); add( panelScroll, BorderLayout.CENTER ); } //Creamos las etiquetas que sirven de título a cada una de //las columnas de la tabla public void CreaColumnas() { titColumna = new String[8]; for( int i=0; i < datocolumna =" new" iy="0;" ix="0;" ventana =" new">

Aunque el ejemplo contiene un array relativamente grande de datos, la clase JTable no manipula demasiado bien grandes cantidades de información, resultando un rendimiento bastante pobre cuando se sobrepasan los 2000 elementos. http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte14/cap1413.html Fuente: http://yohanamoreno.blogspot.com/2008/04/jtable.html Ahora te pongo un pequeño ejemplo para que veas como obtener la tecla pulsada: private void formKeyReleased(java.awt.event.KeyEvent evt) { int code = evt.getKeyCode(); char caracter = evt.getKeyChar();}

Fuente: http://www.lawebdelprogramador.com/foros/Java/1017791-Evento_KeyPressed.html JavaScript » Capturar la tecla F5 con Javascript Veamos cuales son los pasos. Lo primero será saber que el usuario ha pulsado una tecla. Es por ello que deberemos de estar al tanto del evento onkeydown. Al cual le asignaremos una función de escucha. Bueno, el evento lo capturamos a nivel de página: document.onkeydown=capturarf5;

Como podemos ver, la función recibe el objeto event. Este será el que contenga la información de la tecla que el usuario ha pulsado. Empecemos a detallar la función capturarf5(). Lo primero que hay que saber es que el código de la tecla pulsada viaja en la propiedad event.which y que la tecla F5 tiene el código 116. Como la propiedad event.which no está recogida en ninguna especificación (de momento es del DOM Gecko, aunque

ampliamente reconocida) también tenemos que utilizar la propiedad e.keycode (de las implementaciones para el Internet Explorer) Así, para capturar el código de la tecla utilizamos la siguiente línea: var code = (e.keyCode ? e.keyCode : e.which);

Y si es el código 116.... pues, lo que queramos. ¿avisamos al usuario? if(code == 116) { alert("Pulsada la tecla F5"); }

Como podemos apreciar... un código muy sencillo. Por cierto, ¿esto evita un refresco de la página? Fuente: http://lineadecodigo.com/categoria/javascript/page/2/ Redondear decimales en Java Hola, en vista de diversas curiosidades para poder reducir los decimales en Java Netbeans, les dejo un pequeño tutorial donde explico paso a paso como redondear decimales en Java a la cantidad de decimales que se desee. Para los que deseen el código fuente del metodo redondear se los dejo a continuación: public double redondear(double numero, double ndecimal) { double factor = Math.pow(10, ndecimal); return (Math.round(numero * factor) / factor); }

Ahora procedo a explicar la función redondear: Para poder redondear un decimal es necesario aplicar el método Math.round (la cual redondea decimales al valor entero más próximo), cuando deseabamos redondear a 2 decimales multiplicabamos por 100 y luego procediamos a dividir entre 100, pero si lo pensamos detalladamente, 100 es igual que 102 por lo cual utilizamos la variable factor que será la encargada de multiplicar y dividir el numero 10 elevado a la cantidad de decimales que se desee. Es decir 102 = Math.pow(10,2) Si no entienden el método matemático solo tomen en cuenta que la cantidad de ceros es la cantidad de decimales luego de la coma, ahora procedo a desarrollarlo en java. Paso 1:

Paso 2:

Paso 3:

Paso 4:

Paso 5:

Paso 6:

Paso 7:

Paso 8:

Paso 9:

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

private button pasar_datosAction.... { String nombre="David"; int edad=20;

}

} ...

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

public class jdialog_secundario ... { private String nombre; private int edad;

}

public jdialog_secundario(...,...,String nombre,int edad); { this.nombre=nombre;//Aqui la variable this.nombre es David. this.edad=edad;//Aqui la variable this.edad es 20. //Una vez capturado las variables puedes mostrarlo en JTextField. } ...

Fuente: http://forodejava.com/showthread.php/631-Pasar-Datos-de-un-jDialog-a-otro-jDialog