Un layout se define como el objeto que controla el espacio de un elemento gráfico. Por ello estos elementos forman parte indispensable de toda interfaz ya que con ellos se es capaz de montar cualquier tipo de disposición. Lo primero que hay que tener en cuenta es que todo contenedor debe tener asignado un layout, por lo que elementos como JFrame, JPanel, JDialog, JInternalFrame deben de tener obligatoriamente un layout asignado. Inicialmente este tipo de elementos tiene asignado un layout por lo que si no se quiere cambiar ya está presente

  • JFrame: BorderLayout
  • Panel: FlowLayout
  • JInternalFrame: BorderLayout
  • JDialog: BorderLayout

Para poder asignar un layout a un contenedor se utiliza el método setLayout() sobre el componente. Si estamos hablando de un JFrame se utiliza el método getContentPane().setLayout().

BorderLayout

Layout basado en la situación de elementos en los puntos cardinales norte, sur, este, oeste o centro, dividiendo la pantalla en cada uno de los «sub-contentenedores» correspondientes. Para poder instancias este tipo de layout:

borderLayout = new BorderLayout();
// ó
borderLayout = new BorderLayout(10,10);
// donde los dos parámetros representa el espacio en x e y que se deja entre los componentes

Para poder añadir elementos en los puntos cardinales antes explicados se utiliza el método add indicando como parámetros el elemento a añadir y el sitio donde se añade

this.getContentPane().setLayout(borderLayout);
this.getContentPane().add(new JLabel("Elemento central", JLabel.CENTER),BorderLayout.CENTER);
this.getContentPane().add(new JLabel("Elemento norte", JLabel.CENTER),BorderLayout.NORTH);
this.getContentPane().add(new JLabel("Elemento sur", JLabel.CENTER),BorderLayout.SOUTH);
this.getContentPane().add(new JLabel("Elemento este", JLabel.CENTER),BorderLayout.EAST);
this.getContentPane().add(new JLabel("Elemento oeste", JLabel.CENTER),BorderLayout.WEST);

BoxLayout

Layout que organiza los elementos en horizontal o en vertical. Para poder instanciar este layout se indica el elemento que lo contiene y la organización de los elementos:

//elementos en vertical
boxLayout = new BoxLayout(this.getContentPane(),BoxLayout.Y_AXIS);
//ó
//elementos en horizontal
boxLayout = new BoxLayout(this.getContentPane(),BoxLayout.X_AXIS);

Este tipo de layout guarda el tamaño establecido de los elementos que lo forman.

this.getContentPane().setLayout(boxLayout);
    JLabel l1 = new JLabel("Elemento1");
    l1.setPreferredSize(new Dimension(200,200));
    this.getContentPane().add(l1);
    this.getContentPane().add(new JLabel("Elemento2", JLabel.CENTER));
    this.getContentPane().add(new JLabel("Elemento3", JLabel.CENTER));
    this.getContentPane().add(new JLabel("Elemento4", JLabel.CENTER));
}

Adicionalmente se puede crear un área en blanco para manejar mejor el espacio o bien crear unas restricciones en horizontal o vertical que dejan fijo un elemento

this.getContentPane().add(Box.createRigidArea(new Dimension(50,59)));<br>
this.getContentPane().add(Box.createVerticalGlue());
this.getContentPane().add(Box.createHorizontalGlue());

CardLayout

Layout que se encarga de manejar más de un componente (por regla general Jpanel que a su vez tienen layouts) donde tan solo uno de ellos es mostrado y en cualquier momento puede ser ocultado. Actúa como una pila de elementos. Para poder instanciarlo:

cardLayout = new CardLayout();
//ó
//cardLayout = new CardLayout(10,10);

Para añadir un elemento al cardlayout tan solo hay que agregarlo al panel que maneja el layout indicando también un identificador por el que más adelante será llamado

pCentral.add(p1,"elemento1");
pCentral.add(p2,"elemento2");
pCentral.add(p3,"elemento3");
pCentral.add(p4,"elemento4");

Para poder mostrar un panel específico se usa

cardLayout.show(pCentral,"panel1");

Para mostrar el siguiente, anterior, primero o último elemento de la lista

cardLayout.first(pCentral);
cardLayout.previous(pCentral);
cardLayout.next(pCentral);
cardLayout.last(pCentral);

FlowLayout

Layout que sitúa los elementos en horizontal o vertical. Se trata de un layout muy similar al primero explicado con la diferencia que aquí no se pueden incluir áreas rígidas o zonas finas y coloca los elementos en fila repartiendo el espacio entre ellos donde si no hay espacio suficiente empieza filas nuevas.

flowLayout = new FlowLayout(FlowLayout.CENTER,5,5);

GridLayout

Layout que organiza los elementos en filas y columnas. Los elementos se van agregando de izquierda a derecha teniendo en cuenta las filas/columnas creadas. El número de elementos en el constructor son 2 (filas/columnas) o 4 (filas,columna,espacio fila,espacio columnas)

gridLayout = new GridLayout(2,2,5,5);

Los métodos respetables son los referentes a las filas columnas:

gridLayout.setColumns(2);
gridLayout.setRows(2);
gridLayout.getColumns();
gridLayout.getRows();

GridBagLayout

Layout que divide el espacio en filas columnas de forma flexible dependiendo del número de elementos que este agregados al contenedor. Se trata de uno de los layouts más poderosos pero a la vez uno de los más difíciles de manejar debido a las restricciones que tiene.

gridBagLayout = new GridBagLayout();
gridBagConstraints = new GridBagConstraints();

El primer elemento es el propio layout, mientras que el segundo son las restricciones que se adjuntarán a cada elemento a la hora de incluirlo en un componente. Las restricciones son las siguientes:

  • gridx / gridy: ubicación del elemento en concreto expresado en fila columna. Hay que tener en cuenta que la primera fila / columna hace referencia a la posición 0. En el caso de ser el último elemento de la fila / columna se utiliza el valor GridBagConstrain.RELATIVE
  • gridWidth / gridHeight: indica el número de filas o columnas que ocupará el elemento. Si el componente es el último de la fila se utiliza la constante GridBagConstrain.REMAINDER. Si el componente es el primero de la fila se utiliza la constante GridBagConstraint.RELATIVE
  • fill: indica como se rellena el espacio vacío por el elemento que ocupa la «cuadrilla». Este relleno puede ser HORIZONTAL, VERTIAL, BOTH, NONE
  • weightx / weighty: indica como se distribuyen los pesos a lo largo de filas o columnas cuando una interfaz se escala. Los valores estarán comprendidos entre 0.0 y 1.0
  • inset: indica el padding externo  que se asignará a cada uno de los elementos. Se define como un objeto individual p.e new Inset(1,1,1,1)
  • ipdax / ipady: indica el padding externo  que se asignará a cada uno de los elementos.
  • anchor: indica la gravedad del elemento dentro de su celda. Se indica mediante una constante y sus valores pueden ser CENTER (the default), PAGE_START, PAGE_END, LINE_START, LINE_END, FIRST_LINE_START, FIRST_LINE_END, LAST_LINE_END, and LAST_LINE_STAR

Para poder agregar un elemento a un contenedor que tiene GridBagLayout se utiliza el método add donde como parámetro se pasa el elemento y el objeto constraint con las variables explicadas arriba

//fila 0 columna 0
gridBagConstraints.gridx =0;
gridBagConstraints.gridy =0;
gridBagConstraints.weightx=0;
gridBagConstraints.anchor = GridBagConstraints.CENTER;
gridBagConstraints.insets = new Insets(5,5,5,5);
this.getContentPane().add(new JLabel("Nombre"),gridBagConstraints);

//fila 0 columna 1
gridBagConstraints.gridx =1;
gridBagConstraints.gridy =0;
gridBagConstraints.weightx=1;
gridBagConstraints.fill=GridBagConstraints.HORIZONTAL;
gridBagConstraints.anchor = GridBagConstraints.CENTER;
gridBagConstraints.insets = new Insets(5,5,5,5);
this.getContentPane().add(nombre,gridBagConstraints);

//fila 1 columna 0 espacios 2
gridBagConstraints.gridx =0;
gridBagConstraints.gridy =1;
gridBagConstraints.gridwidth = 2;
gridBagConstraints.weightx=1;
gridBagConstraints.fill=GridBagConstraints.HORIZONTAL;
gridBagConstraints.anchor = GridBagConstraints.CENTER;
gridBagConstraints.insets = new Insets(5,5,5,5);
this.getContentPane().add(enviar,gridBagConstraints);

SpingLayout

Layout que define cada uno de los componentes indicando la distancia a la que se encuentra del siguiente componente añadido. Ademas de añadir los elementos con el método add(), se tienen que añadir al layout las restricciones de colocación mediante el  método putConstraint() donde se indican como parámetros punto desde donde se toma la relación, elemento del que se toma, distancia, punto desde el que se tiene relación de espacio, elemento del que se toma

springLayout.putConstraint(SpringLayout.WEST,bPanel2,10,SpringLayout.EAST,bPanel3);

GroupLayout

Layout que define grupos de componentes horizontales y verticales de forma que se puedan tratar de forma independiente. En el constructor de este layout hay que indicar el contenedor al que está asignado

groupLayout = new GroupLayout(this.getContentPane());

A la hora deañadir elementos no se hace directamente sobre el contenedor sino que se añaden a grupos los cuales se añaden al layout

        groupLayout.setAutoCreateContainerGaps(true);
        groupLayout.setAutoCreateGaps(true);

        groupLayout.setHorizontalGroup(groupLayout.createSequentialGroup()
                .addGroup(groupLayout.createParallelGroup()
                        .addComponent(lblNombre)
                        .addComponent(lblApellidos)
                )
                .addGroup(groupLayout.createParallelGroup()
                        .addComponent(nombre)
                        .addComponent(apellido1)
                        .addGroup(groupLayout.createSequentialGroup()
                                .addGroup(groupLayout.createParallelGroup()
                                        .addComponent(enviar)
                                )
                                .addGroup(groupLayout.createParallelGroup()
                                        .addComponent(borrar)
                                )
                        )
                )
                .addGroup(groupLayout.createParallelGroup()
                        .addComponent(lblInicial)
                )

        );
        groupLayout.setVerticalGroup(groupLayout.createSequentialGroup()
                .addGroup(groupLayout.createParallelGroup()
                        .addComponent(lblNombre)
                        .addComponent(apellido1)
                        .addComponent(lblInicial)
                        .addComponent(iniciales))

                .addGroup(groupLayout.createParallelGroup()
                        .addComponent(lblApellidos)
                        .addComponent(apellido1)
                )
                .addGroup(groupLayout.createParallelGroup()
                        .addComponent(enviar)
                        .addComponent(borrar)
                )
        );