Flow layout y action listener

1. Alumno Benjamín Joaquín Martínez
java.awt.FlowLayout
FlowLayout
Coloca los componentes de izquierda a derecha, línea a línea.
Es el gestor por defecto.
Constructores:
public FlowLayout();
public FlowLayout(int alignment);
public FlowLayout(int alignment, int hgap, int vgap);
Valores válidos para el alineamiento:
FlowLayout.LEFT
FlowLayout.RIGHT
FlowLayout.CENTER
El gap de separación entre componentes es en pixels.
El ejemplo:
import java.awt.*;
import java.applet.Applet;
public class FlowLayoutTest extends Applet {
public void init() {
FlowLayout layout = new FlowLayout();
setLayout(layout);
add(new Button("hola"));
add(new Button("adios"));
add(new Button("Etiqueta mas larga"));

2. add(new Button("1"));
add(new Button("2"));
add(new Button("3"));
}
}
FlowLayout es un gestor que pone los controles en una línea, como puede verse en la
figura
Si se cambia el tamaño del applet y los controles no caben en una línea, pasan a la línea
siguiente, como puede verse en la figura.
Un Panel tiene asociado por defecto una instancia de java.awt.FlowLayout La posición de
los componentes visuales es relativa al contenedor en el que se encuentra. La coordenada
0,0 es la esquina superior izquierda del contenedor.

3. java.awt.event.ActionListener
Se usa para detectar y manejar eventos de acción, osea, los que tienen lugar cuando se
produce una acción sobre un elemento del programa.
Un evento ActionEvent se produce:
 al pulsar un botón.
 al hacer doble clic en un elemento de lista.
 al pulsar INTRO en una caja de texto.
 al elegir un menú.
Los distintos elementos del programa están vigilados por Listeners que detectan las
acciones que tienen lugar sobre el elemento vigilado. Cuando ActionListener detecta una
acción se genera un evento de acción (ActionEvent) en el elemento. Los ActionEvent
invocan el método actionPerformed(ActionEvent e) que realiza las acciones programadas
ante ese evento.

4. Existen dos formas de usar un ActionListener, la primera es que la clase implemente esta
interfaz, de este modo:
public class Principal implements ActionListener{
public Principal(){
JButton b=new JButton("aceptar");
b.addActionListener(this);
}
public void actionPerformed(ActionEvent e) {
}
}
En este código se puede ver que la clase implementa esta interfaz y tiene que implementar
sus métodos. Ademas podemos ver que cree un botón y con el método addActionListener
le adicione el ActionListener, use la palabra clave this, ya que es la clase la que implementa
la interfaz.
La otra es que se cree un objeto ActionListener y luego se le manda el objeto al
componente, de esta forma:
public class Principal{
public Principal(){

5. ActionListener accion=new ActionListener() {
public void actionPerformed(ActionEvent e) {
}
};
JTextField t=new JTextField(8);
t.addActionListener(accion);
}
}
Aquí se puede ver que cuando se crea el objeto ActionListener se implementa el metodo
actionPerformed. Además se puede ver que se creó un cuadro de texto y se le adiciono el
ActionListener con el metodo addActionListener de la clase JTextField. Muchos
componentes aceptan ActionListener como son los JButton, JTextField, JTextArea, JLabel,
etc.

6. java.awt.event.ActionEvent
Ejecutar acciones sencillas al pulsar botones mediante la interface ActionListener: detectar
la pulsación del botón como un evento de acción (ActionEvent) y llamar a la acción
prevista con el método actionPerformed
Las aplicaciones han de responder a las acciones que realiza el usuario, por ejemplo:
cerrar la ventana al pulsar un botón. Es necesario poder detectar las acciones de usuario y
convertirlas en acciones de programa. Java dispone de varias formas de implementar este
funcionamiento. En este ejercicio se mostrarán algunas de ellas. Todas se basan en el uso
de Interfaces.
 Las Interfaces son clases "prefabricadas" con propósitos definidos
 Cada Interface contiene declaraciones de métodos (nombre del método, lista de
argumentos y tipo de retorno) pero estos métodos no están implementados (carecen de
cuerpo) y deben ser desarrollados
 Todos los métodos de las Interfaces son public
 Las Interfaces también pueden declarar constantes (public final static).
En Java no existe la herencia múltiple como tal: una clase no puede heredar (extends) de
más de una clase. Pero una clase puede implementar más de una Interface, ésta es una
manera de tener herencia múltiple. En la clase que implementa una Interface han de ser
sobrescritos (override) todos los métodos declarados en la Interface.
 ActionListener es una Interface del grupo de los Listeners
 ActionListener tiene un sólo método: void actionPerformed(ActionEvent e)
 ActionListener se usa para detectar y manejar eventos de acción (ActionEvent) que son los
que tienen lugar cuando se produce una acción sobre un elemento del programa.
Un evento ActionEvent se produce:
 al pulsar un botón (Button)
 al hacer doble clic en un elemento de lista (List)

7.  al pulsar INTRO en una caja de texto (TextField)
 al elegir un menú (MenuItem).
Los distintos elementos del programa (botones, etc...) están vigilados por Listeners que
detectan las acciones que tienen lugar sobre el elemento supervisado.
Cuando ActionListener detecta una acción (por ejemplo: pulsar sobre un botón) se genera
un evento de acción (ActionEvent) en el elemento (botón). Los ActionEvent invocan el
método actionPerformed(ActionEvent e) que realiza las acciones programadas ante ese
evento. La clase que implementa ActionListener ha de importar el
paquete java.awt.event.*.
De manera que cuando el usuario pulsa un botón:
 el botón sobre el que se produce una acción y genera un evento (event source, este dato
se puede obtener con el método getSource) ha de estar previamente registrado con algún
objeto que gestione el evento (ActionListener en este caso) mediante el método:
boton.addActionListener(ActionListener nombre_de_actionListener)
 el botón genera un ActionEvent (clase del paquete java.awt.event)
 ActionEvent invoca al método actionPerformed que realiza las acciones programadas
 si la clase implementa ActionListener, ha de ser sobreescrito (override) el método public
void actionPerformed(ActionEvent e).

8. javax.swing.JFrame
En java para hacer interfaces de usuario se puede utilizar los JFrame, que vienen siendo las
ventanas en las que el usuario puede navegar por la aplicación. En esta entrada y las
siguientes aprenderemos sobre este elemento y sobre muchos otros.
Existen varias formas de crear JFrames en Java pero siempre utilizo una por ser más
ordenada y porque me gusta más, que es extendiendo de la Clase JFrame y no creando un
objeto JFrame dentro de mi clase, más bien mi clase es el JFrame.
Para crear un JFrame se tiene que importar la librería:
import javax.swing.JFrame;
Luego de importarla vamos a crear un método para inicializar nuestra ventana, debido a
que extendemos directamente de JFrame podemos utilizar los métodos de esta
directamente, por ejemplo un inicializador sencillo para nuestra ventana sería el siguiente:
private void inicializador(){
//Tamaño de la ventana
setSize(800,600);
//Layout de la ventana
setLayout(null);
//Titulo
setTitle("Mi ventana");
//Posicion (aparecerá en el centro de la pantalla)
setLocationRelativeTo(null);
//Visible
setVisible(true);
//Modificación de tamaño (no se puede modificar el tamaño del frame)
setResizable(false);
//Cierra el proceso del frame cuando se cierra la ventana
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
Este método se tiene que llamar en el constructor de nuestra clase para poder ver nuestro
frame, aunque solo con esto nuestra ventana parece aburrida, podemos agregarle
componentes con funcionalidades como JLabel, botones, checkBox, radioButon, paneles,
barras de desplazamiento entre muchas otras cosas, pero eso será en las entradas
siguientes.
Al final mi clase quedará así:
import javax.swing.JFrame;

9. //Esta linea quita una advertencia (Para el que no le guste tener
advertencias)
@SuppressWarnings("serial")
public class JFrames extends JFrame {
public JFrames() {
inicializador();
}
private void inicializador(){
//Tamaño de la ventana
setSize(800,600);
//Layout de la ventana
setLayout(null);
//Titulo
setTitle("Mi ventana");
//Posicion (aparecerá en el centro de la pantalla)
setLocationRelativeTo(null);
//Visible
setVisible(true);
//Modificación de tamaño (no se puede modificar el tamaño del frame)
setResizable(false);
//Cierra el proceso del frame cuando se cierra la ventana
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
}
Con esto creamos una ventana con Java, en la cual podremos colocar diversos elementos.

10. javax.swing.JTextField
Un JTextField o campo de texto es un componente java de la clase swing que crea un
input utilizado para la captura de datos.
Constructores:
 JTextField().- Construye un nuevo TextField.
 JTextField(Document doc, String text, int columns).- Crea una nueva JTextField que
usa el modelo de almacenamiento de texto dado y el número dado de columnas.
 JTextField(int columns).- Construye un nuevo vacío TextField con el número
especificado de columnas.
 JTextField(String text).- Construye un nuevo TextField inicializado con el texto
especificado.
 JTextField(String text, int columns).- Construye un nuevo TextField inicializado con el
texto y las columnas especificados.
Ejemplo:
import java.awt.FlowLayout;
import javax.swing.*;
public class Ejemplo {
JTextField texto;
public Ejemplo(){
JFrame ventana = new JFrame("Caja de Texto en Java");
texto = new JTextField(10);
ventana.setLayout(new FlowLayout());
ventana.setSize(450, 400);
ventana.setVisible(true);
ventana.add(texto);
}
public static void main (String[]args){
Ejemplo t = new Ejemplo();
}
}

11. Propiedades :
 jtextfield.setBounds(new Rectangle(25, 15, 250, 21)). Cada uno de los valores del
parámetro (25,15,250,21) es igual a (x,y,width,height), donde x,y, es la coordenada en
la que se ubica el control, dentro del contenedor del formulario. Width es el ancho
que tendrá el control, o sea, 250 pixeles y height sería la altura, en este caso de 21
píxeles.
 jtextfield.setText(“Realizada modificación del JTextField”). En esta instrucción,
queda claro que la cadena “Realizada modificación del JTextField”, que se le pasa
como parámetro al método setText, aparece dentro de la caja de texto durante la
ejecución del programa.
 jtextfield.setEditable(false). Si esta instrucción, está establecida en true, permite que
se pueda escribir sobre el JTextField. Si está establecida en false, impide que el
usuario pueda modificar el contenido del JTextField.
 jtextfield.setHorizontalAlignment(JTextField.LEFT). El parámetro LEFT, permite que el
texto en la caja de texto, se alinee a la izquierda, el parámetro CENTER al centro y el
RIGHT a la derecha.
Ejemplo 01:
import java.awt.*;
import javax.swing.*;
public class Ejemplo1 {
JTextField dato1,dato2;
public Ejemplo1(){
JFrame ventana = new JFrame("Caja de Texto en Java");

12. dato1 = new JTextField("Nombres",20);
dato1.setBackground(new Color(255, 255, 51));
dato1.setForeground(new java.awt.Color(102, 102, 255));
dato2 = new JTextField("Apellidos",20);
dato2.setBackground(new Color(204, 255, 153));
dato2.setForeground(new Color(255, 0, 0));
ventana.setLayout(new FlowLayout());
ventana.setSize(350, 400);
ventana.setVisible(true);
ventana.add(dato1);
ventana.add(dato2);
}
public static void main (String[]args){
Ejemplo1 t1 = new Ejemplo1();
}
}

13. Bibliografía
ActionListener. (s/f). Recuperado el 19 de abril de 2021, de
Myjavazone.com website:
http://www.myjavazone.com/2010/06/actionlistener.html
Java: Swing: JFrame. (s/f). Recuperado el 19 de abril de 2021, de
Blogspot.com website: https://franvarvil.blogspot.com/2012/12/jframe-
programacion-java.html
JTextField en java. (2018, abril 16). Recuperado el 19 de abril de 2021, de
Wordpress.com website: https://victomanolo.wordpress.com/jtextfield-
en-java/
Los gestores FlowLayout, BorderLayout y Gridlayout. (s/f). Recuperado el
19 de abril de 2021, de Ehu.es website:
http://www.sc.ehu.es/sbweb/fisica/cursoJava/applets/diseno/flow.htm
pol. (s/f). Acciones en Java con ActionListener. Recuperado el 19 de abril
de 2021, de Perez987.es website: https://perez987.es/acciones-al-pulsar-
un-boton-en-java/
(S/f). Recuperado el 19 de abril de 2021, de Upm.es website:
https://www.dit.upm.es/~santiago/docencia/apuntes/applets/layout.ht
m