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
• En este paso vamos a escribir el nombre del proyecto que por convención Java, las primeras letras de las palabras que contenga serán en mayúsculas: ProyectoPrueba.
Project Name: ProyectoPrueba
También deseleccionamos las casillas: Create Main Class y Set as Main Proyect. Damos clic en el botón Finish.
• Teniendo el proyecto creado, ahora agregaremos(creamos) un paquete diferente al predefinido. Damos clic derecho sobre <default package>: New > Java Package.
• Definimos el nombre del paquete, de misma forma que con los proyectos, por convención Java, el nombre de los paquetes debe estar totalmente en minúsculas: proyectoprueba.
Package Name: proyectoprueba
• Creamos(agregamos) una clase a nuestro proyecto dando clic derecho sobre el paquete del paso
• 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.
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.
Esto es lo que se llama una Clase en Java(esta clase en particular se llama Main, eso es un dato importante porque lo vamos a utilizar más adelante). Las clases son el fundamento de la programación orientada a objetos y podríamos decir que son el molde con el que hacemos nuevos objetos. Las clases tienen atributos y métodos. Los atributos son lo que nos dice cómo es esa clase, por ejemplo, los atributos de una persona son el color de ojos y el alto(entre muchos otros), los métodos son las acciones que puede realizar una clase, por ejemplo correr.
En el código que se genera automaticamente por NetBeans tenemos dos métodos, el método Main() que también se conoce como el constructor de la clase y el método main() que es el punto de inicio del programa(por las mayúsculas y minúsculas Main es diferente de main).
Paso 4:
Dentro del método main() escribe el siguiente código:
Una vez que lo hayas escrito presiona el botón de compilar (o F11). En la ventana de compilación deben aparecerte varios mensajes de compilación y debe terminar en BUILD SUCCESSFUL(total time: 7 seconds). Esto quiere decir que nuestra aplicación compiló de manera adecuada y estamos listos para correrla. Presiona el botón correr (o presiona F6). En la parte inferior de la pantalla debe aparecer el letrero "Hola!".
¡Felicidades! Has creado tu primera aplicación Java con NetBeans, pero esto no es lo que queremos que vea un cliente final. Para que un programa sea útil para cualquier persona es necesario que tenga una
interfaz gráfica así que vamos a utilizar Swing para crear una interfaz gráfica que nos muestre el mismo mensaje.
Swing es un conjunto de librerías con las que cuenta Java para crear y mostrar una interfaz gráfica. Dentro de estas librerías hay varias clases(recuerda, una clase es como un molde con el que podemos hacer objetos) que nos permiten mostrar ventanas, mensajes, botónes, cajas de texto e incluso imágenes, audio o video. Una de las clases más importantes de Swing es JFrame. Esta clase es una ventana que tiene un contenedor en el que podemos poner controles.
Como podemos ver en la imagen un JFrame es una ventana normal de Windows. Dentro de un JFrame existe algo llamado ContentPane. Un ContentPane es un contenedor de controles en el que podemos agregar los elementos de la interfaz gráfica. Ahora veamos otro control importante en la generación de interfaces gráficas. El JLabel es una etiqueta con la que podemos motrar texto en nuestras aplicaciones. Un JLabel es una herramienta muy poderosa ya que nos permite agregar texto, cambiar el formato, la posición, agregar imágenes y muchas cosas más. Vamos a crear una clase que sea un JFrame y después vamos a agregarle un JLabel para mostrar nuestro mensaje.
Paso 5:
Vuelve al código de la clase Main. Como dijimos tenemos que convertir esta clase en un JFrame. Esto es sencillo, lo único que debemos hacer es agregar la línea extends JFrame en la parte de arriba después de dónde dice public class Main como se ve en la imágen.
Es importante notar que dejar un renglón entre el nombre de la clase y el extends no es necesario, únicamente es para darle una mejor presentación al código, pero ustedes pueden seguir cualquier estilo que ustedes consideren más claro. Después de escribir esta línea NetBeans la va a subrayar con una línea roja, esto significa que el código tiene un error. Poniendo el mouse sobre el error podemos obtener más información sobre él.
Paso 6:
El error que nos marca NetBeans es que no conoce el símbolo. Esto quiere decir que no sabe qué es un JFrame, para resolver este tipo de errores debemos agregar la librería de la que hablaba hace unos momentos, en estos momentos todavía no sabemos dónde está, pero por suerte NetBeans también nos muestra un foquito a la izquierda en el que, al hacer click, nos brinda una solución. No siempre podemos confiar en las soluciones que brinda NetBeans porque después de todo es una herramienta y no una persona que nos está haciendo la recomendación, pero muchas veces su sugerencia es acertada, como en este caso que dice que debe agregar un import(veremos más sobre este tema más adelante). Selecciona la opción y debe aparecer una línea al principio de nuestra clase en la que resuelve el error.
Paso 7:
Como vimos en la parte de arriba el método Main(con mayúscula) es el constructor de la clase. Este es el método con el que vamos a crear nuevos objetos de nuestra clase(que es una ventana). Dentro de este método debemos escribir algunas líneas de código para darle un tamaño a la ventana y para que se muestre. Copia el código que se muestra en la siguiente imágen:
En el código estamos utilizando la palabra clave this, que hace referencia a la misma clase que lo llama, es decir, a nuestra ventana. La primera línea va a cambiar el tamaño de nuestra ventana a 200 x 200. Escribe this.setS y espera unos momentos. Aparecerá una pantalla que te muestra opciónes de auto completar. Esta pantalla es muy útil al programar ya que cuando no conocemos un método nos brinda información sobre qué significan los parámetros y cómo utilizar el método.
Por ejemplo, en esta imágen nos indica que el método setSize() debe recibir dos números enteros(int quiere decir número entero), y nos dice que el método va a cambiar el tamaño del componente(en este caso nuestra ventana) para que tenga el ancho y alto especificados. Tambíen nos indica que podemos conseguir más información viendo los métodos getSize(), setBounds() y setMinimumSize(). Utilizando esta herramienta completa el código para mostrar la ventana.
La segunda línea nos permite cambiar el título de nuestra aplicación. Podemos utilizar cualquier título que nos guste, lo único importante es pasarlo entre comillas porque es texto. La tercera línea le dice a nuestra aplicación qué debe hacer cuando el programa termine. En este caso nuestro constructor es únicamente una ventana, por lo que le indicamos que al cerrar la ventana la aplicación termine con EXIT_ON_CLOSE. La cuarta línea le indica a la ventana que es visible, por lo tanto se dibuja en pantalla.
Paso 8:
Por último debemos crear un nuevo objeto de nuestra ventana, esto es muy sencillo y lo logramos agregando la línea que se ve en la imágen dentro del método main()(con minúscula).
Esta línea está creando un nuevo objeto de la clase Main mandando llamar el constructor que acabamos de crear. Compila tu programa haciendo click en el botón compilar y luego córrelo haciendo click en el botón correr .
Con esto se muestra una ventana vacía, ya casi hacemos el programa que queríamos, pero nos falta un mensaje. Para eso vamos a utilizar otra clase de Swing que se llama JLabel. En la parte superior del constructor escribe el código como se ve en la imagen:
Una vez más la primera línea va a ser subrayada en rojo porque nos falta importar una librería. Ahora vamos a utilizar otra técnica para resolver este mismo error. Haz click derecho sobre el código y selecciona la opción "Fix Imports". Con esto NetBeans revisará todo el código y automaticametne va a agregar todas las librearías que necesitamos.
En el código lo que estamos haciendo es crear un nuevo JLabel. Su nombre será lblHola(por convención todos los JLabel deben empezar su nombre con lbl) y este JLabel va a ser un nuevo JLabel que diga "Hola". Después agregamos el JLabel al contenedor de la ventana.
¡Felicidaes, hemos terminado nuestra primera aplicación en NetBeans utilizando interfaz gráfica!
Una vez que hayas terminado tu programa debes comprimir el directorio de la aplicación que seleccionaste en el paso 2 y mandarlo por blackboard.
Conexión a una base de datos en MySQL con Java
Para poder hacer una conexión a una base de datos, tendríamos que importar una librería, que por lo generalmente se encuentra en NetBeans y se le conoce por mysql-connector-java-5.1.6-bin, buena para el programa voy a utilizar de ejemplo un JFrame como el siguiente:
Lo que está utilizando son 1 JPanel, 4 JLabels, 2 JTextfields, 1jPasswordField(para la contraseña claro). Utilizaremos el siguiente código:
static String Exe3 = ""; static String Exe4 = ""; static String Exe5 = ""; /** Creates new form conx */ public conx() {
initComponents(); }
public void conex1() throws SQLException { try {
Exe3 = this.jTextField1.getText(); Exe4 = this.jPasswordField1.getText(); Exe5 = this.jTextField2.getText(); String serverName = Exe5;
int port = 3306;
String dataBase = "ejem";
Class.forName("com.mysql.jdbc.Driver");
String url = "jdbc:mysql://" + serverName + ":" + port + "/" + dataBase; Connection con = DriverManager.getConnection(url, Exe3, Exe4);
Statement stm = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
if(con != null) { usu ex= new usu(); ex.setVisible(true); this.dispose(); } if(con == null) { this.jTextField1.setText(""); this.jPasswordField1.setText("");
this.jLabel4.setText("Error vuelve a intentarlo"); }
stm.close(); con.close();
}catch(ClassNotFoundException ex) { System.out.println(ex);
System.out.println("error en la linea Entrada"); }
}
Como se puede observar un String para el nombre del servidor, otro para la base de datos, un entero para el número del puerto(que por default el 3306 siempre es de MySQL).
Este JFrame sirve como la base de algún programa, pues como lleva Strings Estáticos no hay necesidad de volverlo a crear solo de exportar, por ejemplo si alguno de ustedes necesita que invocar en otro Frame el nombre del servidor lo único que debes de hacer es poner lo siguiente:
String url = "jdbc:mysql://" + conx.Exe5 + ":" + port + "/" + dataBase;
Fuente: http://www.taringa.net/posts/info/6407848.R/Conexion-a-una-base-de-datos-en-MySQL-con-Java.html
TaT CambiarIconoJFrame
Cómo cambiar el ícono de un JFrame en cinco pasos.
Paso 1
El ícono debe ser una imagen de extensión PNG. Esto se hace más fácil, ya que conseguir una figura y convertirlo en formato .ico es muy complicado. Los PNG nos ayudan bastante.
Paso 2
La imagen que será el ícono debe estar dentro del paquete de fuentes, como si fuera una clase más. Si estuviera dentro de un paquete, sería mucho mejor.
Paso 3
En el código del JFrame que vamos a poner el ícono, sobreescribimos el método getIconImage() conteniendo el siguiente código: (notar cómo se está llamando a la imagen .png)
@Override
public Image getIconImage() {
Image retValue = Toolkit.getDefaultToolkit().
getImage(ClassLoader.getSystemResource("resources/icono.png")); return retValue;
}
Paso 4
En la vista de diseño del JFrame, lo seleccionamos y vamos sus propiedades, buscamos la propiedad "iconImagen" y hacemos clic en el botón de puntos suspensivos. Se mostrará una ventana de diálogo como esta:
De la lista desplegable, seleccionamos "Valor de componente existente". Esto hará que cambie la ventana a la siguiente forma:
Seleccionamos la opción "Propiedad" y hacemos clic en el botón de puntos suspendidos. Aparecerá una ventana de diálogo más pequeña, y seleccionamos la propiedad "iconImage" que aparece ahí.
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
JFrame y JDialog
Cuándo usar JFrame y cuándo JDialog
En una aplicación java con ventanas debería haber un único JFrame, correspondiente a la ventana principal de la aplicación. El resto de ventanas secundarias deberían ser JDialog.
Un JFrame en una ventana que en Windows crea, en la barra de herramientas, donde está el menú de "inicio" y las aplicaciones que tenemos abiertas, un nuevo botón de aplicación abierta. En una aplcación lo normal es que sólo haya un botón ahí. Si creamos varios JFrame en nuestra aplicación, apareceran varios botónes, uno por cada JFrame.
El JDialog no muestra este botón. Por ello, el resto de las ventanas de nuestra aplicación deberías ser
JDialog.
Hay otro motivo más. Un JFrame no admite a ninguna otra ventana como padre. El JDialog sí admite como padres un JFrame u otros JDialog. Esto es importante porque una ventana hija siempre quedará por encima de su ventana padre. Si al crear los JDialog les pasamos el JFrame como padre, los JDialog siempre estarán visibles por encima del JFrame. No se podrán ir "detrás" de él.
Si además, en el constructor del JDialog ponemos a true el flag que indica que es modal, además de pasarle una ventana padre, entonces el JDialog impedirá el acceso a las otras ventanas hasta que se cierre.
Puedes ver esto más detallado (y embarullado) en:
http://www.chuidiang.com/java/novatos/JFrame_JDialog.php
Cambiar el icono de la taza de café en JFrame y JDialog
Cambiar el icono de la taza de café que aparece en los JFrame, arriba a la izquierda, es fácil. Basta con llamar al método setIconImage() del JFrame.
frame.setIconImage (new ImageIcon("fichero.gif").getImage());
Los JDialog no tienen este método, pero heredan el icono de su ventana padre. Por ello, basta con crearlos pasándoles como padre en el constructor un JFrame que tenga el icono cambiado, o bien otro
JDialog que a su vez se le haya cambiado el icono
JDialog dialog = new JDialog (frame);
Abrir y cerrar ventanas secundarias (JDialog) desde la primaria (JFrame)
En el siguiente código de ejemplo, una ventana principal JFrame tiene un botón para abrir una ventana secundaria JDialog. import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; import javax.swing.JButton; import javax.swing.JDialog; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.WindowConstants; public class DosVentanas {
private JFrame ventanaPrincipal; private JDialog ventanaSecundaria; /**
* @param args */
public static void main(String[] args) { new DosVentanas();
}
public DosVentanas() {
// Construcción de ventana principal
ventanaPrincipal = new JFrame("Ventana principal"); JButton botón = new JButton("Abre secundaria"); ventanaPrincipal.getContentPane().add(botón); ventanaPrincipal.pack();
// Construcción de ventana secundaria
ventanaSecundaria = new JDialog(ventanaPrincipal,"Ventana secundaria"); JLabel etiqueta = new JLabel("Hola");
ventanaSecundaria.getContentPane().add(etiqueta); ventanaSecundaria.pack();
// Hacer que el botón abra la ventana secundaria y cierre la // principal
botón.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) {
ventanaPrincipal.setVisible(false); ventanaSecundaria.setVisible(true); }
});
// Hacer que al cerrarse la secundaria con la x de arriba a la // derecha, se muestre la primaria
ventanaSecundaria.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) {
ventanaPrincipal.setVisible(true); ventanaSecundaria.setVisible(false); }
public void windowClosed(WindowEvent e) { ventanaPrincipal.setVisible(true); ventanaSecundaria.setVisible(false); }
});
// Mostrar la ventana principal
ventanaPrincipal.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); ventanaPrincipal.setVisible(true);
} }
En primer lugar se construyen la ventana primaria y secundaria, una con un botón y la otra con una etiqueta.
Luego al botón se le añade un ActionListener para que oculte la principal y muestre la secundaria cuando se pulsa.
Finalmente se añade un WindowAdapter a la ventana secundaria para enterarnos de cuándo se cierra pulsando la x de arriba a la derecha. Cuando esto sucede, mostramos la ventana primaria y ocultamos la secundaria.
Centrar una ventana en pantalla
Si queremos que una ventana nos salga centrada en la pantalla, antes del jdk 1.4 no nos quedaba más remedio que echar unas cuentas. El código podía ser como este:
// Se da a la ventana el tamaño, con pack() o setSize() v.pack();
// Se obtienen las dimensiones en pixels de la pantalla.
Dimension pantalla = Toolkit.getDefaultToolkit().getScreenSize();
// Se obtienen las dimensiones en pixels de la ventana. Dimension ventana = v.getSize();
// Una cuenta para situar la ventana en el centro de la pantalla. v.setLocation( (pantalla.width - ventana.width) / 2, (pantalla.height - ventana.height) / 2); // Se visualiza la ventana. v.setVisible(true);
Para que el método pack() dé un tamaño adecuado a la ventana es necesario que la ventana ya tenga dentro los componentes y que estemos usando un Layout que no sea null.
Desde la versión 1.4 del JDK existe un método de la clase JWindow que realiza la operación de centrar la ventana sobre otro componente especifico. Este método es setLocationRealtiveTo(JComponenet otroComponente), donde otroComponente es cualquier componente sobre el que queremos que salga centrada la ventana p.e: JFrame, JDialog, JButton, JTextField, etc...
// La ventana saldrá centrada sobre el botón unBotón. v.setLocationRelativeTo (unBotón);
Si se pasa null como valor a este parámetro, entonces la ventana se centrara justo al centro de la pantalla del PC...
// La ventana saldrá centrada en pantalla. v.setLocationRelativeTo (null);
Fuente: http://chuwiki.chuidiang.org/index.php?title=JFrame_y_JDialog Creación de la Clase SelectorColoresMarc
El selector de colores lo crearemos en una ventana siguiendo los siguientes pasos:
nos situamos en la ventana Projects y con el botón derecho del ratón seleccionamos el paquete paqawt. Entonces elegimos New | Other...
se abre el cuadro de diálogo New File y abrimos las carpetas Java GUI Forms y AWT Forms. Entonces elegimos Frame Form y hacemos clic sobre el botón .
se abre el cuadro de diálogo New Frame Form. En el campo de texto Class Name: introducimos el nombre de la Clase SelectorColoresMarc y finalmente hacemos clic sobre el botón
Este Asistente (Wizard) nos ha creado una pestaña llamada SelectorColoresMarc, la cual contiene dos botónes Design y Source.
Cuando el botón Design está activo entonces el IDE nos proporciona un entorno gráfico para diseñar nuestras aplicaciones visuales. Si hacemos clic sobre el marco que tenemos en el área de diseño podemos ver la ventana Properties que en el futuro nos será muy útil para cambiar las diferentes propiedades de los componentes visuales Java.
Ahora vamos a hacer clic sobre el botón Source para ver el código fuente Java generado por el Asistente NetBeans, al igual que otros entornos de desarrollo Java, no permite que el desarrollador pueda modificar código en algunos métodos que están relacionados con el entorno gráfico.
La causa de esta restricción es debido a la sincronización que el entorno de desarrollo tiene que realizar cuando pasa de Diseño a Código fuente y viceversa.
Para evitar posibles errores en la escritura de código relacionado con la parte visual, NetBeans prefiere que el trabajo visual se realice directamente en este caso en el entorno gráfico en vez de codificarlo nososotros mismos.
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
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...
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.
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! “); }
}
Conectar Java con MySQL en NetBeans
Dentro de unas semanas tendré que desarrollar, junto con un equipo de trabajo, un sistema de un almacen en Java bajo la plataforma de NetBeans. Es por eso que comenzaré a pubicar una serie de post sobre cómo manejar bases de datos de MySQL con Java, y en los cuales poco a poco iré agregando nuevas funcionalidades.
Por ahora solo mostraré cómo realizar la conexión a la base de datos de MySQL.
Para comenzar debemos de tener instalado NetBeans, en lo particular yo tengo instalada la versión 6.0. Posteriormente debemos descargar un Driver o Conector para poder conectarnos a la base de datos. Se puede decir que ese Driver sabe “cómo hablar con la base de datos”, yo descargué la versión 5.0.
Una vez descargado el archivo, extraemos los componentes, de estos el archivo que nos interesa es
mysql-connector-java-5.0.5-bin.jar, este jar es la clase o Driver que nos permitirá conectarnos a la base de datos.
Ahora tenemos que hacer que esa clase esté accesible para nuestros proyectos, así que la vamos a guardar en la carpeta <DIRECTORIO_DE_JAVA>/jre/lib/ext. Si has realizado una instalación por defecto del NetBeans en Windows, entonces estará en:
C:\Archivos de programa\Java\jdk1.6.0_04\jre\lib\ext. En esta carpeta es donde se agregan los jar
adicionales, y así ya los tendremos disponibles para cuando necesitemos usarlos de nuevo. Ahora que ya tenemos el conector a la base de datos pasaremos a la parte del NetBeans:
1. Creamos un nuevo proyecto: New Project -> Java -> Desktop Application (Basic application). 2. Agregamos un botón al formulario y le cambiamos su label a “Cargar datos”.
3. Agregamos una nueva clase llamada TestConnection import java.sql.*;
public class TestConnection { public String bd = "nombre_bd"; public String login = "usuario";
public String password = "contraseña";
public String url = "jdbc:mysql://localhost/"+bd; public void conectar() {
Connection conn = null; try {
Class.forName("org.gjt.mm.mysql.Driver");
conn = DriverManager.getConnection(url, login, password); if (conn != null)
{
System.out.println("Conexión a base de datos "+url+" ... Ok"); conn.close();
} }
catch(SQLException ex) {
System.out.println("Hubo un problema al intentar conectarse con la base de datos "+url); } catch(ClassNotFoundException ex) { System.out.println(ex); } } }
4. Hacemos doble clic en el botón “Cargar datos” y colocamos el siguiente código: sourcecode language=’java’ [
TestConnection conexion = new TestConnection(); conexion.conectar();
]
Y listo!!!. Con esto ya tenemos realizada la conexión a la base de datos de MySQL Fuente: http://fragowb.wordpress.com/2008/05/01/conectar-java-con-mysql-en-netbeans/
Java - LLenar un JTable con ResultSet 1. Entorno • JDK 6 Update 21 • Netbeans 6.9.1 • MySQL 5.1. 2. Introducción
Lo que se desea demostrar en este tutorial es como mostrar los datos de una consulta en un JTable. Haciendo uso de la clase ResultSetMetaData que nos brinda la información de una tabla de la base de datos y la clase ResultSet que nos devuelve la data producto de una consulta hacia la base de datos.
3. Desarrollo
3.1. Crear el proyecto
Primero debemos de crear un proyecto en Netbeans para eso nos vamos a "File->New Project" y seleccionamos la opción de crear un "Java Application"
Al proyecto debemos de agregar un formulario (JFrameForm) que lo llamaremos "frmLlenarJtable". Para hacemos clic derecho en el paquete que se llama "llenarjtable" de ahí seleccionamos New y elegimos "JFrame Form"
3.2. Diseño del Formulario
Debemos de diseñar el siguiente formulario:
Donde:
El JTextBox: Recibe el nombre de txtQuery El JTable: Recibe el nombre de jtQuery El JButton: Recibe el nombre de btnConsultar 3.3. Crear base de datos en MySQL
Debemos de crear una base de datos en MySQL. A la base de la llamaremos "bdproductos" y también crearemos una tabla que se llamara "producto"
3.4. Codificando el action del botón "Consultar"
Debemos de codificar la acción del botón "Consultar" que va a llenar al JTable con la data producto de la consulta que vamos a hacer a la base de datos bdproductos que esta en MySQL. No olvidar agregar el conector al Netbeans para poder comunicarnos con MySQL.
Para ir a la Action del botón debemos hacer clic derecho en el botón de ahí seleccionamos Events, luego Action y finalmente ActionPerformed
Y luego dentro de ese evento ponemos el siguiente codigo
try {
//Para establecer el modelo al JTable
DefaultTableModel modelo = new DefaultTableModel();
this.jtQuery.setModel(modelo);
//Para conectarnos a nuestra base de datos
DriverManager.registerDriver(new com.mysql.jdbc.Driver());
Connection conexion = DriverManager.getConnection("jdbc:mysql://localhost/bdproductos", "usuario", "clave");
//Para ejecutar la consulta
Statement s = conexion.createStatement();
//Ejecutamos la consulta que escribimos en la caja de texto //y los datos lo almacenamos en un ResultSet
ResultSet rs = s.executeQuery(txtQuery.getText());
//Obteniendo la informacion de las columnas que estan siendo consultadas
ResultSetMetaData rsMd = rs.getMetaData();
//La cantidad de columnas que tiene la consulta int cantidadColumnas = rsMd.getColumnCount();
//Establecer como cabezeras el nombre de las colimnas for (int i = 1; i <= cantidadColumnas; i++) {
modelo.addColumn(rsMd.getColumnLabel(i)); }
//Creando las filas para el JTable while (rs.next()) {
Object[] fila = new Object[cantidadColumnas];
for (int i = 0; i < cantidadColumnas; i++) { fila[i]=rs.getObject(i+1); } modelo.addRow(fila); } rs.close(); conexion.close(); }catch (Exception ex) { ex.printStackTrace(); }
4. Ejemplo de la aplicación Sin poner etiquetas a la consulta
Con etiquetas a la consulta
Fuente: http://www.programandoconcafe.com/2010/11/java-llenar-un-jtable-con-resultset.html Centrar un JFrame/JDialog en pantalla
Al crear un nuevo JFrame ó JDialog en Swing, al hacerlos visibles estos aparecerán arriba a la izquierda de nuestra pantalla. Por ejemplo si realizamos:
import javax.swing.JFrame; public class Prueba{
public static void main(String[] args){
JFrame frame = new JFrame("Prueba JFrame"); frame.setSize(500, 500);
frame.setDefaultCloseOperation(frame.EXIT_ON_CLOSE); frame.setVisible(true);
} }
Si ahora especificamos por medio del método setLocationRelativeTo a null, la ventana se posicionará en el medio de la pantalla. Por lo que si agregamos la siguiente linea:
import javax.swing.JFrame; public class Prueba{
public static void main(String[] args){ JFrame frame = new JFrame("Prueba JFrame"); frame.setSize(500, 500); frame.setLocationRelativeTo(null); frame.setDefaultCloseOperation(frame.EXIT_ON_CLOSE); frame.setVisible(true); } }
tendremos un resultado similar a este:
Fuente: http://lefunes.wordpress.com/2008/02/11/centrar-un-jframejdialog-en-pantalla/ Centrar JDialog en Jframe
Si lo que deseamos es centrar un JDialog en el JFrame “padre”, lo que hacemos es usar el mismo método, pero esta vez especificando que la posicioón de apertura del JDialog será con respecta al JFrame:
import javax.swing.JFrame; public class Prueba{
public static void main(String[] args){
JFrame frame = new JFrame("Prueba JFrame"); frame.setSize(500, 500);
frame.setLocationRelativeTo(null);
final JButton botón = new JButton("Abrir Dialogo"); botón.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { JDialog dialogo = new JDialog(frame); dialogo.setSize(100, 100); dialogo.setLocationRelativeTo(frame); dialogo.setVisible(true); } }); frame.add(botón); frame.setDefaultCloseOperation(frame.EXIT_ON_CLOSE); frame.setVisible(true); } }
Fuente: http://lefunes.wordpress.com/2008/02/11/centrar-un-jframejdialog-en-pantalla/ Asesoramiento en programa
Hice el acceso al programa mediante una contraseña(necesaria) con dos clases. la q contiene el metodo main:
Código:
public class aplicacion {
public static void main(String[] args) { contraseña obj=new contraseña(); }
}
Y la q contiene las especificaciones de la ventana: Código:
import java.awt.Color; import javax.swing.*; import javax.swing.JFrame; import java.awt.event.*; public class contraseña { public contraseña(){
final JFrame marco=new JFrame("Acceso de programa");//CREAMOS EL MARCO DE LA VENTANA
//espacio deonde van los componentes JDesktopPane esc=new JDesktopPane();
JLabel eusuario=new JLabel("Usuario:"); JLabel econtraseña=new JLabel("Contraseña:"); final JTextField usuario=new JTextField();
final JPasswordField contraseña = new JPasswordField(); JButton cerrar=new JButton("cerrar");
JButton ingresar=new JButton("ingresar"); //ubicacion en el plano eusuario.setBounds(10,10,100,30); usuario.setBounds(90,10,190,30); econtraseña.setBounds(10, 50, 100, 30); contraseña.setBounds(90,50,190,30); cerrar.setBounds(180, 100, 100, 30); ingresar.setBounds(10, 100, 100, 30); //ocultamos la contraseña rusticamente
//agregar al escritorio los diferentes objetos esc.add(eusuario); esc.add(usuario); esc.add(econtraseña); esc.add(contraseña); esc.add(cerrar); esc.add(ingresar);
esc.setBackground(Color.LIGHT_GRAY);//esto es solo para distinguir el escritorio de la ventana
marco.add(esc);//este agrega el escritorio a la ventana marco.setSize(300,180);//le damos tamaño variable marco.setLocationRelativeTo(null);
marco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
marco.setVisible(true);//luego ir al metodo main a ocupar esta clase como metodo para un objeto
//programamos los botónes
ingresar.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e){ String user; String clave; clave=contraseña.getText(); user= usuario.getText(); if (user.equalsIgnoreCase("felipe")&&clave.equals("cbrfelipe")){ JOptionPane.showMessageDialog(null,"Bienvenido al sistema");//aprobacion //abrir otro FRAME Programa
programa frame=new programa();// con este me muevo a la siguiente ventana... me costo caleta pillarlo
marco.setVisible(false);
}else JOptionPane.showMessageDialog(null,"reintentar"); }
});
cerrar.addActionListener(new ActionListener(){//para el botón cerrar tan solo ocupamos exit public void actionPerformed(ActionEvent e){
System.exit(0); } }); } } Fuente: http://www.elcachondeo.cl/foro/f135/2031731-asesoramiento-en-programa/ Cómo usar frames y diálogos en Java Netbeans
Todos los programas que vemos en el escritorio de Windows o Linux usan ventanas es por eso una de las razones que el sistema más usado en el mundo tiene el nombre “ventana” en ingles Windows, cuando hacemos sistema en Java Netbeans existen dos tipos de ventanas que son: Frames y diálogos. A continuación te estaremos hablando de cada una de ellas.
Visita mi web:http://www.wix.com/foxsoftware/estudiosavefenix
Los FRAMES son ventanas principales que no necesitan de la existencia de otras para existir, por ejemplo la ventana principal de WORD o EXCEL podemos tener varios WORD abiertos al mismo tiempo todos son independientes esos y no necesitan de otra ventana para su existencias en JAVA estas ventanas principales se llaman FRAME y cuando se las da un nombre se acostumbra a poner el nombre que lo identifica y con la terminación FRAME por ejemplo MAINFRAME es el FRAMA principal, o NEWITEMFRAME u FRAME para crear un nuevo ítem.
Los DIALOGOS son ventanas también al igual que las ventanas de tipo FRAME pero con la diferencia que estos bloquean al formulario o ventana padre hasta que se cierre el DIALOGO.
Bueno primeramente vamos a crear un FRAME principal y abrir otro FRAME a través de un botón en el FRAME principal.
Creamos un nuevo proyecto:
Ahora escogemos JAVA y JAVA APPLICATION y después clic en el botón NEXT:
Luego dejamos las opciónes como se muestra en la siguiente imagen:
Ahora hacemos clic en FINISH, y ahora creamos nuestro primer JFRAME haciendo clic derecho en el icono en forma de una taza de café de nuestro proyecto que acabamos de crear como en la siguiente imagen:
Luego hacemos clic en FINISH recuerda que nuestro primer FRAME se llama NEWJFRAME como se muestra en la anterior imagen.
De la misma manera creamos otro FRAME llamado NEWJFRAME1:
Ahora ya tenemos dos JFRAME vamos abrir el JNEWFRAME1 a través del NEWJFRAME por medio de un JBUTTON.
Ahora hacemos clic en el NEWJFRAME1 y en sus propiedades cambiamos la propiedad
DEFAULTCLOSEOPERATION de EXIT_ON_CLOSE A DISPOSE, como se muestra en la siguiente imagen recuerda que es del NEWJFRAME1:
Esto hemos hecho para que cada FRAME sea independiente a la hora de cerrar y o se sierren todas cuando cerremos una.
Ahora agregamos un botón al otro NEWJFRAME al primero que creamos y abrimos su código de su evento con clic derecho como en la siguiente imagen:
Y escribimos en siguiente código como en la siguiente imagen:
Listo con eso cuando hagamos clic en el botón se abrirá nuestro NEWJFRAME1, cuando ejecutes el proyecto te pedirá que elijas el FRAME principal le dices que sea NEWJFRAME como en la siguiente imagen:
Ahora vamos a crear un DIALOGO que es el otro tipo de ventana que tiene el JAVA, de la misma forma que hemos creado un FRAME se crea un DIALOGO, como en la siguiente imagen:
Luego hacemos clic en FINISH, ahora para abrir este NEWJDIALOG por medio de nuestro FRAME de la misma forma que hicimos anteriormente arrastramos un botón en el NEWJFRAME y en su evento escribimos el siguiente código:
Listo ahora ejecuta tu proyecto y recuerda que el FRAME principal de be ser NEWJFRAME si te sale la siguiente ventana:
Elige NEWJFRAME, y cuando ejecute veras las diferencias que existen entre una ventana de tipo DIALOGO y una ventana de tipo FRAME, espero que te haya servido.
Cómo poner fondo a un formulario de Java Netbeans
Bueno si y has usado alguna vez un DELPHI o C++BUILDER o un VISUAL BASIC y UN VISUIAL C#, y has pensado que poner una imagen de fondo a un formulario de JAVA NETBEANS es tan fácil como en las otras tecnologías casi te equivocaste, no es para nada igual, es totalmente diferente muy diferente no es difícil porque una vez que sepas como se hace lo harás muy fácilmente después.
Visita mi web:http://www.wix.com/foxsoftware/estudiosavefenix
Entonces sigue estos pasos, abre tu NETBEANS, haz clic en FILE->NEW PROJECT:
Ahora escoge JAVA y después JAVA APPLICATION como se muestra en la siguiente imagen:
Luego de hacer clic en NEXT te saldrá otra ventana ponle un nombre a tu aplicación en nuestro caso será APLICACIONCONFONDO y deja las demás opciónes como en la siguiente imagen:
Después de hacer clic en FINSH se creara el siguiente paquete en la parte derecha como en la siguiente imagen:
Ahora vamos a crear nuestro formulario principal, haciendo clic en FILE después en NEW FILE como en la siguiente imagen:
Escogemos en categorías escogemos SWING GUI FORMS y tipo de archivo JDIALOG FORM y de pues hacemos clic en NEXT> como en la siguiente imagen:
Ahora solo le ponemos un nombre en mi caso “Principal” y luego le damos clic en FINISH:
Ahora creamos otro formulario de tipo PANEL para que sea el fondo de nuestro formulario principal. Y hacemos similar al anterior clic en FILE luego en NUEVO FILE:
Peo esta vez no escogemos JDIALOG FORM si no que JPANEL FORM de SWING GUI FORM como se muestra en la siguiente imagen:
Luego clic en NEXT y luego le ponemos un nombre en mi caso “Fondo” como en la siguiente imagen:
Luego hacemos clic en FINISH y se creara nuestro formulario y ahora listo vamos a empezar a trabajar en la configuración de nuestro Fondo, para eso nos ubicamos en nuestro formulario Fondo no en el formulario principal si no en fondo como muestra en la siguiente imagen:
Le arrastramos un JLabel1 y le ampliamos su tamaño por todo el formulario agarrándole de una esquina y agrandándole hasta que tape todo el formulario Fondo:
Ahora nos vamos a las propiedades del JLabel1 que está en la parte derecha y borramos su propiedad TEXT para que no se vea el título JLABEL1 y hacemos clic en la propiedad ICON en su botón buscar que está representado por un botón de tres puntos suspensivos como se muestra en la figura:
Luego nos saldrá una ventana done tenemos que elegir la imagen de fondo que queremos, como en la siguiente imagen:
Nosotros hacemos clic en el botón IMPORT TO PROJECT… y escogemos la imagen que queramos de nuestro ordenador como en la siguiente imagen:
Luego hacemos clic en NEXT y después clic en FINISH:
Luego clic en el botón OK, Y nos aparecerá el formulario llamado Fondo con la imagen de fondo que le escogimos ahora solo tenemos que importar este formulario Fondo a nuestro formulario Principal y lo hacemos de la siguiente forma:
Hacemos clic en Principal para entrar en el formulario Principal luego en clic en SOURCE para entrar en su código:
Luego buscamos las líneas siguientes:
Y escribimos las siguientes líneas de código dentro de las llaves de amarillo que se muestran en la imagen de arriba:
El código debe quedar así:
Ahora haz clic en el botón PLAY que es un triángulo verde: Y te pedirá que elijas en formulario principal:
Escoges Principal y listo ya tienes tu fondo pero solo se verá cuando se ejecute tu proyecto, recuerda que tienes que trabajar pone ido tus botónes y todo lo demás en el formulario Principal y n así en el
formulario Fondo. Para cada formulario que quieres con fondo tienes que crear otro formulario Fondo. Bueno es muy largo porque en Java de esa forma se pone un fondo, en la práctica es relativamente corto y sencillo.
¿Cómo ocultar el botón cerrar del JFrame? en NetBeans?
Puedes quitar el marco completo de la ventana con la siguiente propiedad del Jframe miventana.setUndecorated(true);
Fuente: http://es.answers.yahoo.com/question/index?qid=20110312080706AA40Qqw Inhabilitar botón cerrar Java en JFrame
Trata el siguiente código, a mi me funciono sin problema alguno, colócalo en la clase principal donde inicie el código del programa.
setDefaultCloseOperation(0); ejemplo:
class Programa extends JFrame{ Programa(){ setDefaultCloseOperation(0); } } Fuente: http://www.todoexpertos.com/categorias/tecnologia-e-internet/programacion/java/respuestas/1018742/inhabilitar-botón-cerrar-java-en-jframeg
JFrame, JDialog y otras ventanas
Cuando queremos hacer ventanitas en java nos encontramos con dos ventanas: El JFrame y el JDialog. ¿Cuándo se usa una u otra?, ¿Qué diferencias hay entre ellas?.
Los JDialog admiten un padre y pueden ser o no modales. ¿Para qué sirve ese padre? ¿Puedo hacer cualquier JDialog modal?
Otras veces queremos hacer una ventana de error, de aviso, para pedir un dato o confirmar algo. ¿Pongo
JFrame o JDialog para esas ventanas? ¿Tengo que construirla?
Vamos a tratar en este tutorial de echar un vistazo a JFrame y JDialog, así como a JOptionPane y ver cuándo usamos una u otra. Trataremos de responder a todas estas preguntas.
JFrame y JDialog
Los dos tipos de ventanas principales que tenemos en java son JFrame y JDialog. Hay varias diferencias entre ellas y en función de estas diferencias vamos a ver para qué sirven
• Si instanciamos un JFrame, en la barra de abajo de windows (creo que se llama "barra de herramientas") nos aparece un nuevo "botóncito" correspondiente a nuestra aplicación. Si instanciamos un JDialog, no aparece nada.
• Un JFrame tiene un método setIconImage() para cambiar el icono por defecto de la taza de café.
JDialog no tiene este método.
• Un JDialog admite otra ventana (JFrame o JDialog) como padre en el constructor. JFrame no admite padres.
• Un JDialog puede ser modal, un JFrame no. Todo esto nos indica lo siguiente:
• Un JFrame debe ser la ventana principal de nuestra aplicación y sólo debe haber una.
• Las ventanas secundarias de nuestra aplicación deben ser JDialog. Los motivos de esto son los siguientes.
Al mostrar el JFrame un botón en la barra de herramientas de windows y tener método para cambiar el icono, es la ventana ideal como ventana principal de nuestra aplicación y sólo debe haber una. Nos permite cambiar el icono y sólo debe haber un botón en la barra de herramientas de windows para nuestra aplicación.
Si usamos un JDialog como ventana principal, no tenemos botón en la barra de herramientas y no hay forma fácil de cambiarle el icono.
Los JDialog son ideales para ventanas secundarias porque admiten una ventana padre. Si la VentanaA es padre del JDialogB, entonces el JDialogB siempre estará por delante de VentanaA, nunca quedará por detrás. Lo ideal es que hagamos nuestras ventanas secundarias como JDialog cuyo padre sea el JFrame principal. De esta forma los JDialog siempre serán visibles por encima del JFrame y no se irán detrás ni quedarán ocultos por el JFrame.
Otra ventaja de admitir un padre es que heredan el icono de él. Si hemos cambiado el icono del JFrame con el método setIconImage(), entonces todos los JDialog que hagamos como hijos de este JFrame heredarán el icono. Todas las ventanas de nuestra aplicación tendrán el mismo icono en lugar de la taza de café por defecto.
Jerarquía de padres y ventanas modales
Un JDialog puede ser modal, pasándole un true en el constructor en el sitio adecuado o haciéndolo modal con el método setModal(). Si hacemos un JDialog modal, todas las demás ventanas se deshabilitarán hasta que el usuario de nuestro programa cierre el JDialog. Esto está estupendo para pedir un dato al usuario y evitar que toque otras cosas hasta que haya introducido el dato. Sin embargo, tiene un peligro.
Supongamos un JDialog que lo hacemos modal para pedir unos datos al usuario. Este JDialog tiene un botón de "Aceptar" para que el usuario lo pulse cuando haya terminado de introducir los datos. Supongamos que en el código de ese botón "Aceptar" comprobamos los datos que ha metido el usuario y vemos que son incorrectos. Le sacamos un segundo JDialog modal para indicarle el error y no cerramos el primero.
¿Quién debe ser el padre de ese segundo JDialog modal?. Si hacemos que el padre sea el JFrame tendremos dos JDialog modales hijos del JFrame, es decir, dos JDialog modales hermanos. Esto nos dará problemas, como que ambas ventanas queden deshabilitadas, que al cerrar una de ellas se nos oculten todas, que parte de la ventana quede deshabilitada mientras que otra parte no, etc.
Entonces, ¿cómo hacemos?. Para que java no haga cosas raras, el padre del segundo JDialog modal debe ser el primer JDialog modal. De esta forma, el segundo tiene "prioridad" sobre el primero. Todo queda deshabilitado excepto este segundo JDialog. Cuando lo cerremos, será el primero el que mande.
Resumiendo, si queremos varias ventanas modales simultáneamente en pantalla, cada ventana que se muestre debe ser padre de la siguiente, de forma que la cadena de ventanas modales sean padre, hijo, nieto, etc. Tener dos ventanas modales simultaneas que sean hermanas o primas o cualquier otra relación que no sea directa, nos dará problemas.
JOptionPane
Para hacer ventanas sencillas que avisen de un error al usuario y tengan un botón de "Cerrar", o que le pidan una confirmación para hacer algo (como borrar un fichero) y tengan dos botónes de "Si" y "No", o para pedirle que elija una opción entre varias disponibles ... tenemos suerte. No hay que construir la ventana.
La clase JOptionPane de java tiene métodos showConfirmDialog(), showInputDialog(),
showOptionDialog(), showMessageDialog(). Estos métodos mostarán una ventana modal que pide al
usuario una confirmación, que le pide un dato o le muestra un mensaje. En caso de que el usuario tenga que elegir algo, el método usado devuelve el valor elegido.
Por ejemplo, para mostrar un aviso de error, nos basta esta simple línea de código
JOptionPane.showMessageDialog(ventanaPadre, "mensaje de error", "título de la ventana", JOptionPane.ERROR_MESSAGE);
Esto mostrará el mensaje de error y detendrá la ejecución del código hasta que el usuario cierre la ventana.
Ahora viene el dato importante. Esta ventana es modal y admite un padre. Si ya hay una ventana modal visible en pantalla, deberías pasar esa ventana como padre de esta para no tener problemas.
JInternalFrame
El JInternalFrame es una ventana especial que ni es ventana ni es nada. De hecho, no hereda de
Window. En realidad es un componente java que se dibuja dentro de otro componente, pero adornado
con la barra de título de una ventana y sus botónes de maximizar, minimizar y cerrar. Puede incluso arrastrarse y modificarse de tamaño siempre que se mete dentro del componente adecuado.
El sitio bueno para meter los JInternalFrame es el JDesktopPane. Este panel admite JInternalFrame y sabe manejarlos.
JFrame ventana = new JFrame();
JDesktopPane desktop = new JDesktopPane(); ventana.getContentPane.add(desktop);
JInternalFrame internal = new JInternalFrame(); desktop.add(internal);
En este código el JInternalFrame se comportará como una ventana, pero que no puede salirse del JDesktop que la contiene.
Resumen
• En nuestra aplicación debe haber un JFrame y sólo uno, que será la ventana principal.
• Todas las ventanas secundarias deben ser JDialog y todos los JDialog deberían tener padre.
• Todos los JDialog modales visibles a la vez en pantalla, deben ser unos hijos de otros en una cadena "padre-hijo-nieto" directa. No pueden ser "hermanos", ni "primos" ni "sobrinos".
Cerrar la ventana JFrame o JDialog al pulsar la tecla ESCAPE
KeyboardFocusManager kb = KeyboardFocusManager.getCurrentKeyboardFocusManager(); kb.addKeyEventPostProcessor(new KeyEventPostProcessor(){
public boolean postProcessKeyEvent(KeyEvent e){
if (e.getKeyCode() == KeyEvent.VK_ESCAPE && this != null){ System.out.println("probando..."); dispose(); return false; } return true; } }); Fuente:http://foro.chuidiang.com/java-j2se/cerrar-la-ventana-jframe-o-jdialog-al-pulsar-la-tecla-escape/ JAVA desde cero
Clase JFrame
Por herencia la clase JFrame y sus clases descendientes (subclases directas ) pueden utilizar los datos y/o métodos de la superclase Frame, Window, Container, Component y Object de la librería awt.
La clase JFrame es ligeramente incompatible con la clase Frame. Como todo otro contenedor de alto nivel de la librería Swing, un JFrame contiene un JRootPane como su único elemento. El contentPane proporcionado por el rootPane debería, como una regla, contener todos los componentes que no sean menú mostrados por el JFrame.
A diferencia del Frame, un JFrame tiene alguna noción de como responder cuando el usuario intenta cerrar la ventana. El comportamiento por defecto es simplemente ocultar el JFrame cuando el usuario cierra la ventana. Para cambiar el comportamiento por defecto se debe invocar al método setDefaultCloseOperation().
I.- JERARQUÍA DE CLASES
II.- MÉTODOS ATRIBUTOS
static int EXIT_ON_CLOSE La salida por defecto al cerrar una ventana. CONSTRUCTORES
JFrame() Crea un nuevo frame que es inicialmente visible
JFrame(String título) Crea un nuevo frame con el título indicado como parámetro MÉTODOS
Tipo de retorno Método Descripción
Container getContentPane() Retorna el objeto contentPane.
jMenuBar getJMenuBar() Retorna el menúBar establecido en el frame
Void remove(Component comp) Remueve el componente indicado como parámetro de éste contenedor Void setContentPane(Container contentPane) Establece la propiedad del contentPane
Void setDefaultCloseOperation(int operation) Establece la operación que sucederá por defecto cuando el usuario cierra la ventana Void setJMenuBar(JMenuBar menu) Establece la barra de menú para el frame
Void setLayout(LayoutManager layout) Por defecto, la distribución de los paneles de éste componente no 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 :
Java - deshabilitar maximizar en frame
public Login() { initComponents(); setSize(400,300);
this.setResizable(false);// esto hara que el frame no se pueda maximizar }
Fuente: http://www.lawebdelprogramador.com/foros/Java/930097-deshabilitar_maximizar_en_frame.html Jframe sin el boton de cerrar, maximizar y minimizar
Facil y sencillo setUndecorated(true);
getRootPane().setWindowDecorationStyle(JRootPane.NONE); se le pone al frame y listo
Fuente: http://skuarch.blogspot.com/2011/03/jframe-sin-el-botón-de-cerrar-maximizar.html Limitar caracteres en un JTextfield
Por diversas razones tenemos la necesidad de evitar que un usuario ingrese ya sea números, letras, ciertos caracteres especiales o más de un número máximo de caracteres.
Para lograr estos objetivos voy a mostrar algunos de ejemplos de clases que implementan algun tipo de limitación en los datos ingresados.
Primer ejemplo: Limitar el jTextField a solo letras y espacios. Nombre de la clase: LimitadorSoloLetras.java
import javax.swing.text.AttributeSet; import javax.swing.text.BadLocationException; import javax.swing.text.PlainDocument; /** * @author Hernán */
public class LimitadorSoloLetras extends PlainDocument{
public void insertString(int arg0, String arg1, AttributeSet arg2) throws adLocationException
{
for (int i=0;i<arg1.length();i++)
if (!Character.isLetter(arg1.charAt(i)) && ! Character.isSpaceChar(arg1.charAt(i)))
return;
super.insertString(arg0, arg1, arg2); }
}
Modo de uso: supongamos que tenemos un JTextField llamado txtNombres, entonces lo que tenemos que hacer es:
txtNombres.setDocument(new LimitadorSoloLetras()); Segundo Ejemplo: Limitar el jTextField a solo números.
Nombre de la clase: LimitadorSoloNumeros.java import javax.swing.text.AttributeSet; import javax.swing.text.BadLocationException; import javax.swing.text.PlainDocument; /** * @author Hernán */
public class LimitadorSoloLetras extends PlainDocument{
public void insertString(int arg0, String arg1, AttributeSet arg2) throws adLocationException
{
for (int i=0;i<arg1.length();i++)
if (!Character.isLetter(arg1.charAt(i)) && Character.isSpaceChar(arg1.charAt(i)))
return;
super.insertString(arg0, arg1, arg2); }
Modo de uso: supongamos que tenemos un JTextField llamado txtNombres, entonces lo que tenemos que hacer es:
txtDNI.setDocument(new LimitadorSoloNumeros());
Tercer Ejemplo: Limitar el jTextField a solo letras y espacios y además limitar la cantidad de caracteres ingresados.
Nombre de la clase: LimitadorSoloLetrasNroMax.java import javax.swing.JTextField; import javax.swing.text.AttributeSet; import javax.swing.text.BadLocationException; import javax.swing.text.PlainDocument; /** * @author Hernán */
public class LimitadorSoloLetrasNroMax extends PlainDocument{ private JTextField miJTextField;
private int nroMaxCaracteres;
public LimitadorSoloLetrasNroMax(JTextField mijtext, int nroMaxCaract){ miJTextField=mijtext;
nroMaxCaracteres=nroMaxCaract; }
public void insertString(int arg0, String arg1, AttributeSet arg2) throws BadLocationException
{
for (int i=0;i<arg1.length();i++)
if ((!Character.isLetter(arg1.charAt(i)) && !
Character.isSpaceChar(arg1.charAt(i)))||(miJTextField.getText().length() +arg1.length())>nroMaxCaracteres)
return;
super.insertString(arg0, arg1, arg2); }
}
Modo de uso: supongamos que tenemos un JTextField llamado txtApellidos, entonces lo que tenemos que hacer es:
txtApellidos.setDocument(new LimitadorSoloLetrasNroMax(txtApellidos,30));
Cuarto Ejemplo (a pedido de trancelex): Limitar el jTextField a solo letras y espacios, y además cuando se llegue al número maximo pasar al próximo campo.
Nombre de la clase: LimitadorSoloLetrasNroMaxV2.java import javax.swing.JTextField; import javax.swing.text.AttributeSet; import javax.swing.text.BadLocationException; import javax.swing.text.PlainDocument; /** * @author Hernán */
public class LimitadorSoloLetrasNroMaxV2 extends PlainDocument{ private JTextField miJTextField;
private int nroMaxCaracteres;
public LimitadorSoloLetrasNroMaxV2(JTextField mijtext, int nroMaxCaract){ miJTextField=mijtext;
nroMaxCaracteres=nroMaxCaract; }
public void insertString(int arg0, String arg1, AttributeSet arg2) throws adLocationException{
for (int i=0;i<arg1.length();i++){
if ((miJTextField.getText().length()+arg1.length())>nroMaxCaracteres){ miJTextField.transferFocus();
return;
}else if (!Character.isLetter(arg1.charAt(i)) && ! Character.isSpaceChar(arg1.charAt(i)))
return; }
super.insertString(arg0, arg1, arg2); }
