K-71 Robles - Debora - A4
K-71 Robles - Debora - A4
K-71 Robles - Debora - A4
Grupo: K-71.
Proyecto: Actividad 4.
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).
- 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
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:
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
3.1 JButton
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
Ejemplo.
import java.awt.FlowLayout;
import javax.swing.*;
JTextField t1,t2,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
3.5 JRadioButton
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);
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.1 FlowLayout.
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.
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
Ejemplo
4.2 Gridlayout.
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;
fillGrid();
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
add(Componente, Coordenada)
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.
Clase GridBagLayout
Constructor:
GridBagLayout (): se utiliza para crear un administrador de diseño de
bolsa de cuadrícula.
Métodos:
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();
}
}
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.
1 import javax.swing.*;
2
3 public class Trigo extends JFrame{
4
5 }
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 }
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();
}
}