Está en la página 1de 8

Tomado del siguiente enlace:

http://www.chuidiang.org/java/layout/BorderLayout.php
Ejemplo de BorderLayout, BoxLayout y FlowLayout
Los Layout son las clases java que se encargan de decidir, dentro de un formulario, panel, ventana o
lo que sea cómo van colocados los botones, areas de texto y demás dentro de ellos. El Layout decide
si los botones se pegan a la izquierda, a la derecha, si se deben hacer o no grandes al estirar la
ventana, etc.

En este tutorial vamos a construir una ventana usando el BorderLayout. Para algunos de los paneles
que meteremos en ella usaremos el BoxLayout y el FlowLayout.

La ventana será una ventana típica de cualquier aplicación, pero un poco exagerada. Es decir, una
área central grande, en nuestro caso un JTextArea con scroll. Pondremos botones por los
alrededores, arriba, abajo, a la izquierda y a la derecha. Por eso digo que es algo exagerado. Lo
normal es ponerlos arriba y a un lado, no en todos los sitios a la vez.

Cada uno de los paneles que va en los laterales los coloreamos de un color distinto, de forma que
podamos ver exactamente hasta donde llegan.

Aquí tienes un Applet con lo que vamos a crear. Ni se te ocurra darle a los botones o te llevarás un
chasco, ya que no hacen nada salvo entretenerte mientras los pulsas.

FlowLayout

Los botones que vamos a poner arriba y abajo del componente central van alineados en fila. Para
hacer una fila horizontal de botones o cualesquiera otros componentes, el Layout ideal es
el FlowLayout. Usarlo es bastante sencillo, basta decirle al panel que debe tener un FlowLayout y
empezar a añadirle botones al panel.

Si el panel superior es una fila de cuatro botones, el código sería este

panelSuperior = new JPanel(new FlowLayout(FlowLayout.LEFT));
panelSuperior.setBackground(Color.cyan);
panelSuperior.add(new JButton("Sup.1"));
panelSuperior.add(new JButton("Sup.2"));
panelSuperior.add(new JButton("Sup.3"));
panelSuperior.add(new JButton("Sup.4"));

Si en el constructor de FlowLayout no ponemos nada, los botones irán en fila horizontal centrados en
el panel. Como los queremos pegados a la izquierda, en el constructor del FlowLayout hemos puesto
como parámetro FlowLayout.LEFT. Por supuesto, tenemos también FlowLayout.RIGHT. Si
investigamos en la API de FlowLayout , veremos también que hay constructores que nos permiten
indicar qué márgenes queremos arriba, abajo, izquierda y derecha e incluso de separación entre
botones.
El panel inferior lo haremos más variado, con un JLabel, un JTextField y un JButton. El código es
similar

panelInferior = new JPanel(new FlowLayout());
panelInferior.setBackground(Color.yellow);
panelInferior.add(new JLabel("Pon texto"));
panelInferior.add(new JTextField(25));
panelInferior.add(new JButton("Listo"));

Esta vez hemos dejado el FlowLayout sin parámetros en el constructor, para que queden centrados.

BoxLayout

Para los componentes que van a los lados necesitamos algo similar al FlowLayout, pero que lo haga
en vertical. El BoxLayout es algo más elaborado que el FlowLayout en el sentido de que permite
tanto orientación horizontal como vertical. Sin embargo, aunque también se puede hacer, no es tan
evidente el hacer que los componentes se peguen arriba, abajo, a la izquierda o a la derecha.

El código para nuestra barra de botones vertical en el lado izquierdo quedaría así

panelIzquierdo = new JPanel();
panelIzquierdo.setLayout(new BoxLayout(panelIzquierdo, BoxLayout.Y_AXIS));
panelIzquierdo.setBackground(Color.red);
panelIzquierdo.add(new JButton("1"));
panelIzquierdo.add(new JButton("2"));
panelIzquierdo.add(new JButton("3"));

El constructor del BoxLayout es más complejo (y en mi opinión tonto) que el del FlowLayout.
Debemos pasarle el contenedor al que lo estamos añadiendo, es decir, el parámetro panelIzquierdo.
También debemos pasarle si queremos orientación vertical BoxLayout.Y_AXIX u orientación
horizontal BoxLayout.X_AXIS. Hay otras opciones, pero de momento las ignoramos. En la API de
BoxLayout puedes ver más detalles sobre este Layout.

Para el panel derecho haremos lo mismo

panelDerecho = new JPanel();
panelDerecho.setBackground(Color.green);
panelDerecho.setLayout(new BoxLayout(panelDerecho, BoxLayout.Y_AXIS));
panelDerecho.add(new JButton("A"));
panelDerecho.add(new JButton("B"));
panelDerecho.add(new JButton("C"));
panelDerecho.add(new JButton("D"));

BorderLayout

Finalmente el Layout por defecto de todas las ventanas es el BorderLayout. Este es un Layout que
divide el panel en cinco zonas: una central, una arriba, otra abajo, en la izquierda y en la derecha. El
tamaño de estas zonas depende de los componentes que van dentro, pero más o menos es esto:

 La zona superior e inferior se estiran de izquierda a derecha hasta ocupar toda la ventana.
En vertical se deja el tamaño justo para que quepan los componentes que hay dentro.
 Las zonasizquierda y derecha se estiran de arriba a abajo hasta ocupar todo el espacio
disponible entre las zonas de arriba y abajo. El ancho para las zonas izquierda y derecha es el
justo para que se vean los componentes que hay dentro.

 La zona central se estira en ambas direcciones hasta tocar a las otras zonas.

En la imagen puedes ver estas zonas del BorderLayout.

Por lo demás, este Layout es muy simple. Podemos añadir hasta cinco componentes, cada uno en su
sitio.

// Creamos el componente central, un JTextArea con scroll.
JScrollPane scroll=new JScrollPane(new JTextArea());

// Añadimos todos los componentes
v.getContentPane().setLayout(new BorderLayout()); 
v.getContentPane().add(scroll,BorderLayout.CENTER);
v.getContentPane().add(panelSuperior,BorderLayout.NORTH);
v.getContentPane().add(panelInferior,BorderLayout.SOUTH);
v.getContentPane().add(panelIzquierdo,BorderLayout.WEST);
v.getContentPane().add(panelDerecho,BorderLayout.EAST);

Listo. v es nuestra ventana (en el ejemplo un JFrame) y


con BorderLayout.CENTER, NORTH, SOUTH, WEST y EAST estamos indicando dónde queremos
cada cosa.

Puedes ver este ejemplo funcionando en el Applet de arriba. Cada zona se ha coloreado de un color
para distinguirla mejor. Los botones no hacen nada, así que no te aburras pulsándolos. Por supuesto,
te puedes bajar el BorderLayout.jar para ejecutarlo con
$ java ­jar BorderLayout.jar

o bajarte el fuente PruebaBorderLayout.java para verlo, modificarlo y jugar con él.

De todas formas, si esto te parece sencillo, puedes intentarlo con el GridBagLayout. Te permite hacer
lo mismo de una forma más complicada, pero sin usar tantos paneles.

Tablas
Anterior | Siguiente

Al igual que los árboles, las tablas en Swing son importantes y poderosas. En principio, se crearon
para constituir un interfaz ligado a bases de datos a través del Java Database Connectivity (JDBC,
para los amigos), y así evitar la complejidad inherente al manejo de los datos, proporcionando mucha
flexibilidad al programador. Hay suficientes características como para montar desde una hoja de
cálculo básica hasta información para escribir un libro completo. Sin embargo, también es posible
crear una JTable relativamente simple si entiende correctamente el funcionamiento.

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 tabla
class TablaListener implements TableModelListener {
public void tableChanged( TableModelEvent evt ) {
for( int i=0; i < datos.length; i++ ) {
for( int j=0; j < datos[0].length; j++ )
System.out.print( datos[i][j] + " " );
System.out.println();
}
}
}
// Constructor
ModeloDatos() {
addTableModelListener( new TablaListener() );
}
// Devuelve el número de columnas de la tabla
public int getColumnCount() {
return( datos[0].length );
}
// Devuelve el número de filas de la tabla
public int getRowCount() {
return( datos.length );
}
// Devuelve el valor de una determinada casilla de la tabla
// identificada mediante fila y columna
public Object getValueAt( int fila,int col ) {
return( datos[fila][col] );
}
// Cambia el valor que contiene una determinada casilla de
// la tabla
public void setValueAt( Object valor,int fila,int col ) {
datos[fila][col] = valor;
// Indica que se ha cambiado
fireTableDataChanged();
}
// Indica si la casilla identificada por fila y columna es
// editable
public boolean isCellEditable( int fila,int col ) {
return( true );
}
}

public class java1416 extends JPanel {


public java1416() {
setLayout( new BorderLayout() );
JTable tabla = new JTable( new ModeloDatos() );
// La tabla se añade a un ScrollPane para que sea éste el
// que controle automáticamente en tamaño de la tabla,
// presentando una barra de desplazamiento cuando sea
// necesario
JScrollPane panel = new JScrollPane( tabla );
add( panel,BorderLayout.CENTER );
}

public static void main(String args[]) {


JFrame frame = new JFrame( "Tutorial de Java, Swing" );
frame.addWindowListener( new WindowAdapter() {
public void windowClosing( WindowEvent evt ) {
System.exit( 0 );
}
} );
frame.getContentPane().add( new java1416(),BorderLayout.CENTER );
frame.setSize( 200,200 );
frame.setVisible( true );
}
}

En el ejemplo, para no complicar la cosa, DataModel es quien contiene el conjunto de datos, pero
también se podrían haber cogido de una base de datos. El constructor añade un receptor de eventos
de tipo TableModelListener que va a imprimir el contenido de la tabla cada vez que se produzca un
cambio. El resto de los métodos utilizan la notación de los Beans y son utilizados por el
objeto JTable cuando se quiere presentar la información
del DataModel. AbstractTableModelproporciona por defecto los
métodos setValueAt() y isCellEditable() que se utilizan para cambiar los datos, por lo que si se quiere
realizar esta operación, no queda más remedio que sobrescribir los dos métodos.

La figura siguiente muestra la Tabla obtenida tras la ejecución del programa en donde se ha editado
la casilla correspondiente a la segunda fila y columna B.

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 < 8; i++ ) {


titColumna[i] = "Col: "+i;
}
}

// Creamos los datos para cada uno de los elementos de la tabla


public void CargaDatos() {
datoColumna = new String[100][8];

for( int iY=0; iY < 100; iY++ ) {


for( int iX=0; iX < 8; iX++ ) {
datoColumna[iY][iX] = "" + iX + "," + iY;
}
}
}

public static void main( String args[] ) {


JFrame ventana = new JFrame( "Tutorial de Java, Swing" );

ventana.addWindowListener( new WindowAdapter() {


public void windowClosing( WindowEvent evt ){
System.exit( 0 );
}
} );
ventana.getContentPane().add( new java1417(),BorderLayout.CENTER );
ventana.setSize( 300,180 );

ventana.setVisible( true );
}
}

La figura siguiente muestra el resultado de la ejecución del ejemplo. Obsérvese que cuano se
selecciona un elemento individual de la tabla, aparece una selección en cruz de fila y columna,
centrada en la celda que se ha marcado. En este ejemplo los colores de fondo y texto para la región
seleccionada se han alterado, que es otra de las facilidades que soporta el componente JTable, el
cambio de color para un área de selección.

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.

Home | Anterior | Siguiente | Indice | Correo

Tomado del siguiente enlace:

http://dis.um.es/~bmoros/Tutorial/parte14/cap14-13.html