Usuario:
Formas y Componentes
Definición 
Para establecer una interfaces gráfica se comienza por definir un marco o frame. La clase clave para ello en java es el JFrame y cualquier clase que se define, puede ser definida como una extensión de esta.
El JFrame solo corresponde al marco y no tiene un área donde colocar las componentes. Por ello la segunda clase que se introduce es el panel o el JPanel que corresponde a la tela sobre la cual vamos a desplegar las componentes.
Las componentes a su vez son clases. Existen algunas para
* mostrar textos, como el JLabel o etiqueta
* ingresar información como el JTextField o campo de texto
* activar procesos como el JButton o botón
Cada componente tiene sus constructores y métodos asociados tanto para configurar los como para inducir acciones.
ID:(2370, 0)
La Clase JFrame
Imagen
Si estudiamos la clase JFrame veremos que hay dos constructores bastante simples que podemos usar:
```
JFrame()
```
o
```
JFrame(String title)
```
donde "title" es el texto que el marco despliega en el borde superior.
Entre los métodos de la clase JFrame se tiene la posibilidad de definir una estructura (layout) para facilitar la localización de las componentes. Si no se desea dicha estructura basta indicar que se desea setear en "null":
```
setLayout(null);
```
Tambien se puede fijar el tamaño mediante el método setSize:
```
setSize(200,100);
```
De igual forma podemos setear el formato del área en que se fijan las componentes:
```
setLayout(new FlowLayout());
```
Podemos ademas agregar un boton para cerrar el JFrame:
```
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
```
Si finalmente deseamos hacer visible el JFrame basta empelar el setVisible:
```
setVisible(true);
```
ID:(2372, 0)
Creación del Constructor
Nota
Basado en la clase JFrame se puede crear una clase mainForm que configura el JFrame. Para ello la nueva clase, que podemos llamar mainFrame, debe extender JFrame:
```
public class mainFrame extends JFrame {
...
}
```
El constructor de esta subclase debe primero emplear el constructor de JFrame para crear el marco como tal. Esto se hace haciendo referencia a la superclase con la palabra "super" y usando los argumentos que corresponden al constructor deseado:
```
super( title);
```
Adicionalmente se puede definir que no se desea una estructura predefinida (con lo que hay que manualmente localizar cada componente)
```
setLayout(null);
```
y definir el tamaño:
```
setSize(200,100);
```
y como reacciona si se le cierra:
```
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
```
Con ello el constructor de mainFrame sería
```
public mainFrame(String title){
super( title);
setLayout(null);
setSize(200,100);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
```
ID:(1161, 0)
Configurar el Marco en el Main
Cita
Para construir la GUI debemos crear una clase que podemos llamar mainFrame y que es una extensión de la clase JFrame.
En la subclase se le puede proveer de todas las componentes necesarias, por lo que en el main basta solo crearla y hacerla visible:
```
public class GUI {
public static void main (String[] args){
mainFrame marco = new mainFrame("Titulo");
marco.setVisible(true);
}
}
```
El marco puede contener todas las funciones que permita su operación en forma independiente del programa main que la inicializo.
ID:(2371, 0)