K-71 Robles - Debora - A4

Descargar como docx, pdf o txt
Descargar como docx, pdf o txt
Está en la página 1de 34

INSTITUTO TECNOLÓGICO DE TLALNEPANTLA

Materia: Programación Avanzada

Grupo: K-71.

Profesor: Oscar Mendoza Camargo.

Proyecto: Actividad 4.

Alumno: Robles Uicab Débora.

No. De Control: 17250509.

Fecha de entrega: 22/05/2020.


ACTIVIDAD 4

1. Investigar sobre la definición, declaración y uso de los principales


controles y componentes estándar para el desarrollo de programas en
modo gráfico, las clases, así como los métodos y eventos en Java
Swing y AWT.

1.1 JAVA SWING.


Swing es una biblioteca de interfaces gráficas de usuario (GUI) para Java. Viene
incluida con el entorno de desarrollo de Java (JDK).
Es un conjunto de clases y otros recursos para construir GUI’s (Interfaces de
Usuario Gráficas). Es independiente de la plataforma (sistema operativo) sobre la
que se ejecute. Con Swing podemos crear ventajas, contenedores, botones,
etiquetas, campos de texto, listas desplegables, etc. La mayoría de sus clases
comienzan con una J (por ejemplo, JFrame).
Una aplicación Swing se construye mezclando componentes con las siguientes
reglas:
 Debe existir, al menos, un contenedor de alto nivel (TopLevel Container),
que provee el soporte que las componentes Swing necesitan para el
pintado y el manejo de eventos.
 Otras componentes colgando del contenedor de alto nivel (éstas pueden
ser contenedores o componentes simples).
Estructura básica de un programa de Swing.
En el ejemplo, sólo hay un contenedor de alto nivel, un JFrame.
o Un frame implementado como una instancia de la clase JFrame es una
ventana con decoraciones, tales como, borde, título y botones como íconos
y para cerrar la ventana.
o Aplicaciones con un GUI típicamente usan, al menos, un frame.
o Además, el ejemplo tiene un componente, una etiqueta que dice "Hola
Mundo".
Como ya se dijo antes, cada aplicación Swing debe tener al menos un top-level
container que contendrá toda la aplicación,estos pueden ser:
 javax.swing.JFrame: Una ventana independiente.
 javax.swing.JApplet: Un applet.
Diálogos: Ventanas de interacción sencilla con el usuario como por ejemplo:
 java.swing.JOptionPane: Ventana de diálogo tipo SI_NO,
SI_NO_CANCELAR, ACEPTAR, etc...

 java.swing.JFileChooser: Ventana para elejir un archivo.


java.swing.JColorChooser etc.
Creación de ventanas.
La clase JFrame proporciona operaciones para
manipular ventanas.
 Constructores:
- JFrame()
- JFrame(String titulo)
Una vez creado el objeto de ventana, hay que:
 Establecer su tamaño.
 Establecer la acción de cierre.
 Hacerla visible.
Ejemplo:
import javax.swing.*;

public class VentanaTest {


public static void main(String[] args) {
JFrame f = new JFrame("Titulo de ventana");
f.setSize(400, 300);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}
}
Acciones de cierre:
 JFrame.EXIT_ON_CLOSE: Abandona aplicación.
 JFrame.DISPOSE_ON_CLOSE: Libera los recursos asociados a la
ventana.
 JFrame.DO_NOTHING_ON_CLOSE: No hace nada.
 JFrame.HIDE_ON_CLOSE: Cierra la ventana, sin liberar sus recursos.
1.2 AWT

Abstract Window Toolkit. (AWT, en español Kit de Herramientas de Ventana


Abstracta). Conjunto de herramientas GUI (Interfaz Gráfica con el Usuario)
diseñadas para trabajar con múltiples plataformas. Interfaz de usuario, y sistema
de ventanas independiente de la plataforma original de Lenguaje de programación
Java. AWT es parte de las Java Foundation Classes (JFC) - la API estándar para
suministrar una interfaz gráfica de usuario (GUI) para un programa Java.

Clases de AWT

Jerarquía de clases de AWT

Este paquete viene incluido en la API de Java como java.awt ya desde su primera
versión, con lo que las interfaces generadas con esta biblioteca funcionan en
todos los entornos Java disponibles (incluyendo navegadores, lo que les hace
especialmente eficientes para la creación de applets Java).

Component: Esta clase representa a cualquier objeto que puede ser parte
de una interfaz gráfica de usuario. Es la clase padre de muchas de las
clases del AWT.

Su propósito principal es representar algo que tiene una posición y un tamaño, que
puede ser dibujado en la pantalla y que pueda recibir eventos de entrada (que
responda a las interacciones con el usuario).

Container: La clase Container sabe cómo mostrar componentes


embebidos (que a su vez pueden ser instancias de la clase Container).

Estos objetos Container tienen un LayoutManager asociado que define la manera


en que van a posicionarse los objetos componentes en su interior.

LayoutManager y LayoutManager2: son dos interfaces encargadas de la


representación y posicionamiento en pantalla de componentes AWT.
Otras clases: Por supuesto AWT no se limita a estas clases. Dentro de
esta biblioteca podemos encontrar multitud de clases prefabricadas para
facilitar el diseño gráfico.
Clases contenedoras (hijas de Container)

Panel: Permite hacer una presentación más avanzada que Container


mediante la combinación con subpaneles o subclases para crear
contenedores personalizados. La clase Applet que sirve para crear applets
Java, hereda de esta clase Panel.

 ScrollPane: Una barra de desplazamiento, horizontal o vertical.


 Window: Una ventana sin borde.
 Frame: Una ventana que no tiene borde. Puede tener asociado un
objeto Menubar (una barra de herramientas o barra de menú
personalizada).
 Dialog: Una ventana usada para crear diálogos. Tiene la capacidad de
ser modal con lo que sólo este contenedor recibiría entradas del usuario.
 Filedialog: Un diálogo que usa el selector de archivos nativo del sistema
operativo.

Clases componentes (hijas directas de Component)

- Button: Un botón gráfico para el que se puede definir una acción que
sucederá cuando se presione el botón.
- Canvas: Permite pintar o capturar eventos del usuario. Se puede usar
para crear gráficos o como clase base para crear una jerarquía de
componentes personalizados.
- Checkbox: Soporta dos estados: on y off. Se pueden asociar acciones
que se ejecuten (triggers) cuando el estado cambie.
- Choice: Menú desplegable de opciones.
- Label: Cadena de etiqueta en una localización dada.
- List: Una lista desplegable de cadenas.
- Scrollbar: Desplegable de objetos Canvas.
- TextComponent: Cualquier componente que permita editar cadenas de
texto.Tiene dos clases hijas:
- TextField: Componente de texto consistente en una línea que puede ser
usada para construir formularios.
- TextArea: Componente para edición de texto de tamaño variable.

 Eventos de AWT

AWT tiene sus propios eventos, que se explican a continuación.

Eventos físicos

Son todos hijos del evento ComponentEvent, que indica algún cambio en un
objeto Component:
 InputEvent: Se ha producido una entrada del usuario. Tiene como eventos
hijos KeyEvent (pulsación de una tecla) y MouseEvent (acción sobre el
ratón).
 FocusEvent: Avisa al programa de que el componente ha ganado o perdido
la atención (enfoque) del usuario. Esto se deduce de la actividad del
usuario (ratón y teclado).
 WindowEvent: Avisa al programa de que el usuario ha utilizado uno de los
controles de ventana a nivel del sistema operativo, como los controles de
minimizar o cerrar.
 ContainerEvent: Se envía cuando se añaden o eliminan componentes a un
contenedor.
 PaintEvent: Evento especial que señala que el sistema operativo quiere
dibujar de nuevo una parte de la interfaz. Un componente debe
sobreescribir el método paint() o el método update() para gestionar este
evento.

Eventos semánticos

Son todos hijos del evento AWTEvent, que es el evento base de la jerarquía de
eventos:

 ActionEvent: Avisa al programa de acciones específicas de componentes


como las pulsaciones de botones.
 AdjustmenteEvent: Comunica que una barra de desplazamiento ha sido
ajustada.
 ItemEvent: Avisa al programa cuando el usuario interacciona con una
elección, una lista o una casilla de verificación.
 TextEvent: Avisa cuando un usuario cambia texto en un componente
TextComponent, TextArea o TextField.
 InputMethodEvent: Avisa que un texto que está siendo creado utilizando un
método de entrada está cambiando (se ha escrito algo más...).
 InvocationEvent: Este evento ejecuta el método run() en una clase
Runnable cuando es tratado por el thread del despachador (dispatcher) de
AWT.

2. Investigar los métodos de la clase JFrame en Java Swing.

 JFrame

JFrame es una clase utilizada en Swing (biblioteca gráfica) para generar ventanas
sobre las cuales añadir distintos objetos con los que podrá interactuar o no el
usuario. A diferencia de JPanel, JFrame posee algunas nociones típicas de una
ventana como minimizar, cerrar, maximizar y poder moverla.
Métodos propios de la clase

Además de los métodos heredados, JFrame implementa una serie de métodos


propios de esta, que se describen a continuación:

 addImpl(Component comp, Object constraints, int index): Añade el


componente especificado al JFrame.
 createRootPane(): Crea un Panel por defecto por medio de una llamada al
constructor.
 frameInit(): Llama a los constructores para inicializar el JFrame
correctamente.
 getAccessibleContext(): Obtiene el AccessibleContext asociado a dicho
JFrame.
 getContentPane(): Devuelve el contenido del JFrame.
 getDefaultCloseOperation(): Devuelve la operación por defecto cuando se
cierra el JFrame.
 getGlassPane(): Devuelve el objeto glassPane que corresponde a este
JFrame.
 getGraphics(): Obtiene las características gráficas del JFrame.
 getJMenuBar(): Devuelve la barra de menú del JFrame.
 getLayeredPane(): Obtiene el objeto layeredPane del JFrame.
 getRootPane(): Obtiene el objeto rootPane del JFrame.
 getTransferHandler(): Devuelve el objeto transferHandler del JFrame.
 isDefaultLookAndFeelDecorated(): Comprueba si la apariencia de la
ventana JFrame es la apariencia por defecto; en caso afirmativo será
cierto.
 isRootPaneCheckingEnabled(): Devuelve un valor de cierto si las llamadas
add y setLayout se remiten a la contentPane.
 paramString(): Devuelve una representación en cadena de texto del
JFrame.
 processWindowEvent(WindowEvent e): Procesa los eventos que se
producen en el JFrame.
 remove(Component comp): Elimina el componente que se especifica de la
ventana JFrame.
 repaint(long time, int x, int y, int width, int height): Redibuja el rectángulo
especificado del JFrame en el tiempo indicado en milisegundos.
 setContentPane(Container contentPane): Establece el contentPane
especificado en JFrame.
 setDefaultCloseOperation(int operation): Especifica la operación por defecto
al cerrar el JFrame.
 setDefaultLookAndFeelDecorated(boolean defaultLookAndFeelDecorated):
Establece la apariencia que debe tener el JFrame, como bordes, botones
para distintos usos, título...
 setGlassPane(Component glassPane): Establece las propiedades del
objeto glassPane.
 setIconImage(Image image): Define el icono que se mostrará en la parte
superior izquierda del marco del JFrame.
 setJMenuBar(JMenuBar menubar): Establece la barra de menú del
JFrame.
 setLayeredPane(JLayeredPane layeredPane): Define el objeto layeredPane
del JFrame.
 setLayout(LayoutManager manager): Establece la forma en que se
mostrarán los distintos objetos añadidos al JFrame.
 setRootPane(JRootPane root): Establece el rootPane de la ventana .
 setRootPaneCheckingEnabled(boolean enabled): Establece si las llamadas
add y setLayout se remiten o no a la contentPane.
 setTransferHandler(TransferHandler newHandler): Define el
transferHandler, que es un mecanismo de soporte de transferencia de datos
dentro del JFrame.
 update(Graphics g): Hace una llamada al método paint(g).

3. Investigar los componentes de gráficos: JButton, JLabel, JTextField,


JCheckBox y JRadioButton.

3.1 JButton

La función de un JButton es crear un botón visible dentro de una aplicación de


interfaz gráfica de usuario en Java. El JButton permite a los programadores dictar
el texto que aparece en el botón y el momento en el que aparece dentro de la
interfaz general. Usando métodos adicionales dentro del lenguaje Java los
programas también pueden proporcionar respuestas detalladas a la interacción del
usuario con un JButton. Los JButtons se encuentran entre los muchos elementos
de interfaz de usuario posibles en Java. Otros elementos son las listas
desplegables, botones de radio, etiquetas y casillas de verificación. Los programas
de Java necesitan importar los recursos Swing y AWT necesarios para usar
JButtons.
Class JButton
java.lang.Object
java.awt.Component
java.awt.Container
javax.swing.JComponent
javax.swing.AbstractButton
javax.swing.JButton

El objeto JButton es un botón pulsable con una etiqueta o una imagen.

El boton es muy similar a una etiqueta con la diferencia del pulsado, para que al
hacer click haga algo hay que implementar la interface de eventos y asignarle un
vigilante al boton, para saber cuando este es pulsado y describir en los metodos
de la interface que es lo que queremos que haga.

El resultado será:
3.2 JLabel

Class JLabel

java.lang.Object
java.awt.Component
java.awt.Container
javax.swing.JComponent
javax.swing.JLabel

El componente JLabel son etiquetas que permite añadir texto, este no puede ser
modificado por el usuario. Además de texto también admite gráfico de la clase
ImageIcon
Constructores JLabel
JLabel cuenta 6 constructores:

 JLabel()
o Crea un objeto etiqueta sin texto ni imagen.
 JLabel(Icon image)
o Crea un objeto etiqueta con una imagen.
 Ejemplo:
 ImageIcon icono = new
ImageIcon("src/miPaquete/Miarchivo.jpg");
 Jlabel etiqueta = new JLabel(icono);
 JLabel(Icon image, int horizontalAlignment)
o Crea un objeto etiqueta con una imagen y una alineación horizontal.
La alinacion debe ser una constante defina de SwingConstants:
LEFT, CENTER, RIGHT, LEADING o TRAILING.
o Ejemplo:
 ImageIcon icono = new ImageIcon("src/miPaquete/Miarchivo.jpg",
SwingConstants.CENTER);
 Jlabel etiqueta = new JLabel(icono);
 JLabel(String text)
o Crea un objeto etiqueta con el texto indicado.
 Ejemplo:
 JLabel etiqueta = new JLabel("Hola Mundo");
 JLabel(String text, int horizontalAlignment)
o Crea un pbjeto etiqueta con un texto como contenido y una
alineación horizontal.
 Ejemplo:
 JLabel etiqueta = new JLabel("Hola Mundo",
SwingConstants.RIGHT);
 JLabel(String text, Icon icon, int horizontalAlignment)
o Crea un objeto etiqueta con un texto y una imagen más una
alineacion horizontal.
 Ejemplo:
 JLabel etiqueta = new JLabel("Hola Mundo",
"src/miPaquete/Miarchivo.jpg", SwingConstants.LEFT);

El resultado será:
3.3 JTextField

Un JTextField o campo de texto es un componente utilizado para la captura de


datos, estos son casi indispensables en una aplicación. A continuación veremos
cómo crear un JTextField, sus métodos, y applets donde veremos toda la
funcionalidad y utilidad del JTextField.

Ejemplo.

JTextField campo=new JTextField();

Esto crea un campo de texto vacio.

JTextField campo=new JTextField(String texto);

Esta instrucción crea un campo de texto con un texto especificado.

JTextField campo=new JTextField(String texto, int columnas);

Esto nos crea un campo de texto con un texto especificado y el número de


columnas.

import java.awt.FlowLayout;
import javax.swing.*;

public class Principal extends JApplet {

JTextField t1,t2,t3;

public void init(){


setLayout(new FlowLayout());
t1=new JTextField();
t2=new JTextField(10);
t3=new JTextField("JAVA ZONE");
add(t1);
add(t2);
add(t3);
}
}

En esta ocasión declare los campos de texto afuera del método init, esta es otra
forma de hacer la declaración de las variable, es conveniente hacerlo de este
modo si se desea utilizar dichas variables en otros métodos. 

Con el método setLayout le indico al applet que tipo de distribución quiero que
tenga en este caso una FlowLayout la cual se usa para indicar que los
componentes se adicionan a al applet de izquierda a derecha. Luego inicializo los
campos de textos, cree tres campos para mostrar los distintos constructores que
esta clase posee. Y por último se los adiciono al Applet.

3.4 JCheckBox

Un CheckBox o tambien conocida como una casilla de verificacion, es muy usada


ya que nos permite seleccionar algunas opciones, este componente puede
mostrar un texto, una imagen, una imagen con un texto. A continuacion veremos
cómo podemos crear una casilla de verificacion, sus metodos y algunos applets
que nos muestren más de cerca su funcionamiento.
¿Como se crea un JCheckBox?

 JCheckBox casilla=new JCheckBox();


 Esto crea una casilla de verificacion sin incono y sin texto.
 JCheckBox casilla=new JCheckBox(Icon imagen);
 Esta instruccion nos crea una casilla de verificacion con el icono
especificado.
 JCheckBox casilla=new JCheckBox(String texto);
 Esta instruccion nos crea una casilla de verificacion con el texto
especificado.
 JCheckBox casilla=new JCheckBox(String texto, Icon imagen);
 Esto nos crea una casilla de verificacion con el texto e icono especificado.

3.5 JRadioButton

Conocido también como botón de opción o botón de radio es un tipo de widget


utilizado en interfaces gráficas de usuario que permite elegir una sola opción de un
conjunto predeterminado de estas.
Los botones de opción (botones de radio) se llaman así en referencia a los
botones físicos que se usan en los radios para seleccionar estaciones
preajustadas - cuando se presionaba uno de los botones, otro de los botones
saltaba

Es posible que, inicialmente, ninguno de los botones de opción en un grupo esté


seleccionado. Este estado no puede restaurarse interactuando con el widget del
botón de opción (pero es posible a través de otros elementos de la interfaz de
usuario).

Un aspecto interesante de los botones de opción, cuando se utilizan en un


formulario HTML, es que si no se marca ningún botón en un grupo, entonces no se
pasa ningún par nombre-valor cuando se envía el formulario. Por ejemplo, para un
grupo de botones de opción llamado Sexo, con las opciones de Masculino y
Femenino, la variable Sexo no pasaría, ni siquiera con un valor en blanco.
Este es un ejemplo común de un RadioButton en donde sólo se permitirá
seleccionar un elemento de la lista definida previamente por el Programador:

Bueno, ahora vamos al código, veamos que se debe hacer para crear uno de
estos.
Imports Utilizados:

import javax.swing.ButtonGroup;
import javax.swing.JRadioButton;

Definir un RadioButton:
JRadioButton rbtn1=new JRadioButton("txt1",true);
JRadioButton rbtn2=new JRadioButton("txt2",false);
JRadioButton rbtn3=new JRadioButton("txt3",false);

Creación del Grupo de Botones:


ButtonGroup grupo1 = new ButtonGroup();
grupo1.add(rbtn1);
grupo1.add(rbtn2);
grupo1.add(rbtn3);

La Clase que se utiliza se llama JRadioButton y donde la clase que nos permite
crear un grupo donde "almacenaremos" nuestro botones es la ButtonGroup. Los
parámetros que se pasan al momento de crearlo son el Texto que llevará y si
estará seleccionado este ítem al momento de ejecutar nuestro programa

4. Investigar sobre los Layout Manager usados en Java Swing:


FlowLayout, Gridlayout, BorderLayout y GridBagLayout, su definición,
declaración, sus métodos, uso y un ejemplo de cada uno.

4.1 FlowLayout.

Organiza los componentes en un flujo de izquierda a derecha.

Clase FlowLayout

java.lang.Object
java.awt.FlowLayout
Flow (en español "flujo") ordena los componentes en un flujo direccional, al
igual que las líneas de texto en un párrafo, por defecto es de izquierda a
derecha, si no encuentra más espacio para un componente utiliza una nueva
linea. La alineación de la línea se determina por la propiedad "align", sus
valores posibles son las variables de la clase.

FlowLayout es clase del paquete awt, veamos sus constructore, variables y


métodos:

Constructores:
FlowLayout()
Constructor básico sin parámetros, con valores predeterminados de alineación
centrada y 5 unidades de espacio horizontal y vertical.
FlowLayout(int align)
Construye un nuevo FlowLayout con la alineación "align" especificada y un valor
predeterminado de 5 unidades de espacio horizontal y vertical.
FlowLayout(int align, int hgap, int vgap)
Construye un nuevo FlowLayout con la alineación indicada y los espacios
horizontales y verticales indicados.
Variables de Clase
public static final int LEFT = 0; Izquierda
public static final int CENTER = 1;, centro (Default)
public static final int RIGHT = 2; Derecha
public static final int LEADING = 3; Iniciales
public static final int TRAILING = 4; Finales
Podemos usar el nombre de las variables o bien su valor en el constructor:
FlowLayout(int align) de la linea 17
Métodos

entre otros... para configurar si no lo hicimos en el constructor.

 getAlignment(int align) y/o setAlignment(int align)


o Obtiene o configura la alineación para este diseño.
 getHgap(int hgap) y/o setHgap(int hgap)
o Obtiene o configura la distancia horizontal entre los componentes y
entre los componentes y las fronteras del contenedor.
 getVgap(int vgap) y/o setVgap(int vgap)
o Obtiene o configura la distancia vertical entre los componentes y
entre los componentes y las fronteras del contenedor.

Ejemplo

Hago uso del constructor FlowLayout(FlowLayout.LEFT, 150,0) para que:


 Los ordene de izquierda a derecha
 alineados a la izquierda (Mucho no se nota)
 Cada elemento tome 150px de margen horizontal, empezando desde la
izquierda como es su alineación
 Tomen 0px de distancia vertical (Van a estar pegados uno arriba del otro)

4.2 Gridlayout.

Organiza los componentes una "parrilla" de filas y columnas.

El GridLayout coloca los componentes en forma de matriz, haciendo que todos


ocupen el mismo tamaño. Es un Layout adecuado para hacer matrices de cajas de
texto (por ejemplo, si queremos hacer un crucigrama o un sudoku) o para matrices
de botones (por ejemplo, una calculadora).

Se puede instanciar pasándole el número de filas y columnas que queremos. Por


ejemplo, el siguiente trozo de código prepara una ventana con un GridLayout de
10 filas y 5 columnas.

Es un administrador de diseño que coloca componentes dentro de una cuadrícula


con el mismo tamaño de celda. Puede establecer el número de filas, columnas, la
brecha horizontal y la brecha vertical utilizando los siguientes métodos:
 setRows(int rows)
 setColumns(int columns)
 setHgap(int hgap)
 setVgap(int vgap)
O puedes configurarlos con los siguientes constructores:
- GridLayout(int rows, int columns)
- GridLayout(int rows, int columns, int hgap, int vgap)
Si el número de filas o columnas es desconocido, puede establecer la variable
respectiva en 0 . Por ejemplo:
- new GridLayout(0, 3)
Esto hará que GridLayout tenga 3 columnas y tantas filas como sea necesario.
El siguiente ejemplo muestra cómo un GridLayout presenta componentes con
diferentes valores para filas, columnas, espacio horizontal, espacio vertical vertical
y tamaño de pantalla.

Ejemplo:
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.EventQueue;
import java.awt.GridLayout;

import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSpinner;
import javax.swing.SpinnerNumberModel;
import javax.swing.WindowConstants;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

public class GridLayoutExample {

private GridLayout gridLayout;


private JPanel gridPanel, contentPane;
private JSpinner rowsSpinner, columnsSpinner, hgapSpinner, vgapSpinner;

public void createAndShowGUI() {


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

gridPanel = new JPanel(gridLayout);

final ChangeListener rowsColumnsListener = new ChangeListener() {


@Override
public void stateChanged(ChangeEvent e) {
gridLayout.setRows((int) rowsSpinner.getValue());
gridLayout.setColumns((int) columnsSpinner.getValue());
fillGrid();
}
};

final ChangeListener gapListener = new ChangeListener() {


@Override
public void stateChanged(ChangeEvent e) {
gridLayout.setHgap((int) hgapSpinner.getValue());
gridLayout.setVgap((int) vgapSpinner.getValue());
gridLayout.layoutContainer(gridPanel);
contentPane.revalidate();
contentPane.repaint();
}
};

rowsSpinner = new JSpinner(new


SpinnerNumberModel(gridLayout.getRows(), 1, 10, 1));
rowsSpinner.addChangeListener(rowsColumnsListener);

columnsSpinner = new JSpinner(new


SpinnerNumberModel(gridLayout.getColumns(), 1, 10, 1));
columnsSpinner.addChangeListener(rowsColumnsListener);

hgapSpinner = new JSpinner(new


SpinnerNumberModel(gridLayout.getHgap(), 0, 50, 1));
hgapSpinner.addChangeListener(gapListener);

vgapSpinner = new JSpinner(new


SpinnerNumberModel(gridLayout.getVgap(), 0, 50, 1));
vgapSpinner.addChangeListener(gapListener);
JPanel actionPanel = new JPanel();
actionPanel.add(new JLabel("Rows:"));
actionPanel.add(rowsSpinner);
actionPanel.add(Box.createHorizontalStrut(10));
actionPanel.add(new JLabel("Columns:"));
actionPanel.add(columnsSpinner);
actionPanel.add(Box.createHorizontalStrut(10));
actionPanel.add(new JLabel("Horizontal gap:"));
actionPanel.add(hgapSpinner);
actionPanel.add(Box.createHorizontalStrut(10));
actionPanel.add(new JLabel("Vertical gap:"));
actionPanel.add(vgapSpinner);

contentPane = new JPanel(new BorderLayout(0, 10));


contentPane.add(gridPanel);
contentPane.add(actionPanel, BorderLayout.SOUTH);

fillGrid();

JFrame frame = new JFrame("GridLayout Example");


frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
frame.setContentPane(contentPane);
frame.setSize(640, 480);
frame.setLocationByPlatform(true);
frame.setVisible(true);
}
private void fillGrid() {
gridPanel.removeAll();
for (int row = 0; row < gridLayout.getRows(); row++) {
for (int col = 0; col < gridLayout.getColumns(); col++) {
JLabel label = new JLabel("Row: " + row + " Column: " + col);
label.setHorizontalAlignment(JLabel.CENTER);
label.setBorder(BorderFactory.createLineBorder(Color.GRAY));
gridPanel.add(label);
}
}
contentPane.revalidate();
contentPane.repaint();
}

public static void main(String[] args) {


EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
new GridLayoutExample().createAndShowGUI();
}
});
}

4.3 BorderLayout.
Organiza los componentes en uno de los 5 paneles que corresponde a una de las
coordenadas (Norte, Sur, Este, Oeste) y el centro.

Clase BorderLayout

java.lang.Object
java.awt.BorderLayout

El gestor BorderLayout (borde, margen) divide el contenedor en 5 partes


como se muestra en la siguiente imagen:

Básicamente luego de crear el objeto del gestor borde y configurarlo para un


contenedor, a la hora de agregar componentes, el método add necesitará 2
parámetros:

 add(Componente, Coordenada)

-estas coordenadas tienen que ser Strings de clase de BorderLayout:

o NORTH, para el panel superior (Norte)


o LEFT, para el panel izquierdo
o CENTER, para el panel central
o RIGHT, para el panel derecho
o SOUTH, para el panel inferior (Sur)

Por ejemplo: miPanel.add(boton, BorderLayout.NORTH); de esta manera


agregamos el componente al contenedor y en el lugar que el gestor lo dividio.

Constructores
 BorderLayout()
o Construye un gestor BorderLayout y sin espacios entre los componentes.
 BorderLayout(int hgap, int vgap)
o Construye un diseño BorderLayout con los espacios entre los componentes
especificados. La distancia horizontal se especifica mediante hgap y la
distancia vertical se especifica por vgap.

Ejemplo:
*Como vemos le dimos 10px de distancia horizontal entre los
componentes(por ejemplo entre los botones 3 y 4) y además 60px de manera
vertical (por ejemplo el boton 1 con los demás).

*También hay que notar que comente los paneles izquierdo y sur, con lo que
estos espacios no forman siempre parte del marco, hay que agregarlos sino el
gestor de diseño se las ingeniará para crear cosas como estas.

4.4 GridBagLayout.

Coloca componentes en rectángulos (células) en una cuadrícula, y luego utiliza los


tamaños preferidos de los componentes para determinar qué tan grande debe ser
las células.

Clase GridBagLayout

La clase GridBagLayout es un administrador de diseño flexible. Se utiliza para


alinear los componentes horizontalmente, verticalmente o a lo largo de su línea
base. No requiere los componentes del mismo tamaño. Cada objeto
GridBagLayout gestiona una cuadrícula rectangular de celdas, dinámica con cada
componente que ocupa una o más celdas, llamada su área de visualización. Los
componentes GridBagLayout están asociados con la instancia de
GridBagConstraints. Estas restricciones se utilizan para definir el área de
visualización del componente y sus posiciones. Además de su objeto de
restricciones, GridBagLayout también considera los tamaños mínimos y preferidos
de cada componente para determinar el tamaño de un componente. Los
componentes GridBagLayout también están dispuestos en la cuadrícula
rectangular, pero pueden tener diferentes tamaños y pueden ocupar las múltiples
filas o columnas.

Constructor:
 GridBagLayout (): se utiliza para crear un administrador de diseño de
bolsa de cuadrícula.

Métodos:

 removeLayoutComponent (Componente cmp): elimina el componente


especificado de este diseño.
 getLayoutAlignmentY (Contenedor p): devuelve la alineación a lo largo
del eje y.
 addLayoutComponent (Componente cmp, Objeto contras): Agrega el
componente especificado con el nombre especificado al diseño.
 toString (): devuelve una representación de cadena de los valores de este
diseño de bolsa de cuadrícula.
 getLayoutAlignmentX (Contenedor p): devuelve la alineación a lo largo
del eje x.
 getConstraints (Componente cmp): Obtiene las restricciones para el
componente especificado.
 maximumLayoutSize (Tar del contenedor): devuelve las dimensiones
máximas para este diseño dados los componentes en el contenedor de
destino especificado.
 minimumLayoutSize (Contenedor par): determina el tamaño mínimo del
contenedor principal utilizando este diseño de bolsa de cuadrícula.

Ejemplo:
// Java program to demonstrate GridBagLayout class.
import java.awt.*;
import java.awt.event.*;
import javax.swing.JFrame;
import javax.swing.*;
  
// class extends JFrame
public class GridbagDemo extends JFrame {
  
    GridbagDemo()
    {
  
        // Function to set title of JFrame.
        setTitle("GridBagLayoutDemo");
  
        // Creating Object of Jpanel class
        JPanel p = new JPanel();
  
        // set the layout
        p.setLayout(new GridBagLayout());
  
        // creates a constraints object
        GridBagConstraints c = new GridBagConstraints();
  
        // insets for all components
        c.insets = new Insets(2, 2, 2, 2);
  
        // column 0
        c.gridx = 0;
  
        // row 0
        c.gridy = 0;
  
        // increases components width by 10 pixels
        c.ipadx = 15;
  
        // increases components height by 50 pixels
        c.ipady = 50;
  
        // constraints passed in
        p.add(new JButton("Java Swing"), c);
  
        // column 1
        c.gridx = 1;
  
        // increases components width by 70 pixels
        c.ipadx = 90;
  
        // increases components height by 40 pixels
        c.ipady = 40;
  
        // constraints passed in
        p.add(new JButton("Layout"), c);
  
        // column 0
        c.gridx = 0;
  
        // row 2
        c.gridy = 1;
  
        // increases components width by 20 pixels
        c.ipadx = 20;
  
        // increases components height by 20 pixels
        c.ipady = 20;
  
        // constraints passed in
        p.add(new JButton("Manager"), c);
  
        // increases components width by 10 pixels
        c.ipadx = 10;
  
        // column 1
        c.gridx = 1;
  
        // constraints passed in
        p.add(new JButton("Demo"), c);
  
        // Creating Object of "wndcloser" 
        // class of windowlistener
        WindowListener wndCloser = new WindowAdapter() {
  
            public void windowClosing(WindowEvent e)
            {
  
                // exit the system
                System.exit(0);
            }
        };
  
        // add the actionwindowlistener
        addWindowListener(wndCloser);
  
        // add the content
        getContentPane().add(p);
  
        // Function to set size of JFrame.
        setSize(600, 400);
  
        // Function to set visiblity of JFrame.
        setVisible(true);
    }
  
    // Main Method
    public static void main(String[] args)
    {
  
        // calling the constructor
        new GridbagDemo();
    }
}

5. Investigar sobre los eventos, su definición, e implementación en una


interfaz gráfica, y un ejemplo.

5.1 Interfaz Gráfica:

Para empezar la discusión de cómo realizar interfaces graficas en Java, debemos


primero realizar algunas aclaraciones:

 El concepto de "Interfaz de usuario" se refiere a los mecanismos para


construir ventanas, botones, menús, etc. que permiten crear una interfaz
amigable para nuestros programas y no al concepto de "interface" que
existe en Java y que se refiere a una especie de clase abstracta pura.
 Los mecanismos para crear "interfaces de usuario" en Java están pensados
para favorecer la creación de la lógica de negocio separada de la creación
de la interfaz de usuario. Sin embargo, no hay garantía de que esto suceda.
Es responsabilidad del programador cristalizar este objetivo. Para poder
lograrlo le sugerimos al lector estudiar el patrón de diseño conocido como
MVC.
 Para el manejo de eventos Java utiliza un modelo en el cual existe un
"ente" generador de eventos y otros "entes" interesados en dar respuesta a
los eventos. Cuando un evento se produce, el generador del evento avisa a
todos los "entes" que hayan manifestado su interes en el evento. Y cada
uno de los interesados responderá al evento utilizando su propia lógica.

Para mayor claridad construiremos un ejemplo completo poco a poco; sin embargo
debemos advertir que se asume que el lector está familiarizado con conceptos
como: clase, objeto, mensaje, constructora, referencias, imports, herencia e
interfaces.

Los containers contienen componentes y estos son acomodados dentro del


espacio visual del container respetanto unaa cierta distribución que llamaremos
layout.
La interfaz de usuario es la parte del programa que permite al usuario
interaccionar con él. La API de Java proporciona una biblioteca de clases para el
desarrollo de Interfaces gráficas de usuario (en realidad son dos). La biblioteca
proporciona un conjunto de herramientas para la construcción de interfaces
gráficas que tienen una apariencia y se comportan de forma semejante en todas
las plataformas en las que se ejecuten. La estructura básica de la biblioteca gira
en torno a componentes y contenedores. Los contenedores contienen
componentes y son componentes a su vez, de forma que los eventos pueden
tratarse tanto en contenedores como en componentes.

La API está constituida por clases, interfaces y derivaciones. AWT y Swing


 Component: superclase de todas las clases de interfaz gráfica.
Container: para agrupar componentes.
 JComponent: superclase de todos los componentes de Swing que se
dibujan directamente en los lienzos (canvas). Sus subclases son los
elementos básicos de la GUI.
 JFrame: ventana que no está contenida en otras ventanas.
 JDialog: cuadro de diálogo.
 JApplet: subclase de Applet para crear applets tipo Swing.
 JPanel: contenedor invisible que mantiene componentes de interfaz y
que se puede anidar, colocándose en otros paneles o en ventanas.
También sirve de lienzo.
 Graphics: clase abstracta que proporciona contextos gráficos donde
dibujar cadenas de texto, líneas y otras formas sencillas.
 Color: color de los componentes gráficos. Font: aspecto de los
caracteres.

 FontMetrics: clase abstracta para propiedades de las fuentes.


Categorías de clases: 9 Contenedores: JFrame, JApplet, JWindow,

 JDialog 9 Componentes intermedios: JPanel, JScrollPane 9


Componentes: JLabel, JBbutton, JTextField, JTextArea, ... 9 Clases de
soporte: Graphics, Color, Font
Construcción de una ventana

1 import javax.swing.*;
2
3 public class Trigo extends JFrame{
4
5 }

En la primera línea simplemente importamos el paquete donde está definida la


clase JFrame. Un JFrame es la clase que representa al tipo "Ventana". En otras
palabras un "JFrame" es una ventana del sistema operativo. Como nuestra clase
hereda (extienda) a la clase JFrame, Trigo será por lo tanto también un JFrame es
decir una ventana.

Para comprobar esto añadiremos a nuestra clase un método "main", quedando


ahora de la siguiente forma:

1 import javax.swing.*;
2
3 public class Trigo extends JFrame{
4 public static void main(String[] arg){
5 Trigo miAplicacion = new Trigo();
6 miAplicacion.setBounds(10,10,200,200);
7 miAplicacion.pack();
8 miAplicacion.setVisible(true);
9 }
10 }

Todos los mensajes enviados al objeto "miAplicacion" son métodos heredados de


"JFrame". El primer método "setBounds" establece la posición inicial de la ventana
en la pantalla y sus dimensiones. El segundo, "pack", en este momento no era
realmente necesario ya que la ventana está vacia; pero quisimos incluirlo para no
tener que modificar el main más tarde. Este método optimiza la disposición de los
elementos dentro de la ventana. Y el último mensaje es simplemente para
ordenarle a la venta que se haga visible. Después de compilar y ejecutar el código
verá en pantalla algo como lo mostrado en la figura.

Distribuciones Relativas
 
Los layouts determinan el criterio con el que se vaan a distribuir los componentes
dentro del container
 
FlowLayout : Distribuye los componentes uno al lado del otro en la parte superior
del container. Por defecto provee una alineación centrada, pero también puede
alinear a la izquierda o derecha.
 
BorderLayout: Divide el espacio del container en 5 regiones: NORTH, SOUTH,
EAST, WEST y CENTER, admite un único componente por región
 
GridLayout: Divide el espacio del container en una grilla de n filas por m columnas,
en donde las celdas son de igual tamaño
 
GridBagLayout: Divide el espacio del container en una grilla donde cada
componente puede ocupar varias filas y columnas. Además permite distribuir el
espacio interno de cada celda.

Ejemplo:
import javax.swing.*;
import java.awt.*;
public class Gui01 extends JFrame {
private Container panel;
private JButton miboton;
public Gui01() {
super("Ejemplo 01 con botón");
// Configurar componentes ;
miboton = new JButton("Aceptar");
panel = getContentPane();
panel.add(miboton);
...
setSize(200,100);
setVisible(true);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
public static void main(String args[]) {
Gui01 aplicacion = new Gui01();
}
}
import javax.swing.*;
import java.awt.*;
public class Gui01 extends JFrame {
private JButton miboton;
public Gui01() {
super("Ejemplo 01 con botón");
...
miboton = new JButton("Aceptar");
add(miboton);
...
setSize(200,100);
setVisible(true);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
public static void main(String args[]) {
Gui01 aplicacion = new Gui01();
}
}
public class Gui01 {
private JButton miboton;
private Container panel;
public Gui01() {
Jframe frame = new JFrame(“Ejemplo 01”);
panel = frame.getContentPane();
...
miboton = new JButton("Aceptar");
panel.add(miboton);
//se añade al contentPane del frame
...
frame.pack();
frame.setVisible(true);
frame.setDefaultCloseOperation(Jframe.EXIT_ON_CLOSE);
}
public static void main(String args[]) {
Gui01 aplicacion = new Gui01();
}
}
public class Gui01 {
private JButton miboton;
public Gui01() {
Jframe frame = new JFrame(“Ejemplo 01”);
...
miboton = new JButton("Aceptar");
frame.add(miboton); //se añade al frame
...
frame.pack();
frame.setVisible(true);
frame.setDefaultCloseOperation(Jframe.EXIT_ON_CLOSE);
}
public static void main(String args[]) {
Gui01 aplicacion = new Gui01();
}
}

También podría gustarte