Repaso

Clase Date

Cuando se utiliza la clase Date, el tiempo se representa mediante el número de milisegundos transcurridos a partir de un punto prefijado, la denominada época que es 00:00:00 UTC que denota Tiempo Universal Coordinado, esto es la hora estándar científica, que a efectos prácticos es más conocido como Hora Media de Greenwich (GMT).

Clase Gregorian Calendar

Mientras que la clase Date reprensenta un instante en el tiempo, la clase Gregorian Calendar expresa las fechas con la notación de calendario.

new GregorianCalendar();
new GregorianCalendar(2015,11,31);
new GregorianCalendar(2015,Calendar.DECEMBER,31);
new GregorianCalendar(2015,Calendar.DECEMBER,31,23,59,59);

GregorianCalendar fechaLimite = new GregorianCalendar(...);

Métodos de consulta y modificación

GregorianCalendar ahora = new GregorianCalendar();
int mes = ahora.get(Calendar.MONTH);
int diaSemana = ahora.get(Calendar.DAY_OF_WEEK);

Permite calcular atributos de un instante de tiempo (por ejemplo día de la semana mes, año, etc). Se utiliza el método get y una constante definida.

También permite setear estos mismos atributos con el método set.

fechaLimite.set(Calendar.YEAR, 2015);
fechaLimite.set(Calendar.MONTH, Calendar.APRIL);
fechaLimite.set(Calendar.DAY_OF_MONTH,15);

Se pueden añadir un cierto número de días, semanas y meses.

fechaLimite.add(Calendar.MONTH,3);

Relación entre Date y GregorianCalendar

Los métodos setTime y getTime determinan o fijan el instante de tiempo que representa un objeto tipo calendario.

Date lahora = calendario.getTime();
calendario.setTime(lahora);

Si se conoce día, mes y año y se quiere un objeto Date:

GregorianCalendar calendario = new GregorianCalendar(anio,mes,dia);
Date fechaContrato = calendario.getTime();

Si se desea averiguar el año, mes o día de un objeto Date:

GregorianCalendar calendario = new GregorianCalendar();
calendario.setTime(fechaContrato);
int anio = calendario.get(Calendar.YEAR);

Clase SimpleDateFormat

Nos ayuda a mostrar las fechas en el formato que queramos o a reconstruirlas a partir de una cadena de texto.

import java.text.SimpleDateFormat;
...
SimpleDateFormat formateador = new SimpleDateFormat("dd/MM/yyyy");

// Esto muestra la fecha actual en pantalla así 05/07/2016
System.out.println(formateador.format(new Date()));

Para reconstruir una fecha a partir de la cadena de texto, podemos usar la misma clase SimpleDateFormat. Por ejemplo, si un usuario escribe una fecha con este formato en un JTextField, podemos leerla así

JTextField textField = new JTextField();
SimpleDateFormat formateador = new SimpleDateFormat("dd/MM/yyyy");
try
{
   Date fecha = formateador.parse(textField.getText());
}
catch (ParseException e)
{
   // Error, la cadena de texto no se puede convertir en fecha.
}

Una cosa interesante es que a la hora de convertir un String a Date, la clase SimpleDateFormat es "indulgente", es decir, si metemos mal el String, trata de corregirlo. Por ejemplo, si introducimos una fecha "32 de Enero", no obtendremos error, sino que se arreglará y nos devolverá un Date correspondiente a "1 de Febrero". Podemos eliminar este comportamiento con el método setLenient(false);

SimpleDateFormat formateador = new SimpleDateFormat("dd/MM/yyyy");
formateador.setLenient(false);

de esta forma, el "32 de Enero" dará un error.

Otro aspecto importante a tener en cuenta es nunca utilizar

SimpleDateFormat formateador = new SimpleDateFormat("dd/mm/yyyy");

debido a que mm se refiere a minutos y no meses

Introducción al manejo de disposiciones (Layouts)

FlowLayout

• Layout predeterminado que tienen todos los JPanel.
• Alinea los componentes horizontalmente hasta que no queda más espacio y después hace que empiece una nueva fila de componentes. 
• Cuando se modifica el tamaño del contenedor, reorganiza automáticamente los componentes para ocupar el espacio disponible.
• Por defecto los componentes se centran en el contenedor. Las otras opciones puede ser alinearlo a derecha o izquierda.

lamina.setLayout(new FlowLayout(FlowLayout.LEFT));

FlowLayout(int alineacion, int espX,int espY)

BorderLayout

• Layout predeterminado que tienen todos los JFrame.
• Nos permite seleccionar el lugar que deseamos colocar cada componente (norte, sur, este, oeste o centro).
• Primero se sitúan los componentes de los bordes y luego el componente del centro ocupa el espacio restante.
• Cuando se modifican las dimensiones del contenedor las dimensiones de los componentes de los bordes no varian, pero el componente del centro si.

Los componentes se añaden especificando una constante llamada CENTER, NORTH, SOUTH, EAST o WEST.

lamina.setLayout(new BorderLayout());
lamina.add(botonAmarillo, BorderLayout.SOUTH);

• No es necesario que todas las posiciones estén ocupadas.
• Si no se proporciona ningún valor, se supone que la posición deseada es CENTER.
• A diferencia del FlowLayout que deja cada componente con su tamaño preferido, el BorderLayout hace que los componentes crezcan hasta llenar todo el espacio disponible.
• Se puede especificar el espacio entre regiones en el constructor.

BorderLayout(int espX, int espY)

Un BorderLayout no es excesivamente útil por si mismo.

setLayout(new BorderLayout());
JButton botonAmarillo = new JButton("Amarillo");
JButton botonAzul = new JButton("Azul");
JButton botonRojo = new JButton("Rojo");
		
add(botonAzul,BorderLayout.NORTH);
add(botonRojo,BorderLayout.CENTER);
		
JPanel contenedor = new JPanel();
contenedor.add(botonAmarillo);
add(contenedor,BorderLayout.SOUTH);

setLayout(new BorderLayout());
JButton botonAmarillo = new JButton("Amarillo");
JButton botonAzul = new JButton("Azul");
JButton botonRojo = new JButton("Rojo");


add(botonAmarillo,BorderLayout.SOUTH);
add(botonAzul,BorderLayout.NORTH);
add(botonRojo,BorderLayout.CENTER);

GridLayout

• Organiza todos los componentes en filas y columnas.
• Las celdas siempre son de un mismo tamaño.
• Cuando se modifica el tamaño de la ventana, las celdas crecen o decrecen pero todas tienen el mismo tamaño.

En el constructor se especifica el número de filas y columnas deseado.

lamina.setLayout(new GridLayout(5,4));

También se puede especificar los espacios horizontales y verticales que se deseen. Se especifican en los últimos 2 parámetros del constructor.

lamina.setLayout(new GridLayout(5,4,3,3);

Los componentes se van añadiendo, empezando por la primera entrada de la primera fila, para añadir después la segunda entrada de la primera fila y así sucesivamente

lamina.add(new JButton("1"));
lamina.add(new JButton("2"));

Introducción de texto

JTextField

Un campo de texto admite una línea de texto.

JTextArea

Una zona de texto admite múltiples líneas de texto.

JTextComponent

void setText (String texto)

String getText()

Campos de texto

Añadiendo campos de texto

JPanel lamina = new JPanel();
JTextField campoDeTexto = new JTextField("Valor predetermindado", 20);
lamina.add(campoDeTexto);

Segundo parámetro refiere a "columnas". Puede ser impreciso. Se pueden cambiar las columnas durante la ejecución:

campoDeTexto.setColumns(10);
lamina.revalidate();

Se puede modificar el contenido del campo de texto en cualquier momento utilizando setText

campoDeTexto.setText("Hola");

Se puede averiguar lo que ha escrito el usuario llamando al texto getText. Para recortar posibles espacios en blanco anteriores y posteriores usamos trim.

String texto = campoDeTexto.getText().trim();

Rótulos y Rotulación de Componentes

• Son componentes que contienen un texto
• Carecen de ornamentación (por ejemplo no tienen bordes)
• No reaccionan frente a entradas de usuario.
• Se puede usar un rótulo para identificar componentes.

Constructores:

• JLabel(String texto)
• JLabel(Icon icono)
• JLabel(String texto, int alineación)
• JLabel(String texto,Icon icono,int alineación)

JLabel rotulo = new JLabel("Minutos",JLabel.RIGHT);

Eventos en campos de texto

Los campos de texto en Swing están representados de la siguiente forma: la cadena que se ve en el campo de texto es solo una manifestación visible (la vista) de una estructura de datos subyacente (el modelo).

El modelo de todos los componentes de texto se describe mediante la interfaz Document.

Se le puede pedir a Document que nos envíe una notificación siempre que cambies los datos. 

campoDeTexto.getDocument().addDocumentListener(oyente);

DocumentListener

private class OyenteCampos implements DocumentListener {
    public void insertUpdate(DocumentEvent evento) {}
    public void removeUpdate(DocumentEvent evento) {}
    public void changeUpdate(DocumentEvent evento) {}
}

Campos de Contraseña

JPasswordField

Cada carácter que se escribe se representa mediante un carácter de eco, que generalmente va a ser un asterisco *.

• JPasswordField() Constructs a new JPasswordField, with a default document, null starting text string, and 0 column width.

  JPasswordField(Document doc, String txt, int columns) Constructs a new JPasswordField that uses the given text storage model and the given number of columns.

  JPasswordField(int columns) Constructs a new empty JPasswordField with the specified number of columns.

  JPasswordField(String text) Constructs a new JPasswordField initialized with the specified text.

  JPasswordField(String text, int columns) Constructs a new JPasswordField initialized with the specified text and columns.

void setEchoChar(char eco): determina el carácter de eco para este campo de contraseña.

char[] getPassword(): proporciona el texto contenido en este campo de contraseña. Para mayor seguridad se debe reescribir el contenido de la matriz proporcionada después de utilizarla. La contraseña no se proporciona como cadena porque la cadena permanecería en la máquina virtual hasta que actue el garbage collector. 

Campos de entrada con formato

Entrada de enteros

JFormattedTextField campoInt = new JFormattedTextField(NumberFormat.getIntegerInstance());

Al igual que los campos de texto pueden setearse las columnas:

campoInt.setColumns(6);

Se puede especificar un valor predeterminado:

campoInt.setValue(new Integer(100));

Obtener el valor ingresado:

Number valor = (Number) campoInt.getValue();
int v = valor.intValue();

Comportamiento frente a la pérdida de foco

Cuando pierde el foco, el formateador examina la cadena de texto que ha generado el usuario.

Si el formateador conoce la forma de traducir la cadena de texto a un objeto, el texto es válido. De lo contrario es inválido.

Se puede utilizar el método isEditValid

Existen distintos comportamientos.

Comportamientos:

• Admisión o reinstauración: es el predeterminado. Si la cadena es válida se admite. El encargado de formato la convierte a un objeto. Si la cadena no es válida , el valor no se modifica y se reinstaura como valor la cadena que representa el valor anterior.
• Commit: Si la cadena de texto no es válida, tanto la cadena de texto como el valor de campo permanecen inalterados (no están sincronizados).
• Persist: aunque la cadena de texto sea válida, ni el campo de texto ni el valor actual llegan a modificarse. Sería necesario llamar al commitEdit, setValue o setText para sincronizarlos.
• Revert: (no es útil) se descarta la entrada del usuario y la cadena de texto vuelve a su valor anterior.

Verificadores

• Es un mecanismo para avisarle al usuario que las entradas son incorrectas.
• Se puede asociar a cualquier JComponent.
• Si el componente pierde el foco, entonces se consulta al verificador. 
• Si el verificador informa que el contenido del componente no es válido, entonces el componente vuelve a recibir inmediatamente el foco.
• Extiende de la clase abstracta InputVerifier y tiene que redefinir un método verify

Para aplicarlos a campos de texto se utiliza el método isEditValid de la clase JFormattedTextField.

class Verificador extends InputVerifier {
    
    public boolean verify(JComponent componente)
    {
        JFormattedTextField campo = (JFormattedTextField) componente;
        return campo.isEditValid();
    }
}

Se puede asociar a cualquier JFormattedTextField

campoInt.setInputVerifier(new Verificador());

Problema: si se hace click en un botón, entonces el botón envía notificaciones a sus oyentes de acción antes que un componente de contenido incorrecto pueda volver a conseguir el foco. 

Otros formateadores estándar

Además del formateador para números enteros, el JFormattedTextField admite otros. La clase NumberFormat posee los método estáticos:

• getNumberInstance (números con coma flotante)
• getCurrencyInstance (valores monetarios)
• getPercentInstance (porcentajes)

JFormattedTextField campoMonetario = new FormattedTextField(NumberFormat.getCurrencyInstance());

Para editar fechas y horas, invoque uno de los métodos estáticos de la clase DateFormat:

• getDateInstance
• getTimeInstance
• getDateTimeInstance

JFormattedTextField campoFechas = new JFormattedTextField(DateFormat.getDateInstance());

Este campo permite editar fechas con el formato predeterminado o medio (medium), como el siguiente:

Feb 24, 2016

Se puede seleccionar el corto:

2/24/16

efectuando la llamada:

DateFormat.getDateInstance(DateFormat.SHORT)

MaskFormatter

Es útil para patrones de tamaño fijo que contengan algunos caracteres constantes y algunos variables, por ejemplo patentes de autos.

new MaskFormatter("##UUU##");

Símbolos de MaskFormatter

Se pueden restringir los carácteres que se pueden escribir en el campo invocando a uno de los métodos de MaskFormatter:

setValidCharacters

setInvalidCharacters

Por ejemplo en el sistema de calificaciones de EEUU se podría usar:

MaskFormatter formateador = new MaskFormatter("U*");
formateador.setValidCharacters("ABCD+-");

Pero no hay forma de especificar que el segundo caracter no puede ser una letra.

Áreas de texto

Sirve para obtener entradas de usuario que ocupan más de una línea. Se utiliza el componente JTextArea.

• En el constructor del JTextArea se especifica el número de filas y columnas de la zona de texto.

// 8 líneas de 40 columnas cada una
JTextArea zonaTexto = new JTextArea(8,40);

• El usuario no está limitado al número de filas y columnas, el texto se desplaza ante entrada muy extensas.
• Se pueden usar los métodos setColumns y setRows para cambiar el número de filas y columnas.

• Si hay más texto que el que se puede visualizar en la zona de texto, entonces el texto restante se recorta. Podemos evitar que se recorten las líneas más largar activando los saltos de línea automáticos.

//las líneas largas pasan automáticamente a la siguiente
zonaTexto.setLineWrap(true);

• En Swing, las zonas de texto carecen de barras de desplazamiento. Si deseamos barras de desplazamiento, es necesario agregar la zona de texto dentro de una lámina con desplazamiento.

zonaTexto = new JTextArea(8,40);
JScrollPanel laminaDesplazamiento = new JScrollPanel(zonaTexto);

Componentes de selección

Casillas de verificación

El usuario marca el cuadro haciendo click en su interior y lo deja sin marcar haciendo click de nuevo. También puede pulsar la barra espaciadora cuando tiene el foco. 

Las casillas de verificación precisan un rótulo para identificar su propósito, se da en el constructor: 

JCheckBox casilla = new JCheckBox("Opcion 1");

Para activar o desactivar una casilla de verificación se utiliza el método setSelected:

casilla.setSelected(true);

El método isSelected() recupera entonces el estado actual de la casilla de verificación, toma el valor false si no esta marcaba y true si lo esta.

Boolean estaSeleccionada = casilla.isSelected();

Cuando el usuario hace click en una casilla de verificación, se genera un evento de acción. Podremos asociar entonces, un oyente de acciones a la casilla de verificación.

ActionListener oyente = ...;
casilla.addActionListener(oyente);

Botones de radio

En las casillas de verificación el usuario puede marcar una de las casillas, las dos o ninguna. En muchos casos necesitamos que el usuario marque tan solo una. Cuando se marca otra casilla, la que estuviera marcada anteriormente, se quedaría sin marcar automáticamente. Estos grupos de cuadros suelen denominarse grupos de botones de radio.

Implementando grupos de botones

Se construye un objeto de tipo ButtonGroup para cada grupo de botones. Después se van añadiendo objetos de tipo JRadioButton al grupo de botones. El objeto de grupo de botones tiene la responsabilidad de desactivar el botón que estuviera activado anteriormente cuando se hace click en un nuevo botón.

ButtonGroup grupo = new ButtonGroup();
JRadioButton botonPequeño = new JRadioButton("Pequeño", false);
grupo.add(botonPequeño);
JRadioButton botonMediano = new JRadioButton("Mediano",true);
grupo.add(botonMediano);
...

El segundo argumento del constructor es true para el botón que debe quedar marcado inicialmente y false para los demás. Observe que el grupo de botones controla únicamente el comportamiento de los botones. Si se dese agrupar los botones a efecto de su disposición es necesario añadirlos a un contenedor tal como un JPanel.

Cuando el usuario marca un botón de radio, el botón de radio genera un evento de acción.

ActionListener oyente = new
    ActionListener(){
        public void actionPerformed(ActionEvent evento)
        {
            ...
        }
    };
botonPequeño.addActionListener(oyente);

Bordes

Si se tiene múltiples grupos de botones de radio en una ventana, será necesario indicar visualmente que botones están agrupados. 

Se puede aplicar un borde a cualquier componente que extienda de JComponent.

Ejemplo borde grabado con título:

Border grabado = BorderFactory.createEtchedBorder();
Border conTitulo = BorderFactory.createTitledBorder(grabado,"El título");
lamina.setBorder(conTitulo);

https://docs.oracle.com/javase/7/docs/api/javax/swing/BorderFactory.html

Pasos para agregar bordes

1. Se llama al método estático BorderFactory para crear un borde. Se pueden seleccionar los siguientes estilos:

• Biselado hundido
• Biselado elevado
• Grabado
• Lineal
• Mate
• Vacío (crea un poco de espacio en blanco en torno al componente.

2. Se puede añadir un título al borde pasando el borde a       BorderFactory.createTitledBorder.

3. Añadir al componente el borde resultante mediante una llamada al método setBorder de la clase JComponent.

Selectores múltiples

Si se disponen más de unas pocas alternativas, los botones de radio no son una opción. 

Se puede utilizar un ComboBox. Cuando el usuario hace click en el componente, se despliega una lista de opciones y entonces el usuario puede seleccionar una de ellas.

• Puede ser editable: se puede modificar la selección como si fuera un campo de texto. Para hacer que sea editable se llama al método setEditable. La edición solo afecta al elemento actual.
• Las opciones se pueden añadir empleando el método addItem. 

JComboBox comboFuente = new JComboBox();
comboFuentes.setEditable(true);
comboFuentes.addItem("Serif");
comboFuentes.addItem("SansSerif");

• Este método añade la cadena al final de la lista. Se pueden añadir nuevos elementos en cualquier lugar utilizando insertItemAt.

comboFuentes.insertItemAt("Monospaced",0);

• Se pueden añadir elementos de cualquier tipo, el selector múltiple va invocando al método toString.
• Si se necesita eliminar elementos durante la ejecución se utiliza remoteItem o removeItemAt. El método removeAllItems elimina todos los elementos.

• Para recuperar el elemento que está seleccionado se llama al método getSelectedItem. Es necesario castear para darle el tipo adecuado, en general String.
• Cuando el usuario selecciona un elemento de la lista, el selector genera un evento de acción.

public void actionPerformed(ActionEvent evento)
{
    String fuente = (String) comboFuentes.getSelectedItem();
    ...
}

Tablas

JTable

JTable es una herramienta visual de Java que sirve para poder dibujar tablas, con sus respectivas filas y columnas para visualizar información.

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.

https://docs.oracle.com/javase/tutorial/uiswing/components/table.html

Constructores de JTable

DefaultTableModel

El DefaultTableModel es una clase que implementa TableModel que contiene todos los métodos necesarios para modificar datos en su interior, añadir filas o columnas y darle a cada columna el nombre que se desee. Para utilizar DefaultTableModel debemos importarla y luego declararla para luego poder usar la clase JTable, un ejemplo es:

import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;

DefaultTableModel modelo = new DefaultTableModel();
JTable tabla = new JTable (modelo);

Constructores de DefaultTableModel

Métodos para DefaultTableModel

https://docs.oracle.com/javase/7/docs/api/javax/swing/table/DefaultTableModel.html

JScrollPane

Es una clase importada en swing que permite asociarle una pequeña vista o ventana deslizable o corrediza, que permite solo que se vea una parte de dicho complemento en la tabla. Para poder usarlo, importamos la clase y luego la declaramos, un ejemplo sería:

import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;
import javax.swing.JScrollPane;

DefaultTableModel modelo = new DefaultTableModel();
JTable tabla = new JTable (modelo);
JSrollPane scrollpane = new JScrollPane(tabla);

Se añada directamente el JScrollPane a la lámina.

Selección de filas, columnas y celdas. 

Según el modo de selección, el usuario podrá marcar filas, columnas o una celda individual de la tabla. Por defecto se activa la selección de filas.

Para desactivar este comportamiento:

tabla.setRowSelectionAllowed(false);

Cuando está activa la selección de una fila, puede determinar si el usuario tiene permiso para elegir una sola fila, un rango continuo de ellas o cualquiera de la incluidas en la tabla. Para ello de debe recuperar el modelo de selección y usar su método setSelectionMode:

tabla.getSelectionModel().setSelectionMode(modo);

En este caso modo es uno de estos tres valores:

• ListSelectionModel.SINGLE_SELECTION
• ListSelectionModel.SINGLE_INTERVAL_SELECTION
• ListSelectionModel.MULTIPLE_INTERVAL_SELECTION

La selección de columna esta desactivada por defecto. Para activarla utilice la siguiente llamada: 

tabla.setColumnSelectionAllowed(true);

Habilitar la selección de fila y columna es equivalente a permitir la selección de una celda. Después, el usuario puede marcar conjuntos de ellas. También puede habilitar el comportamiento con esta llamada: 

tabla.setCellSelectionEnabled(true);

Para determinar que filas y que columnas están seleccionadas utilice los métodos getSelectedRows y getSelectedColumns. Ambos devuelven un array int[] con las posiciones de dichos elementos.

En el caso de tratarse de una sola fila la que se puede seleccionar, puede utilizar el método getSelectedRow. 

Determinar selección

Deshabilitar edición

Por defecto, las tablas creadas permiten la edición de sus celdas. Para evitar este comportamiento se debe sobreescribir un método de la clase JTable:

tabla = new JTable(modelTabla) {
    public boolean isCellEditable(int row, int column) {
	return false;
    };
};

Cuadros de diálogos

Diálogos con opciones: JOptionPane

Swing posee un conjunto de diálogos sencillos prefabricados, que nos bastan cuando necesitamos pedir al usuario poca información.

El diálogo tiene los componentes siguientes:

• un ícono
• un mensaje
• uno o más botones de opción.

Ícono

El ícono del lado izquierdo depende de uno de entre cinco tipos de mensaje:

• ERROR_MESSAGE
• INFORMATION_MESSAGE
• WARNING_MESSAGE
• QUESTION_MESSAGE
• PLAIN_MESSAGE (carece de ícono)

Cada tipo de diálogo posee también un método que nos permite proporcionar nuestro propio ícono.

Mensaje

Puede ser una cadena, un ícono, un componente de interfaz de usuario o cualquier otro objeto.

Botones

Dependen del tipo de diálogo y del tipo de opciones. Cuando se llama a showMessageDialog y showInputDialog, solo se obtiene un conjunto estándar de biblioteca (OK y OK/Cancelar, respectivamente). Cuando se llama showConfirmDialog, se puede optar entre 4 tipos de opciones:

• DEFAULT_OPTION
• YES_NO_OPTION
• YES_NO_CANCEL_OPTION
• OK_CANCEL_OPTION

Empleando el showOptionDialog se puede especificar un conjunto arbitrario de opciones. Proporcionamos una matriz de objetos para las opciones.

Valores proporcionados

Los valores proporcionados por estas funciones son las siguientes:

Las llamadas a showConfirmDialog y showOptionDialog proporcionan enteros que denotan el botón seleccionado.

• Diálogo de opciones: se trata del índice de la opción seleccionada o bien el valor de CLOSED_OPTION si el usuario ha cerrado el diálogo en lugar de seleccionar una opción.
• Diálogo de confirmación el valor proporcionado puede ser uno de los siguiente:
  • OK_OPTION
  • CANCEL_OPTION
  • YES_OPTION
  • NO_OPTION
  • CLOSED_OPTION 

1. Seleccione el tipo de diálogo (mensaje, opción, confirmación o entrada).
2. Seleccione el ícono (error, información, advertencia, pregunta, ninguno o personalizado)
3. Seleccione el mensaje (cadena, ícono, componente personalizado o una colección de componentes).
4. Si el diálogo es de confirmación, seleccione el tipo de opción (predeterminado, Si/No, Si/No/Cancelar o OK/Cancelar.
5. Si el diálogo es de opción seleccione las opciones (cadenas, íconos o componentes personalizados).
6. Para un diálogo de entrada, decida entre un campo de texto y un combo.

Ejemplo

int seleccion = JOptionPane.showConfirmDialog(padre,
 "Mensaje", 
"Titulo", 
JOptionPane.OK_CANCEL_OPTION, 
JOptionPane.WARNING_MESSAGE);
if(seleccion == JOptionPane.OK_OPTION)...

Ejercicios

Revisar los ejercicios propuestos para la clase 4 https://github.com/marinabgarcia/CursoJava

1. Práctica de BorderLayout
2. Práctica de BorderLayout con FlowLayout
3. Práctica de campos de textos.
4. Desarrollar un programa que permita cambiar el estilo de un rotulo (cursiva, negrita o ambas) utilizando casillas de verificación.
5. Desarrollar un programa que permita cambiar el tamaño de fuente de un rotulo (pequeño, mediano,grande o muy grande). Utilizar radio buttons.
6. Desarrollar un programa que permita probar los distintos tipos de bordes. Usar radio buttons.
7. Desarrollar un programa que permita cambiar la fuente de un rotulo (Serif, SansSerif,etc). Utilizar un combobox editable.

Trabajo Práctico: Parte 1

Desarrollo de Interfaz de Usuario.

1. Desarrollar interfaz de usuario para las siguientes pantallas. Utilizar layouts y formateadores.
2. Agregar los eventos necesarios para que desde el botón agregar y modificar se abra la pantalla con el formulario.