JPanel

Buen día bienvenidos a este espacio de nuevo. El tema del día de hoy es JPanel, como publiqué en el tema anterior en las aplicaciones que realizemos solo tendremos un JFrame (ventana) y varios JPanel's (paneles). Para esto seguiremos utilizando Netbeans ya que ocuparemos una biblioteca incluida en este, la biblioteca es Diseño Absoluto.

Esta biblioteca servirá para agregar el diseño absoluto tanto al JFrame como a los JPanel. El Diseño Absoluto sirve para que al momento de redimencionar las pantallas los elementos agregados tanto al JPanel como al JFrame no pierdan su posición original.

Para agregar esta biblioteca a nuestro proyecto primero localizamos la carpeta Bibliotecas que se encuentra dentro de nuestro proyecto (revisar imágen).

Damos clic derecho sobre esta carpeta (revisar imágen).

Y elegimos la biblioteca c y damos clic a añadir biblioteca(revisar imágen).

Ahora utilizaremos tres clases java en este ejercicio:

ventana.java
panel.java
ejecutar.java


La clase ventana.java es parecida a la del tema anterior ya que heredará a JFrame.
La clase panel.java será el panel y heredara a JPanel.
La clase ejecutar será la clase que ejecute nuestro programa.

El dividir nuestro ejercicio en varias clases nos ayudará para el momento de expandir nuestros programas.

panel.java

Para la clase panel.java primero importamos los paquetes necesarios que son los siguientes:

import javax.swing.JPanel;
import javax.swing.JLabel;
import javax.swing.JTextField;
import org.netbeans.lib.awtextra.AbsoluteConstraints;
import org.netbeans.lib.awtextra.AbsoluteLayout;

public class panel extends JPanel{

}

La primera libreria es la necesaria para hacer nuestro JPanel, la segunda es necesaria para agregar etiquetas (elemento), la tercerapara agregar campos de texto (elemento), la cuarta nos servira para posicionar los elementos como etiquetas, cajas de texto, botones, etc, en el JPanel o JFrame. La última libreria nos ayudara a a agregar el diseño absoluto a nuestro JPanel y/ó JFrame.

Ahora creamos el constructor de la clase pero de tipo JPanel y que regrese (return) el mismo JPanel.

import javax.swing.JPanel;
import javax.swing.JLabel;
import javax.swing.JTextField;
import org.netbeans.lib.awtextra.AbsoluteConstraints;
import org.netbeans.lib.awtextra.AbsoluteLayout;

public class panel extends JPanel{

public JPanel panel(){//Constructor de la clase panel tipo JPanel

return this; //regresa el mismo JPanel por eso la palabra reservada this
}

}

Ahora agregamos dos etiquetas y dos botones (Realizaremos un tipo login).

import javax.swing.JPanel;
import javax.swing.JLabel;
import javax.swing.JTextField;
import org.netbeans.lib.awtextra.AbsoluteConstraints;
import org.netbeans.lib.awtextra.AbsoluteLayout;

public class panel extends JPanel{
public JPanel panel(){
JLabel etiqueta_nombre=new JLabel("Nombre");//etiqueta Nombre

JLabel etiqueta_contrasena=new JLabel("Contraseña");//etiqueta Contraseña

JTextField campo_nombre=new JTextField(25);//campo de texto para nombre

JTextField campo_contrasena=new JTextField(25);//campo de texto para contraseña
return this;
}
}

El número que contiene el JTextField es el ancho que tendra de tamaño. Ahora agregamos el diseño absoluto y los elementos en las cordenadas deseadas.(el primer número corresponde a la coordenada x y el segundo a la y.)

import javax.swing.JPanel;
import javax.swing.JLabel;
import javax.swing.JTextField;
import org.netbeans.lib.awtextra.AbsoluteConstraints;
import org.netbeans.lib.awtextra.AbsoluteLayout;

public class panel extends JPanel{
public JPanel panel(){
JLabel etiqueta_nombre=new JLabel("Nombre");//etiqueta Nombre

JLabel etiqueta_contrasena=new JLabel("Contraseña");//etiqueta Contraseña

JTextField campo_nombre=new JTextField(25);//campo de texto para nombre

JTextField campo_contrasena=new JTextField(25);//campo de texto para contraseña

this.setLayout(new AbsoluteLayout());


this.add(etiqueta_nombre, new AbsoluteConstraints(200, 30));
this.add(etiqueta_contrasena, new AbsoluteConstraints(200, 60));
this.add(campo_nombre, new AbsoluteConstraints(300, 30));
this.add(campo_contrasena, new AbsoluteConstraints(300, 60));
return this;
}
}

ventana.java

Esta clase es muy parecida a la anterior así que solo daré una explicación breve de lo que agregaremos.

import javax.swing.JFrame;
import javax.swing.JPanel;
import org.netbeans.lib.awtextra.AbsoluteConstraints;
import org.netbeans.lib.awtextra.AbsoluteLayout;

public class ventana extends JFrame{

public ventana(JPanel jp, String titulo, int x, int y, int ancho, int largo){
//jp es el panel que recibirá el JFrame
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setTitle(titulo);
this.setResizable(false);
this.setLayout(new AbsoluteLayout()); //agregamos el diseño absoluto
this.setBounds(x, y, ancho, largo);
getContentPane().add(jp, new AbsoluteConstraints(0, 0 , ancho, largo));
}
}

El constructor recibirá un JPanel, un String para el título y 4 enteros: x e y son las coordenadas de la pantalla y ancho y largo los tamaños del JFrame.
setResizable es para admitir o no la propiedad de maximisar el JFrame.
(Cualquier duda de el codigó anterior dejen comentarios y los resolvemos).

ejecutar.java

En esta clase ejecutaremos nuestra ventana tan solo creando una instancia de la clase panel y recibiendola en una variable JPanel la cual pasaremos a la instancia de la clase ventana.java, así como tambien pasamos las coordenadas x(500), y (100), los tamaños ancho(650) y el largo(200), no nos olvidemos del String (entre "") que será el titulo de la ventana en este caso Inicio.

import javax.swing.JPanel;

public class ejecutar {

public static void main(String [] args){
panel contenedor = new panel();
JPanel p=contenedor.panel();
ventana ver= new ventana( p , "Inicio", 500, 100, 650, 200);
ver.setVisible(true);
}
}

Ejecutamos solo la clase ejecutar.java y quedará así:

Y aquí terminamos con nuestro programa cualquier comentario, duda favor de hacerlo ya que lo resolveremos en el menor tiempo posible. Gracias buen fin de semana!!! (Si tiene faltas de ortografía, que es lo más seguro, avisenme en privado por facebook por favor.)

JFrame

Buen día y Bienvenidos al primer tema del blog el cual tratará acerca de como hacer un JFrame en java el cual vamos aocupar a lo largo del blog para poder visualizar los resultados de las futuras practicas, es decir, que no vamos a ocupar para casi nada la "consola" del IDE en este caso Netbeans.

Este post es muy básico, el motivo es para que algunos compañeros conoscan algunos conceptos básicos y poder avanzar mas rápido, espero y realizen comentarios y preguntas si es que las tienen para poder resolver sus dudas.

Antes de comenzar las herramientas que utilizaremos serán las siguientes:

• JDK de JAVA
• Netbeans IDE (yo utilizare la versión 7.0)

No me detendré a explicar como instalar las herramientas, así que comenzemos...

JFrame

Un JFrame es una ventana, el JFrame es una extensión de Frame del paquete awt.
Este JFrame o ventana nos servira para colocar componentes necesarios para nuestras aplicaciones por ejemplo botones, etiquetas, panel's, listas, radiobotones, etc, etc...

En todas las prácticas que realizemos el unico componente que será agregado directamente al JFrame será el JPanel.

Un JFrame cuenta con diversas propiedades ó métodos las cuales cumplen objetivos específicos algunas de las propiedades ó métodos que ocuparemos en esta primer practica son:

• setTitle(String titulo)
• setDefaultCloseOperation(int cerrar);
• setBounds(int Posicion x, int Posicion y, int Ancho, int Largo)

Para hacer un JFrame tenemos dos opciones, crear un objeto tipo JFrame o heredar la clase JFrame.
En este ejemplo realizaremos la segunda opción, para esto crearemos una clase llamada ventana heredando la clase JFrame.
Para heredar la clase JFrame se agrega la palabra extends y en seguida la clase que queremos heredar en este caso JFrame e importamos el paqueteawt.JFrame.

import javax.swing.JFrame; //libreria/paquete JFrame
public class ventana extends JFrame{

}

Ahora creamos el constructor de la clase

import javax.swing.JFrame; //libreria/paquete JFrame
public class ventana extends JFrame{
//constructor
public ventana(){

}

}

Para agregar las propiedades mencionadas anteriormente utilizaremos la palabra reservada this, la cual hace referencia a la clase donde se esté aplicando.
Ahora agregaremos una por una las propiedades mencionadas anteriormente la primera será setTitle(String titulo). la cual agrega un título a la ventana.

import javax.swing.JFrame; //libreria/paquete JFrame
public class ventana extends JFrame{
//constructor
public ventana(){
this.setTitle("Mi primer ventana");
//setTitle(String titulo)
}
}

Ahora tenemos que stablecer que hará la ventana al cerrar con la opción setDefaultCloseOperation(int cerrar):
Cerrarse y terminar la ejecución (EXIT_ON_CLOSE)
Cerrarse y no terminar la ejecución (DISPOSE_ON_CLOSE)
En este caso cerraremos y terminaremos la ejecución

import javax.swing.JFrame; //libreria/paquete JFrame
public class ventana extends JFrame{
//constructor
public ventana(){
this.setTitle("Mi primer ventana");
//setTitle(String titulo)
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
//setDefaultCloseOperation(int cerrar)
}
}

Por último agregamos un tamaño y una posición a la ventana con la propiedad setBounds(int Posicion x, int Posicion y, int Ancho, int Largo):
la cual contiene cuatro variables tipo enteras:
int Posicion x que es la posición del eje x que tendrá la ventana en la pantalla
int Posicion y que es la posición del eje y que tendrá la ventana en la pantalla
int Ancho que es el ancho que tendrá la ventana
int Largo que es el largo que tendrá la ventana

import javax.swing.JFrame; //libreria/paquete JFrame
public class ventana extends JFrame{
//constructor
public ventana(){
this.setTitle("Mi primer ventana");
//setTitle(String titulo)
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
//setDefaultCloseOperation(int cerrar)
this.setBounds(300, 100, 200, 100);
//setBounds(int Posicion x, int Posicion y, int Ancho, int Largo)
}
}

Ahora ejecutamos con el método main haciendo una instancia de la clase

import javax.swing.JFrame; //libreria/paquete JFrame
public class ventana extends JFrame{
//constructor
public ventana(){
this.setTitle("Mi primer ventana");
//setTitle(String titulo)
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
//setDefaultCloseOperation(int cerrar)
this.setBounds(300, 100, 200, 100);
//setBounds(int Posicion x, int Posicion y, int Ancho, int Largo)
}
public static void main(String []args){
ventana ejecutar = new ventana();//ejecutar es la instancia de la clase
ejecutar.setVisible(true);//setVisible(true) para ver la ventana

}

}

Aquí terminamos nuestra primer ventana espero realizen comentarios y/ó críticas. En el próximo post realizaremos JPanels los cuales serán nuestros contenedores para los componentes.