Jyoc java-cap18 swing y java fx

TemariodecursoJavaSE©IñakiMartín
18.- Swing y JavaFX
TEMARIO DE CURSO
PROGRAMACIÓN JAVA SE
CAPÍTULO 18
SWING y JAVAFX
© Iñaki Martín
Este obra está bajo una licencia de Creative Commons Reconocimiento-NoComercial-SinObraDerivada 4.0 Internacional.

18.- Swing y JavaFX
AWT (AbstractWindowsToolkit) y SWING son librerías de clases para el desarrollo de GUIs (Graphic User
Interface, Interfaz de usuario gráfica, la comunicación con el usuario usando ventanas.)
AWT - Original de las primeras versiones.Algunos componentes de AWT usan código nativo y por ello es
dependiente de la plataforma . Paquete java.awt
SWING - extensión de AWT, arregla los problemas de AWT y añade muchas nuevos elementos.
Paquete javax.swing. Casi todo hereda de AWT.Container.
Ejemplos típicos de ventanas de Swing
Esta ventana es el típico formulario de solicitud de usuario
y clave para ingresar a una aplicación, usando la librería Swing.
Dentro de la ventana identificamos tres tipos de componentes:
1 Etiquetas o "Labels": User y Password son etiquetas.
2 Cajas de texto o "Text boxes": las dos cajas blancas a la
derecha de las etiquetas son cajas de texto.
3 Botones o "Buttons": login y register son botones.
Una forma simplificada de ventanas predefinidas son conocidas como
cajas de diálogo “Dialog”: Esta es una caja de diálogo para dar
simplemente un mensaje,"login failed" en este caso.
La siguiente es una caja de diálogo para
ingresar datos, en este caso el usuario.
Swing 2

18.- Swing y JavaFX
Componentes (elementos) que incluye Abstract Windows Toolkit (AWT) (en el paquete java.awt )
• Elementos GUI : 
- Contenedores (Panel, Frame, Dialog, etc. ) 
- Componentes primitivos (Button, Label, Checkbox, Scrollbar, etc. )
• Layout managers: FlowLayout, BorderLayout, etc.
• Clases de apoyo:
- Para la gestión de eventos: paquete java.awt.event
- Para gráficos: Color, Font, Graphics, etc.
- Para figuras geométricas; Point, Rectangle, Dimension, etc.
- Para tratamiento de imágenes: Image y más de java.awt.image
AWT y Swing
Elementos de AWT-Swing
3

18.- Swing y JavaFX
Toda la jerarquía de clases de Swing parte de la clase Component. Este es el diagrama principal de clases
(en azul las instanciables)
• Vemos que todo parte de Component, todo son componentes.
• Como primera division, hay contenedores y JComponents
• Un Container es una clase abstracta que representa una entidad que puede contener otros componentes
➡ Un Panel extiende de Container, y se trata de una ventana sin titleBar, menubar ni borde. Es la
superclase de Applet y JApplet, las clases para escribir ventanas en aplicaciones web.
➡ Un Window extiende de Container, y es la clase ventana superclass de todas las ventanas de escritorio.
Tiene el borde por defecto y no tiene menubar
➡ Un Frame y un Dialog son ventanas donde incluir otros componentes o contenedores. Sus hijas son las
clases habituales para crear ventanas de escritorio, JFrame y JDialog. Son ventanas que ya tienen
titleBar, menubar (con botones de minimizar, maximizar y cerrar) , borde y se pueden redimensionar.
Formato de ventanas
titleBar
menuBar
4

18.- Swing y JavaFX
Dos tipos, en dos grupos:
- Ventana estándar : JFrame y sus herederas (JPanel,… etc))
- Ventanas de dialogo: JDialog y sus herederas (JOptionPane,, JColorChooser, JFileChooser,… etc)
La diferencia fundamental es la ventanas estándar permiten la inclusión de cualquier tipo de elementos, mientras
que los diálogos son más pop-ups de mensajería e interacción directa con el usuario (mensajes de error, de aviso,
petición de introducción sencilla de opciones), y sobre todo, que pueden funcionar de forma modal.
Una ventana modal es aquella que, en el momento de hacerse visible, bloquea el acceso al usuario a todas las
otras ventanas del programa, hasta que se cierre la ventana modal.
Contenedor primario
Toda ventana Swing tiene al menus un contenedor inicial, primario o de alto nivel (un JFrame, JDialog o JApplet).
Dentro de el se pueden incluirse directamente componentes (botones, etiquetas, cajas de texto) u otros
contenedores, que a su vez pueden incluir mas componentes o contenedores, y así en cascada.
Para recoger el contenedor donde se van a incluir componentes, se usa el método
getContentPane()
Ventanas
Ventanas
5

18.- Swing y JavaFX
Clase JFrame Es un contenedor que incluirá otros elementos
Constructor sencillo: Jframe(String titulo)
JFrame jf = new JFrame("mi primera ventana");
Con esto se crea la ventana, pero no se ve. Hace falta al menos dos cosas:
1. Dar tamaño y posición. Usamos métodos (heredados de la clase Component) :
.setBounds(cx,cy,ancho,alto) cx y cy: coordenadas de esq sup izda (en referencia a la pantalla),
2. Hacerla visible
.setVisible(boolean)
Normalmente no se usa JFrame directamente, sino que se crean clases propias que extienden de JFrame y
tienen sus propia identidad:
Conviene que la visibilidad sea la ultima operación
Frame
package Swing;
import javax.swing.JFrame;
import javax.swing.WindowConstants;
public class JMiVentana extends JFrame{
// Constructor
//*****************
public JMiVentana (String titulo, int x, int y, int ancho,int alto){
super(titulo);
this.setBounds(x,y,ancho,alto);
this.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
this.setVisible(true);
}
}
Ventanas estándar: JFrame
6

18.- Swing y JavaFX
Al cerrar una ventana swing no se destruye, se oculta, con lo que el programa no acaba…
Para configurar como se comporta el botón de cierre se usa un método disponible en todas las ventanas:
.setDefaultCloseOperation(operation)
siendo operation una constante de la interfaz WindowsConstants:
DISPOSE_ON_CLOSE - Cierra la ventana y el objeto ventana, pero no acaba el programa
DO_NOTHING_ON_CLOSE - No hace nada
EXIT_ON_CLOSE - Cierra la ventana y acaba el programa
HIDE_ON_CLOSE - solo cierra la ventana (valor por defecto)
Cierre de ventanas
Botón de cierre
7

18.- Swing y JavaFX
Las ventanas de diálogo Se pueden dividir en dos grupos:
- Ventanas dialogo con funcionalidad específica: son similares a las estándar, solo que vienen ya con ciertas
funcionalidad incluida para dar agilidad a ciertas acciones (mensajes, avisos, selección de colores, etc). Entre
las clases más usadas están:
JOptionPane: para crear diálogos estándar simples.
ProgressMonitor: muestra un dialogo con un gráfico de progreso de una actividad
JColorChooser: ventanas de diálogo para seleccionar un color
JFileChooser: ventanas de diálogo para seleccionar un fichero
Printing API: se puede usar para crear diálogos de selección y control de impresoras e impresión
- Ventanas dialogo personalizadas. Se trata de usar la clase JDialog, con la cual el usuario puede construir un
diálogo a su medida. Los JDialog tienen casi las mismas posibilidades que un JFrame, por lo que para usar un
JDialog es como usar un JFrame.
Todos los diálogos dependen de un componente Frame, al igual que un JFrame. Cuando el componente
JFrame se destruye, se destruyen los diálogos dependientes de él, y cuando el JFrame se minimiza, los hacen
los dependientes también. Además, todos los diálogos dependen de un JDialog, cuando se implementa un
JOptionPane se esta usando un JDialog por detras, pues JOptionPane solo es un contenedor que crea
internamente un Dialog y se añade a si misma a echo contenedor.
Las ventanas de diálogo son casi todas modales.
Solo se puede hacer una ventana de dialogo no modal usando JDialog directamente.
Ventanas tipo Dialogo
Ventanas tipo Dialogo
8

18.- Swing y JavaFX
Clase JOptionPane
Ofrece muchos métodos para hacer varios tipos de diálogo estándar, aquí vamos a ver los 4 mas usados:
• showConfirmDialog() Para confirmación (de tipo si/no/salir o similar),
• showOptionDialog() Para ofrecer una opción,
• showInputDialog() Para Input, para meter datos,
• showMessage(): Para dar información.
Todos los métodos tienen varios constructores sobrecargados, y usan casi los mismos parámetros en sus
llamadas, por lo resumimos aquí los parámetros de los métodos más usados antes de ver cada método:
▪ parentComponent: Indica cual es la ventana de padre del JOptionPane.
Un objeto JOptionPane no necesita estar dentro de un JFrame, por que son ventanas independientes, pero sí se puede indicar qué ventana
llamó a este objeto. Se puede pasar null, aunque es mejor indicar el elemento (botón por ejemplo) que lanzó el JOptionPane.
▪ message: El mensaje a mostrar, habitualmente un String (o un toString() de un objeto, claro)
▪ title: Título para la ventana.
▪ optionType: Un int indicando qué opciones queremos que tenga la ventana.
Los posibles valores son constantes definidas en JOptionPane: DEFAULT_OPTION, YES_NO_OPTION,
YES_NO_CANCEL_OPTION, o OK_CANCEL_OPTION.
▪ messageType: Un int para indicar qué tipo de mensaje queremos mostrar. Esto determina entre otras qué icono se va a
mostrar. Los posibles valores son constantes de JOptionPane: ERROR_MESSAGE, INFORMATION_MESSAGE,
WARNING_MESSAGE, QUESTION_MESSAGE, o PLAIN_MESSAGE
▪ icon: Un icono para mostrar. Si ponemos null, saldrá el icono adecuado según el parámetro messageType. Si no,
usaremos las mismas constantes del messageType.
▪ options: Solo para los optionDialogs. Es un array de objects que son las posibles opciones.
‣ Si los objetos son componentes visuales, aparecerán tal cual como opciones.
‣ Si son String, el JOptionPane pondrá tantos botones como String.
‣ Si son cualquier otra cosa, se les tratará como String llamando al método toString().
‣ Si se pasa null, saldrán los botones por defecto que se hayan indicado en optionType.
▪ initialValue: Selección por defecto. Se puede pasar null.
JOptionPane
Ventanas tipo diálogo, JOptionPane
9

18.- Swing y JavaFX
• Permite al usuario elegir una opción.
• Métodos sobrescritos;
showConfirmDialog (parentComponent, mensaje)
El método devuelve un entero, que indica que opción se eligió, sobre las constantes ya comentadas.
showConfirmDialog(parentComponent, mensaje, titulo, tipoOpcion)
Permite personalizar el dialogo, indicándole un titulo y el tipo de opciones que ofrecerá el método, que
tambien es un int y que tambien ofrece constantes de JOptionPane para ejecutarse
showConfirmDialog(parentComponent, mensaje, titulo, tipoOpcion, tipoMensaje)
Igual que el anterior pero indicándole el tipo de mensaje (advertencia, error o información) con otra
constante).
Ventanas
Ventanas Confirmación : método showConfirmDialog().
10

18.- Swing y JavaFX
• Permite introducir información que se puede recoger desde nuestro programa.
• El método devuelve un String con lo que se introduzca en una caja de texto.
• Métodos sobrescritos:
showInputDialog(String message)
Permite mostrar un mensaje de dialogo, simplemente. Con tipo Object indica que puede
showInputDialog(parentComponent, message, title, messageType):
Permite mostrar un dialogo, con un titulo y un icono
Los iconos se definen con la mismas constantes ya vistas (error, información, advertencia, pregunta o plano)
Ventanas Input: método showInputDialog().
Ventanas
String nom = JOptionPane.showInputDialog (null,
"Introduzca nombre de usuario:",
"Introducir nombre:"
JOptionPane.PLAIN_MESSAGE);
System.out.println ("El nombre introducido es " + nom);
11

18.- Swing y JavaFX
• Permite simplemente mostrar información, sin pedir acción alguna al usuario salvo confirmación de la lectura.
• Se puede usar muy bien como sustituto de System.out.println().
• Métodos sobrescritos:
showMessage(parentComponent, message):
Sólo muestra un mensaje
showMessageDialog(parentComponent, message, title, messageType):
Personaliza el mensaje con un título y un icono.
El icono se define con las constantes ya vistas en los casos anteriores de diálogos.
Ventanas Info: método showMessage().
Ventanas 12

18.- Swing y JavaFX
• Permite mostrar una serie de opciones, de la cuales el usuario debe elegir una.
• Las opciones se pasan como parámetro y son un array de Strings.
• El método devuelve un entero que representa la posición de la opción que ha seleccionado el usuario.
• La primera de las opciones del array es la posición cero. Si se cierra la ventana sin elegir opción, el método
devolverá -1.
showOptionDialog(parentComponent, mensaje, titulo, optionType,messageType, icono, opciones, porDefecto)
class JMiVentana extends JFrame {
// Constructor
public JMiVentana(String titulo, int x, int y, int ancho, int alto) {
super(titulo);
this.setBounds(x, y, ancho, alto);
this.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
this.setVisible(true);
Object[] colores = { "Rojo", "Verde", "Azul" };
int valorElegido = JOptionPane.showOptionDialog(
null, // parentComponent, basta con null
"Escoja un color de la lista", // mensaje
"Ventana para elegir un color", // titulo de ventana
JOptionPane.YES_NO_CANCEL_OPTION, // opciones de acciones
JOptionPane.QUESTION_MESSAGE, // tipo de mensaje
null, // icono. null para icono por defecto
colores, // opciones de texto
colores[0]); // opcion por defecto
if (valorElegido != -1)
System.out.println("Se ha elegido el color " + (valorElegido + 1));
else
System.out.println("No se ha elegido color ");
}
}
Ventanas Option: método showOptionDialog().
Ventanas 13

18.- Swing y JavaFX
Clase JDialog
• Permite crear un cuadro de dialogo propio. Es parecido a una ventana JFrame, pero además puede funcionar
de forma modal.
• Al igual que con JFrame, podemos crear un objeto de la clase, o trabajar con una nueva clase que extienda
JDialog.
Constructor:
JDialog (frame, String titulo, boolean model)
- frame es una ventana sobre la se que se monta el JDialog . Puede ser vacía y nueva, como aquí
new JDialog (new frame(), "titulo", true)
- titulo es un String titulo de la ventana
- model es un boolean que indica si queremos que la ventana sea modal
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”, solo puede haber una cadena
única descendente.
Métodos:
En un JDialog podemos poner todos los componentes que queramos, haciendo la ventana todo lo compleja que
queramos, de idéntico modo a como se hace con un JFrame. Se puede por lo tanto ver en esta clase la manera
de trabajar con ventanas y aplicarla igualmente a JDialog.
Solo vemos un método especial de JDialog;
setModal(boolean acto) Aplicado a un objeto JDialog, indica si la ventana es modal o no
JDialog
Ventanas 14

18.- Swing y JavaFX
Todos ellos con clases que se pueden añadir en una ventana (JFrame o JDialog, p.e.) y comparten atributos y
métodos parecidos.
JLabel Para introducir texto no editable, sólo visible.
JButton Para crear botones sobre los que actuar.
JColorChooser Abre una ventana para poder seleccionar un color. Depende del S.O. que ventana abra.
JCheck Box Un checkBox es un componente que puede estar en dos estados, activado o desactivado
JRadioButton Un RadioButton es un componente para escoger entre varios valores, excluyentemente.
JList Representa una lista de elementos, con efecto scroll y posibilidad de multiselección
JComboBox Presenta un componente para elegir un valor en un desplegable
JTextField Vale para introducir un texto y que sea editable, pero que no tiene más de una linea
JPasswordField Similar a un TextField, solo que no se ve lo que se escribe, protegiéndose como contraseña
JTextArea Es un objeto para escribir texto, pero editándolo en multiples lineas
ImageIcon Es la implementación de una imagen de tipo icono
JScrollbar Representa una barra de desplazamiento que se puede usar junto con otros controles
JOptionPane Provee de un grupo de ventanas de dialogo para interactuar mas fácilmente con el usuario
JFileChooser Abre una ventana de dialogo para poder seleccionar un fichero. Su apariencia depende del S.O.
JProgressBar Una ventana que muestra un progreso, asociado normalmente a la ejecución de una tarea
JSlider Es un componente gráfico que permite elegir un valor desplazando un marcador con el ratón
JSpinner Es una linea simple de texto, que gráficamente cambia de valor para permitir elegir uno de ellos
Componentes GUI
Componentes GUI para usa en Swing
15

18.- Swing y JavaFX
• Muchos componentes heredan los mismos métodos, al heredar casi todos de clases base: Component,
JComponent, Container, JTextComponent…
• Estos métodos y atributos son los mismos o se comportan de modo muy parecido. Aquí se exponen los
métodos comunes mas usados (hay muchos más, claro)
• En siguientes apartados se tratan uno a uno los componentes mas importantes y sus métodos propios.
void setBounds(int x, int y, int width, int height): Ubica (o mueve) el componente y le da tamaño
void setToolTipText(String texto): Muestra el texto cuando se coloca el cursor encima del componente
void setText(String texto); En componentes con texto, indica el texto del mismo. Tiene su paralelo getText()
int getWidth() Da el ancho. No tiene un paralelo setWidth(), ver setBounds(). Sí tiene un paralelo getHeight()
int getX() Da la coordenada x. No tiene un paralelo setX(), ver setBounds(). Sí tiene un paralelo getY()
void setBackground(Color bg) Indica el color de fondo del componente. Tiene su paralelo getBackground ()
void setBorder(Border border) Indica el borde del componente, como un objeto Border
void setEnabled(boolean enabled) Indica si el componente esta enabled o no (activado o no)
void setFont(Font font) Indica la fuente de texto a usar en el componente. Tiene su paralelo getFont()
void setForeground(Color fg) Indica el color de texto del componente. Tiene su paralelo getForeground ()
void setVisible(boolean aFlag) Hace visible o imposible un componente
void update(Graphics g) Efectua un refresco del componente, enviándole un objeto Graphics.
void setName() Da un nombre al componente. Tiene su paralelo getName().
Container getParent() Devuelve el objeto que es el padre del componente actual, padre en la
jerarquía gráfica de nuestro programa
Dimension getSize() Devuelve el tamaño del componente, en un objeto Dimension
void setPreferredSize(Dimension d) Da tamaño a un componente con un objeto Dimension. Ejemplo:
Metodos básicos componentes GUI
Métodos para los componentes GUI de Swing
Métodos de uso general en la mayoría de componentes
16

18.- Swing y JavaFX
Métodos de JLabel:
setText(): Le coloca el String que recibe como argumento
getText(): Obtiene el texto que tiene el componente
setIcon(): Especifica un objeto Icon a mostrar en un JLabel
getIcon(): Obtiene el objeto Icon que esta en un JLabe
setHorizontaAignment(): Alinea un JLabel horizontalmente
setVerticalAlignment(): Alinea un JLabel Verticalmente
setFont() Define la font del texto. Ejemplo; milabel.setFont(new Font("Serif", Font.PLAIN, 14));
Métodos de JButton
setIcon(): Especifica un objeto Icon a mostrar en un JLabel
getIcon(): Obtiene el objeto Icon que esta en un JLabe
setRolloverIcon(): Imagen a mostrar en el JButton cuando se coloca el cursor sobre el
ActionListener: Interface de escucha que permite vigilar a un JButton en caso haya una accion sobre el.
ActionEvent: Cuando ActionListener detecta que hay una accion sobre el, envia un objeto ActionEvent.
actionPerformed(): Este metodo recibe el objeto ActionEvent y en el haremos las acciones que queramos.
Métodos de JTextField:
Métodos de cada componente
Metodos de cada componente 17

18.- Swing y JavaFX
Métodos de JPasswordField
void setText(): Le coloca el String que recibe como argumento
String getPassword(): Obtiene el password que tiene el componente.
Métodos de JCheckBox:
boolean isSelected(): determina si un objeto JCheckBox esta seleccionado.
Metodos de cada componente
JLabel etiqueta = new JLabel ();
final JCheckBox chkAzul = new JCheckBox ("Azul");
final JCheckBox chkRojo = new JCheckBox ("Rojo");
final JCheckBox chkVerde = new JCheckBox ("Verde");
chkAzul.setMnemonic (KeyEvent.VK_C);
chkAzul.addItemListener (new ItemListener () {
@Override
public void itemStateChanged (ItemEvent e) {
etiqueta.setText ("Azul elegido como: " + (e.getStateChange () == 1 ? "seleccionado" : "no seleccionado"));
}
});
// Añadimos elementos al contexto
this.getContentPane ().add (chkAzul);
this.getContentPane ().add (chkRojo);
this.getContentPane ().add (chkVerde);
this.getContentPane ().add (etiqueta);
18

18.- Swing y JavaFX
Métodos de JComboBox:
void setMaximunRowCount(): Establece el maximo de elementos a mostrar en un combo
boolean isSelected(): Determina si un objeto JCheckBox esta seleccionado.
String getSelectionItem(): Devuelve el objeto seleccionado
int getSelectionIndex(): Devuelve la posicion del objeto seleccionado
void setSelectionItem(): Establece el objeto seleccionado
void setSelectionIndex(): Establece el obeto seleccionado por medio de indice
ItemListemer: Interface de escucha de un JComboBox, JList.
ItemEvent: Cuando se detecta una accion (idem en JList, etc) se envia un evento ItemEvent.
itemStateChanged(): Metodo encargado de desencadenar acciones en un evento tipo ItemEvent.
Jcombobox usa un modelo, como JList, para añadir y gestionar los elementos de su lista.
DefaultComboBoxModel cbmodel = new DefaultComboBoxModel (); // Creamos el modelo y añadimos elementos
cbmodel.addElement ("Violin");
cbmodel.addElement ("Viola");
cbmodel.addElement ("Cello");
cbmodel.addElement ("ContraBajo");
final JComboBox cbInstrumentos = new JComboBox (cbmodel); // Creamos comboBox con el modelo,
cbInstrumentos.setSelectedIndex (0); //indicamos valor inicial seleccionado
JScrollPane scrollCbInstrumentos = new JScrollPane (cbInstrumentos);// Creamos el contenedor con scroll y dando el comboBox
JButton boton1 = new JButton ("Elegir"); // Creamos un boton para gestionar una accion
boton1.addActionListener (new ActionListener () {
public void actionPerformed (ActionEvent e) {
String data = "";
if (cbInstrumentos.getSelectedIndex () != -1) {
String res = (String) cbInstrumentos.getSelectedItem (); // sacamos el valor seleccionado
etiqueta.setText (res);
}
}
});
// Añadimos elementos al contexto
this.getContentPane ().add (scrollCbInstrumentos);
this.getContentPane ().add (boton1);
19

18.- Swing y JavaFX
Métodos de JRadioButton:
Un JRadioButton identifica cada uno de los elementos de un ButtonGroup.
Vale para crear objetos que se añaden a un ButtonGroup
Constructor: JRadioButton(Icon icon, boolean selected)
.setMnemonic() Asocia un atajo de teclado al radiobutton:
.itemStateChanged(ItemEvent e) Capturar evento de cambio en el valor del radiobutton:
Son los radiobuttons los que se añaden al contenedor, NO el radiogroup:
Métodos de ButtonGroup:
add(radiobutton rd) Añade un radio button al grupo
JRadioButton radViolin = new JRadioButton("Violín", true);
JRadioButton radViola = new JRadioButton("Viola");
JRadioButton radCello = new JRadioButton("Violoncello");
radViolin.addItemListener(new ItemListener() {
public void itemStateChanged(ItemEvent e) {
lbMensaje.setText("Asi esta el check:: "
+ (e.getStateChange()==1?”Pulsado":"No pulsado"));
}
});
radViolin.setMnemonic(KeyEvent.VK_C);
ButtonGroup grInstrumentos = new ButtonGroup();
grInstrumentos.add(radViolin);
grInstrumentos.add(radViola);
grInstrumentos.add(radCello);
this.getContentPane ().add (radViolin);
this.getContentPane ().add (radViola);
this.getContentPane ().add (radCello);
20

18.- Swing y JavaFX
Métodos de JList
• Un objeto JList tiene una lista de varios elementos, de los que se pueden seleccionar varios a la vez
• Generalmente no se añaden los elementos directamente en la JList, sino que se usa un modelo,
• Un modelo es una especie de plantilla donde se añaden y maneja n los objetos de una lista (tambien se usa en otros
componentes Swing).
• El modelo es un objeto representado por la interfaz ListModel, (habitualmente, se usa la clase DefaultListModel)
• Tras añadir el contenido, el modelo se añade a la JList.
• Hay un constructor para crear objetos JList pasando el ListModel como parámetro.
Métodos mas usuales;
void setVisibleRowCount(): Muestra la cantidad de elementos visibles
void setSelectionModel(tipo): Especifica el modo de selección de una JList. Tipo puede ser;
✤ ListSelectionModel.SINGLE_SELECTION Se permite solo seleccionar un elemento
✤ ListSelectionModel.SINGLE_INTERVAL_SELECTION Permite selección de varios elementos en un intervalo
✤ ListSelectionModel.MULTIPLE_SELECTION Permite selección de varios intervalo
void setListData(): Coloca elementos a mostrar en el JList
object getSelectedValue(): Devuelvo un Object con el elemento seleccionado
object [] getSelectedValues(): Devuelve un array de tipo Object con los elementos seleccionados
int [] getSelectedIndices(): Devuelve un array de tipo Object con los indices seleccionados
void setFixedCellWidth(): Establece la anchura de un objeto JList.
void setFixedCellHeight(): Establece la altura de cada elemento en un objeto JList.
void remove(index) Elimina el elemento (indicado por su indice)
ListSelectionEvent, ListSelectionListener Debe implementar el método valueChanged()
• Un objeto JList tiene elementos de cualquier tipo de objeto, no necesariamente String. Si el tipo no es String, se
representa el valor de toString del objeto.
• Pueden representarse en varias columnas (setLayoutOrientation) y de varios modos, por lo que suelen incluirse en
algún ScrollPane
Metodos de cada componente 21

18.- Swing y JavaFX JList
class EjemploJLIst {
private JFrame jfMiVentana;
private JLabel lblCabecera, lblPie;
private JPanel jpMiPanel;
public void inicializarGUI () {
jfMiVentana = new JFrame ("Ejemplo de JList");
jfMiVentana.setSize (300, 300);
jfMiVentana.setLayout (new GridLayout (3, 1));
lblCabecera = new JLabel ("", JLabel.CENTER);
lblPie = new JLabel ("", JLabel.CENTER);
lblPie.setSize (250, 100);
jpMiPanel = new JPanel ();
jpMiPanel.setLayout (new FlowLayout ());
jfMiVentana.add (lblCabecera);
jfMiVentana.add (jpMiPanel);
jfMiVentana.add (lblPie);
jfMiVentana.setVisible (true);
}
public void mostrarJList () {
lblCabecera.setText ("Seleccione una fruta del JList");
final DefaultListModel frutas = new DefaultListModel ();
frutas.addElement ("Manzana");
frutas.addElement ("Pera");
frutas.addElement ("Naranja");
frutas.addElement ("Sandia");
final JList listaFrutas = new JList (frutas);
listaFrutas.setSelectionMode (ListSelectionModel.SINGLE_SELECTION);
listaFrutas.setSelectedIndex (0);
listaFrutas.setVisibleRowCount (3);
JScrollPane frutasScrollPane = new JScrollPane (listaFrutas);
JButton boton1 = new JButton ("Elegir");
boton1.addActionListener (new ActionListener () {
@Override
String data = "";
if (listaFrutas.getSelectedIndex () != -1) {
data = "Fruta elegida: " + listaFrutas.getSelectedValue ();
}
lblPie.setText (data);
}
});
jpMiPanel.add (frutasScrollPane);
jpMiPanel.add (boton1);
jfMiVentana.setVisible (true);
}
}
public class Swing6_JList {
public static void main (String[] args) {
EjemploJLIst obEjemploList = new EjemploJLIst ();
obEjemploList.inicializarGUI ();
obEjemploList.mostrarJList ();
}
}
22

18.- Swing y JavaFX
Métodos de JTextArea:
• Un objeto JTextArea proporciona un área para manipular varias líneas de texto.
• Es una subclase de JTextComponent, al igual que JTextField.
static void createHorizontalBox() Método de Box crea un objeto Box que ordena los componentes de izquierda a
derecha, en el orden en el que se adjuntan.
void getSelectedText() Devuelve el texto seleccionado de un objeto JTextArea.
void setWrapStyleWord(): Establece el salto de linea entre palabras cuando el texto ocupe el ancho del area
void setEditable(boolean) Indica si el TextArea es editable
void setRows(int) Limita el numero de líneas disponibles
void selectAll() Selecciona todo el texo del componente
void append(String) Añade el texto indicado al final del JTextArea
void insert(String, int) Añade el texto indicado en la posición indicada
JLabel etiqueta = new JLabel ("CONTENIDO;", JLabel.RIGHT);
final JTextArea txaArea = new JTextArea ("En un lugar de la Mancha ... ", 5, 20);
JScrollPane scrollArea = new JScrollPane (txaArea);
JButton btCambiar = new JButton ("Cambiar");
btCambiar.addActionListener (new ActionListener () {
@Override
etiqueta.setText (txaArea.getText ());
}
});
this.getContentPane ().add (scrollArea);
this.getContentPane ().add (btCambiar);
23

18.- Swing y JavaFX Eventos
Eventos
Son las diferentes acciones que se pueden efectuar por la interacción del usuario con el programa.
Hay eventos de muchos tipos. Algunos ejemplos de eventos:
- actionEvent - eventos genéricos de acción (click,...)
- mouseEvent - eventos del ratón (click derecho, mover, etc)
- windowEvent – eventos sobre la ventana (coger foco, minimizar...)
- …
Más adelante veremos en detalle todos los eventos, vamos a seguir con el ejemplo de uso de actionEvent
Al momento de ocurrir el evento actionEvent, se crea un objeto del evento en cuestión, y se envía a un
“escuchador”. Un escuchador es una clase que hemos de construir para tal evento, que tenga el código de lo
que deseamos realizar en respuesta al evento.
Así que para que un componente de nuestro proyecto responda ante un determinado evento, hay que:
1.- Escribir un “escuchador” (listener , una clase “escuchadora”)
2.- Enlazar esta clase con el componente grafico que la “dispara”. Esto se hace junto con las propiedades del
componente, con el metodo void addActionListener(ActionListener l)
24

18.- Swing y JavaFX
A la hora de escribir una clase escuchadora (listener), ésta debe cumplir con ciertas interfaces que definen como ha de
hacerse nuestra clase, esto es, nuestra clase escuchadora debe implementar una interfaz-listener
Estas interfaces se llaman igual que el evento pero acabando en listener en vez de event:
- actionListener para un actionEvent,
- mouseListener para un mouseEvent,
- …
Estas interfaces permiten a nuestro
programa que quede “escuchando” a
ver si hacemos alguna acción con el.
El interfaz escuchador de actionEvent
es actionListener, que solo tiene un
método, actionPerformed(d), que es
el que deberemos sobrescribir
cuando hagamos nuestra clase
escuchadora.
A la derecha, un ejemplo de una clase
escuchadora para un actionListener,
y como añadirlo a un botón:
Listeners
Escuchadores (listeners)
public class Swing3 {
JMiVentana2 miVentana = new JMiVentana2 ("Mi Ventana", 300, 300, 300, 300);
}
}
class EscuchadorBoton1 implements ActionListener {
@Override
public void actionPerformed (ActionEvent ev) {
// AQUI VIENE EL CÓDIGO A EJECUTAR CUANDO SE PINCHE EN EL BOTON
JOptionPane.showMessageDialog (null, "Ha pulsado un boton !", "Cuidado",
JOptionPane.INFORMATION_MESSAGE);
}
}
class JMiVentana2 extends JFrame {
// Constructor
public JMiVentana2 (String titulo, int x, int y, int ancho, int alto) {
super (titulo);
this.setBounds (x, y, ancho, alto);
this.setDefaultCloseOperation (WindowConstants.DISPOSE_ON_CLOSE);
this.setLayout (null);
// Creo un boton1
JButton miBoton1 = new JButton ("Pulse desde el JFrame");
miBoton1.setBounds (2, 2, 200, 40);
miBoton1.addActionListener (new EscuchadorBoton1 ());
// Añadimos elementos
// Puedo añadir elementos directamente en la Frame, con getContentPane
this.getContentPane ().add (miBoton1); // añado el boton1
// Hacemos visible la ventana. No hace falta hacer visibles sus elementos
this.setVisible (true);
}
}
25

18.- Swing y JavaFX
๏ Pues lo que se va a hacer es coger el texto de lo que es el contenido de la clase en si (zona rosa) y se coloca donde se
invoca al objeto a crear:
Resultado:
๏ CUIDADO con los paréntesis y llaves de cierre (se muestran en diferentes colores para identificar los pares)
Listeners con Inner Class
Escuchadores (listeners) con Inner class
miBoton1.addActionListener ( new ActionListener () {
@Override
public void actionPerformed(ActionEvent ev) {
JOptionPane.showMessageDialog (null, "Ha pulsado un boton !",
"Cuidado", JOptionPane.INFORMATION_MESSAGE);
}
}
);
@Override
“Cuidado”, JOptionPane.INFORMATION_MESSAGE);
}
}
miBoton1.addActionListener ( unobjeto );class EscuchadorBoton1 implements ActionListener {
@Override
“Cuidado”, JOptionPane.INFORMATION_MESSAGE);
}
}
EscuchadorBoton1 unobjeto = new EscuchadorBoton1();
miBoton1.addActionListener ( unobjeto );
26
Eso si, hay que quitar lo de
EscuchadorBoton1() (que
ya no existe) y poner
ActionListener()
๏ Para gestionar un escuchador, se ha de escribir una clase escuchadora (listener), y llamarla desde el método escuchador del
componente correspondiente (un addActionListener de un botón, en el caso anterior)
๏ Pero no hace falta escribir directamente una nueva clase para el escuchador, si usamos las llamadas Inner class, o clase
internas. Para crear una clase interna, se “mete” en la invocación de un objeto el código de la propia clase.
y se llamaba así desde una ventana;๏ Un ejemplo; antes nuestra clase escuchadora era la siguiente:

18.- Swing y JavaFX JPanel
JMiVentana2 miVentana = new JMiVentana2 ("Mi Ventana", 300, 300, 300, 300);
}
}
JOptionPane.showMessageDialog (null, "Ha pulsado un boton !", "Cuidado",
JOptionPane.INFORMATION_MESSAGE);
}
}
class JMiVentana2 extends JFrame {
// Constructor
public JMiVentana2 (String titulo, int x, int y, int ancho, int alto) {
super (titulo);
// Valores del panel contenedor
JPanel jp = new JPanel ();
// Valores del boton
JButton miBoton1 = new JButton ("Pulse para ver que hago");
miBoton1.setPreferredSize (new Dimension (200, 40));
EscuchadorBoton1 objetoEscuchadorBoton = new EscuchadorBoton1 ();
miBoton1.addActionListener (objetoEscuchadorBoton);
// añadimos todo a la ventana
this.add (jp);
jp.add (miBoton1);
// hacemos visible la ventana contenedora y los elementos
miBoton1.setVisible (true);
}
}
Los componentes se pueden añadir directamente al JFrame (usando el método .getContentPane() para saber el
contexto donde añadir los elementos), o bien usando contenedores intermedios, Paneles, de los cuales el más usado es
JPanel. Este contenedor se puede usar anidado dentro de otro contenedor, y poner componentes en cualquier nivel:
JPanel
27

18.- Swing y JavaFX Layouts
Para tratar la ubicación de los componentes, podemos hacer dos cosas principalmente;
- Colocar los elementos usando coordenadas:
miLabel.setBounds(100, 70, 50, 50);
- Usar plantillas (Layouts) que vienen ya predefinidos para ubicar elementos gráficamente de modo automático
Un layout se asocia a un panel o a una ventana.
Si se desea usar coordenadas, hay que inhabilitar los layouts, pues un panel o ventana, al crearse, por defecto,
tienen un layout asociado. Se inhabilita poniendo el layout a null:
miPanel.setLayout(null)
Tipos de layouts:
(null) : No seleccionar un layout tambien tiene uso, especificamente, poder colocar los elementos con total
libertad, de modo absoluto, indicando para cada cosa su posicion. Mas tedioso y siempre absoluto, nunca
relativo al tamaño de la ventana o los efectos de redimension de esta
FlowLayout: Los elementos se colocan seguidos uno tras otro desde la esquina superior izquierda hacia la
derecha y hacia abajo. Es el layout asociado por defecto al crear paneles y ventanas
GridLayout: En orden como una tabla, indicando al crearse el tamaño de la tabla
BorderLayout: colocando pegado a los bordes desde arriba y en el sentido de las agujas de un reloj, y acabando
en el centro
GridBagLayout: Los elementos se colocan segun distribución
personalizada, siguien patrones de celdas personalizables
Layouts
28

18.- Swing y JavaFX Sin layout
public class VentanaPrincipal{
private JFrame frmPrincipal;
// MAIN QUE LANZA LA VENTANA
public static void main(String[] args){
EventQueue.invokeLater(new Runnable(){
@Override
public void run(){
try{
VentanaPrincipal window = new VentanaPrincipal();
window.frmPrincipal.setVisible(true);
} catch (Exception e){ e.printStackTrace(); }
}
});
}
// CONSTRUCTOR
public VentanaPrincipal(){
// ------------------ FRAME VENTANATABLERO
// ----------------------------------------
JFrame frmPrincipal = new JFrame();
frmPrincipal.setBounds(100, 100, 800, 600);
frmPrincipal.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frmPrincipal.setResizable(false);
frmPrincipal.setLayout(null);
JButton btnSeguir = new JButton("Seguir");
btnSeguir.setBounds(700, 10, 70, 40)
frmPrincipal.getContentPane().add(btnSeguir);
btnSeguir.addActionListener(new ActionListener()
JLabel lblFicha = new JLabel(“Texto del label");
lblFicha.setBounds(posicionx, posiciony, 33, 33);
frmPrincipal.getContentPane().add(lblFicha);
frmPrincipal.repaint();
}
}
Layout null
29
Poner especificamente setLayout(null); permite colocar los elementos con total libertad, de modo absoluto, indicando para cada
cosa su posicion. Siempre absoluto, nunca relativo al tamaño de la ventana o los efectos de redimension de esta.

18.- Swing y JavaFX FlowLayout
JMiVentanaConLayouts miVentana = new JMiVentanaConLayouts ("Mi Ventana", 300, 300, 300, 300);
}
}
class JMiVentanaConLayouts extends JFrame {
// Constructor
public JMiVentanaConLayouts (String titulo, int x, int y, int ancho, int alto) {
super (titulo);
this.setLayout (new FlowLayout ());
// Creo botones
JButton miBoton1 = new JButton ("UNO");
JButton miBoton2 = new JButton ("DOS");
JButton miBoton3 = new JButton ("TRES");
JButton miBoton4 = new JButton ("CUATRO");
JButton miBoton5 = new JButton ("CINCO");
this.getContentPane ().add (miBoton1);
// Hacemos visible la ventana. No hace falta hacer visibles sus elementos
}
}
FlowLayout()
30

18.- Swing y JavaFX
this.setLayout (new GridLayout (2, 3));
GridLaout
Estas son las ejecuciones del ejemplo anterior cambiando la instrucción del setLayout() por:
this.setLayout (new GridLayout ());
this.setLayout (new GridLayout (4,3));
¿Por que no ha hecho 4 filas ni 3 columnas?
Por que no caben en el tamaño especificado
por el JPanel…..
GridLayout ( rows, columns )
31

18.- Swing y JavaFX BorderLayout (I)
Se usa para colocar elementos en estructura de cuatro bordes y un centro
Con estos cambios en el ejemplo anterior se obtiene el resultado mas abajo indicado:
this.setLayout (new BorderLayout ());
this.getContentPane ().add (miBoton1, BorderLayout.PAGE_START);
this.getContentPane ().add (miBoton2, BorderLayout.LINE_START);
this.getContentPane ().add (miBoton3, BorderLayout.CENTER);
this.getContentPane ().add (miBoton4, BorderLayout.LINE_END);
this.getContentPane ().add (miBoton5, BorderLayout.PAGE_END);
BorderLayout ()
32

18.- Swing y JavaFX GridBagLayout (I)
Se usa para colocar elementos en estructura de filas y columnas, pero configurables por el usuario.
Imaginemos este objetivo
Para conseguirlo pensemos en dividir la pantalla en tantas filas y columnas como vayamos a necesitar para ubicar
individualmente todos los componentes
GridBagLayout() ()
Codigo de ejemplo de GridBagLayout son cortesía de http://www.chuidiang.org
33

18.- Swing y JavaFX
Comenzamos creando la ventana, y asignandole el laypiut GridBagLayout:
• Lo del getContentPane() es porque en realidad la ventana no es el contenedor, sino un componente que lleva internamente la
ventana y que se puede obtener a través de este método. Es a este componente al que debemos añadirle el layout y los
componentes (botoncitos y demás).
• Ahora debemos empezar a añadir componentes. Comencemos por el textArea. Podemos añadirlo con el método add() con un
solo parametro (el contenido del textArea), pero esto en realidad SOLO añade el área de texto, dejando al GridBagLayout total
libertad para decidir dónde y cómo ponerlo.
• Como queremos ubicarlo nosotros, usamos otro metodo add() que tiene un parametro más, que indica al layout dónde y cómo
colocar el componente.
• El segundo parámetro en este caso es un objeto de la clase GridBagConstraints, cuyos atributos guardan información de cómo
y dónde añadir el componente. De momento analizamos cuatro de estos atributos:
• GridBagConstraints.gridx nos dice la posición x del componente, es decir, el número de columna en la que está el
componente, siendo la columna 0 la primera columna de la izquierda. Si el componente ocupa varias columnas (como
nuestra área de texto), debemos indicar la columna en la que está la esquina superior izquierda del componente.
• GridBagConstraints.gridy nos dice la posición y del componente, es decir, el número de fila en la que está el componente,
siendo la fila 0 la primera fila de la parte de arriba. Si el componente ocupa varias filas (como nuestra área de texto),
debemos indicar la fila en la que está la esquina superior izquierda del componente.
• GridBagConstraints.gridwidth nos dice cuántas celdas en horizontal debe ocupar el componente.
• GridBagConstraints.gridheight nos dice cuantas celdas en vertical debe ocupar el componente.
class Ventana extends JFrame {
public Ventana() {
super ("Ejemplo 1"); // El título
this.getContentPane().setLayout (new GridBagLayout()); // Asignamos como layout un GridBagLayout
this.setSize(new Dimension(400,400));
}
}
JTextArea areaTexto = new JTextArea ("Area texto");
GridBagConstraints constraints = new GridBagConstraints();
constraints.gridx = 0; // El área de texto empieza en la columna cero.
constraints.gridy = 0; // El área de texto empieza en la fila cero
constraints.gridwidth = 2; // El área de texto ocupa dos columnas.
constraints.gridheight = 2; // El área de texto ocupa 2 filas.
this.getContentPane().add (areaTexto, constraints);
34GridBagLayout (II)

18.- Swing y JavaFX
El resto de elementos ocupan todos una fila y una columna, y se colocan asi;
Cuidado que estamos usando siempre la misma instancia de GridBagConstraints, si cambiamos uno de los atributos para un
componente, debemos restaurarlo luego para el siguiente.
Por ello es acosejable poner siempre todos los atributos, o hacer un nuevo objeto para cada componente
JButton boton1 = new JButton ("Boton 1");
constraints.gridx = 2;
constraints.gridy = 0;
constraints.gridwidth = 1;
constraints.gridheight = 1;
this.getContentPane().add (boton1, constraints);
JTextField campoTexto = new JTextField ("Campo texto");
this.getContentPane().add (campoTexto, constraints);
35GridBagLayout (III)

18.- Swing y JavaFX
• Si lanzamos la ventana con algo asi como un new Ventana().setVisible(true); vemos que sale esto:
• Lo que pasa es sólo le hemos dicho al GridBagLayout dónde colocar los componentes, no le hemos dicho cómo estirar las filas
y columnas, y esta todo por defecto: cada fila y columna es del tamaño mínimo necesario para albergar sus componentes y
están centradas dentro de la ventana.
• Ahor le diremos cómo se deben estirar las filas y columnas. Vemos que las dos primeras filas deben ser más anchas, la tercera
fila ya está bien de ancho. En cuanto a las columnas, la segunda es la que debe estirarse, la primera y tercera están bien.
• Para estirar filas y columnas, dentro del GridBagConstraints tenemos los campos weigthx y weigthy. El primero indica cómo
estirar las columnas. El segundo las filas.
• A estos campos debemos darles el valor 0.0 (que es el valor por defecto) si no queremos que la fila o columna se estire, y
debemos dar el valor 1.0 a las filas o columnas que queremos que se estiren hasta completar toda la ventana
• Hay un detalle a tener muy en cuenta: widthy afecta a una fila completa, no solo a un componente. Por ello, cada vez que
añadamos un componente a esa fila, debemos dar a widthy el mismo valor (0.0 o 1.0). Lo mismo pasa con widthx y las
columnas.
36GridBagLayout (IV)

18.- Swing y JavaFX
• El código queda asi añadiendo los widthx y widthy, y asi la ejecucion del mismo:
constraints.gridx = 0; // Columna 0. No necesita estirarse, no ponemos weightx
constraints.gridy = 0; // Fila 0. Necesita estirarse, hay que poner weighty
constraints.weighty = 1.0; // La fila 0 debe estirarse, le ponemos un 1.0
constraints.weighty = 0.0; // Restauramos al valor por defecto, para no afectar a los siguientes componentes.
constraints.gridx = 2; // Columna 2. No necesita estirarse, no ponemos weightx
constraints.gridy = 0; // Fila 0. Necesita estirarse, hay que poner weighty
constraints.weighty = 1.0; /* La fila 0 debe estirarse, le ponemos un 1.0.*/
constraints.weighty = 0.0; // Restauramos al valor por defecto, para no afectar a los siguientes componentes.
constraints.gridx = 2; // Columna 2, no necesita estirarse, no ponemos weigthx
constraints.gridy = 1; // Fila 1, necesita estirarse, hay que poner weigthy
constraints.weighty = 1.0; // La fila 1 debe estirarse, le ponemos 1.0
constraints.weighty = 0.0; // Restauramos el valor por defecto.
constraints.gridx = 0; // Columna 0, no necesita estirarse, no ponemos weigthx
constraints.gridy = 2; // Fila 2, no necesita estirarse, no ponemos weigthy
constraints.gridx = 2; // Columna 2, no necesita estirarse, no ponemos weightx
constraints.gridx = 1; // Columna 1, debe estirarse, le ponemos el weigthx
constraints.weightx = 1.0; // La columna 1 debe estirarse, ponemos el 1.0 en weigthx
/* Puesto que es el último componente, no restauramos el valor por defecto. Cuidado si más adelante añadimos más componentes*/
37GridBagLayout (V)

18.- Swing y JavaFX
• ¿Qué ha pasado ahora?. Pues que hemos dicho que estire las filas y columnas y es lo que ha hecho, pero como no le hemos
dicho nada sobre los componentes, no los ha estirado en absoluto.
• Para hacer que los componentes deben estirarse (el area de texto y el campo de texto para nuestro ejemplo) tenemos el
atributo fill del GridBagConstraints. Este puede tomar los siguientes valores:
• GridBagConstraints.NONE para que no se estire en ningún sentido, es la opción por defecto.
• GridBagConstraints.VERTICAL para que se estire sólo en vertical
• GridBagConstraints.HORIZONTAL para que se estire sólo en horizontal.
• GridBagConstraints.BOTH para que se estire en ambas dimensiones
• Si el componente no se estira en alguna dirección, podemos decirle por medio de anchor en GridBagConstraints qué posición
queremos que ocupe. Las posibilidades son
• GridBagConstraints.CENTER para que el componente ocupe el centro de la celda (opción por defecto)
• GridBagConstraints.NORTH para que se pegue a la parte superior, centrado en la misma.
• GridBagConstraints.NORTHEAST para que se pegue a la esquina superior derecha.
• ... (igual con el resto de puntos cardinales)
• GridBagConstraints.WEST para que se pegue al lado izquierdo, centrado en ese lado.
• GridBagConstraints.NORTHWEST para que se pegue a la esquina superior izquierda.
• En nuesto ejemplo básicamente nos queda decirle al area de texto de se ensanche en todos los sentidos, al campo de texto que
se ensanche en horizontal y a los botones 1 y 2 que ocupen la posicion NORTH de su celda. El código sería el siguiente:
// El area de texto debe estirarse en ambos sentidos. Ponemos el campo fill.
constraints.fill = GridBagConstraints.BOTH;
constraints.weighty = 1.0;
(… continua …)
38GridBagLayout (VI)

18.- Swing y JavaFX
constraints.anchor = GridBagConstraints.NORTH; // El botón 1 debe ocupar la posición NORTH de su celda
// El botón 1 no debe estirarse. Habíamos cambiado este valor en el area de texto, asi que lo restauramos.
constraints.fill = GridBagConstraints.NONE;
constraints.anchor = GridBagConstraints.CENTER; // Restauramos valores por defecto.
constraints.anchor = GridBagConstraints.NORTH; // El boton 2 debe ocupar la posición NORTH de su celda.
constraints.weighty = 0.0; // Restauramos valores por defecto.
constraints.anchor = GridBagConstraints.CENTER;
constraints.weightx = 1.0;
constraints.fill = GridBagConstraints.HORIZONTAL; // El campo de texto debe estirarse sólo en horizontal.
39GridBagLayout (VII)

Jyoc java-cap18 swing y java fx

Más contenido relacionado

La actualidad más candente (20)

Similar a Jyoc java-cap18 swing y java fx (20)

Más de Jyoc X (20)

Último (20)

Jyoc java-cap18 swing y java fx