Clase-3 Programación en Java

UNIDAD Nº 2: TEMAS: Clase
Componentes
visuales - swing.
Componentes visuales:
JFrame, JButton, JLabel 3
Objetivos:
 Interfaces visuales en Java.
 Componentes visuales: JFrame, JButton, JLabel
 Eventos
Introducción
Hasta ahora hemos resuelto todos los algoritmos haciendo las salidas a través de una
consola en modo texto. La realidad que es muy común la necesidad de hacer la entrada y salida
de datos mediante una interfaz más amigables con el usuario.
En Java existen varias librerías de clases para implementar interfaces visuales. Utilizaremos las
componentes Swing.
Estructura básica de una aplicación
Problema 1
Confeccionar el programa "Hola Mundo" utilizando una interfaz gráfica de usuario.
import javax.swing.*;
public class Formulario extends JFrame{

private JLabel label1;
public Formulario() {
setLayout(null);
label1=new JLabel("Hola Mundo.");
label1.setBounds(10,20,200,30);
add(label1);
}
public static void main(String[] ar) {

Formulario formulario1=new Formulario();
formulario1.setBounds(10,10,400,300);
formulario1.setVisible(true);
}
}
Instituto Superior Santo Domingo Página 1 de 15

Hasta ahora habíamos utilizado la clase Scanner para hacer la entrada de datos por teclado. Dicha
clase debemos importarla en nuestro programa con la sintaxis:
import java.util.Scanner;
Otra sintaxis para importarla es:
import java.util.*;
Si disponemos un * indicamos que importe todas las clases del paquete java.util.
Ahora bien las componentes Swing hay que importarlas del paquete javax.swing. Cuando debemos
importar varias componentes de un paquete es más conveniente utilizar el asterisco que indicar cada
clase a importar:
import javax.swing.JFrame;
import javax.swing.JLabel;
En lugar de las dos líneas anteriores es mejor utilizar la sintaxis:
La clase JFrame encapsula el concepto de una ventana. Luego para implementar una aplicación que
muestre una ventana debemos plantear una clase que herede de la clase JFrame:
Con la sintaxis anterior estamos indicando que que la clase Formulario hereda todos los métodos y
propiedades de la clase JFrame.
Para mostrar un texto dentro de una ventana necesitamos requerir la colaboración de la clase JLabel
(que tiene por objetivo mostrar un texto dentro de un JFrame)
Definimos luego como atributo de la clase un objeto de la clase JLabel:
private JLabel label1;
En el constructor de la clase llamamos al método heredado de la clase JFrame llamado setLayout y le

pasamos como parámetro un valor null, con esto estamos informándole a la clase JFrame que
utilizaremos posicionamiento absoluto para los controles visuales dentro del JFrame.
setLayout(null);
Luego tenemos que crear el objeto de la clase JLabel y pasarle como parámetro al constructor el
texto a mostrar:
Ubicamos al objeto de la clase JLabel llamando al método setBounds, este requiere como parámetros
la columna, fila, ancho y alto del JLabel. Finalmente llamamos al método add (metodo heredado de la
clase JFrame) que tiene como objetivo añadir el control JLabel al control JFrame.

add(label1);
}
Finalmente debemos codificar la main donde creamos un objeto de la clase Formulario, llamamos al
método setBounds para ubicar y dar tamaño al control y mediante el método setVisible hacemos
visible el JFrame:

}
Cuando ejecutamos nuestro proyecto tenemos como resultado una ventana similar a esta:
Control: JFrame
La componente básica que requerimos cada vez que implementamos una interfaz visual con la
libraría Swing es la clase JFrame. Esta clase encapsula una Ventana clásica de cualquier sistema
operativo con entorno gráfico (Windows, OS X, Linux etc.)
Hemos dicho que esta clase se encuentra en el paquete javax.swing y como generalmente utilizamos
varias clases de este paquete luego para importarla utilizamos la sintaxis:
Podemos hacer una aplicación mínima con la clase JFrame:
public class Formulario {
JFrame f=new JFrame();
f.setBounds(10,10,300,200);
f.setVisible(true);
}
}
Como vemos importamos la clase JFrame del paquete javax.swing:
y luego en la main definimos y creamos un objeto de la clase JFrame (llamando luego a los métodos
setBounds y setVisible):

JFrame f=new JFrame();
f.setBounds(10,10,300,200);
f.setVisible(true);
}
Pero esta forma de trabajar con la clase JFrame es de poca utilidad ya que rara vez necesitemos
implementar una aplicación que muestre una ventana vacía.
Lo más común es plantear una clase que herede de la clase JFrame y extienda sus
responsabilidades agregando botones, etiquetas, editores de línea etc.
Entonces la estructura básica que emplearemos para crear una interfaz visual será:
setLayout(null);
}

}
}
Importamos el paquete donde se encuentra la clase JFrame:

Planteamos una clase que herede de la clase JFrame:
En el constructor indicamos que ubicaremos los controles visuales con coordenadas absolutas
mediante la desactivación del Layout heredado (más adelante veremos otras formas de ubicar los
controles visuales dentro del JFrame):
setLayout(null);
}

En la main creamos un objeto de la clase y llamamos a los métodos setBounds y setVisible:

}
El método setBounds ubica el JFrame (la ventana) en la columna 10, fila 20 con un ancho de 400
píxeles y un alto de 300.
Debemos llamar al método setVisible y pasarle el valor true para que se haga visible la ventana.
Problema propuesto
Crear una ventana de 1024 píxeles de ancho por 800 píxeles de alto. Luego no permitir que el
operador modifique el tamaño de la ventana. Sabiendo que hacemos visible al JFrame llamando la
método setVisible pasando el valor true, existe otro método llamado setResizable que también
requiere como parámetro un valor true o false.
Control: JLabel
Veamos la segunda componente de la librería swing llamada JLabel.

La clase JLabel nos permite mostrar básicamente un texto.
Problema 1
Confeccionar una ventana que muestre el nombre de un programa en la parte superior y su número
de versión en la parte inferior. No permitir modificar el tamaño de la ventana en tiempo de ejecución.
public class Formulario extends JFrame {
private JLabel label1,label2;
setLayout(null);
label1=new JLabel("Sistema de Facturación.");
add(label1);
label2=new JLabel("Vesion 1.0");
add(label2);
}

formulario1.setResizable(false);
}
}
Importamos el paquete javax.swing donde se encuentran definidas las clase JFrame y JLabel:
Heredamos de la clase de JFrame:
public class Formulario extends JFrame {
Definimos dos atributos de la clase JLabel:
private JLabel label1,label2;
En el constructor creamos las dos JLabel y las ubicamos llamando al método setBounds, no hay que
olvidar de llamar al método add que añade la JLabel al JFrame:
setLayout(null);
label1=new JLabel("Sistema de Facturación.");
add(label1);
label2=new JLabel("Vesion 1.0");
add(label2);
}
Por último en la main creamos un objeto de la clase que acabamos de codificar, llamamos al método
setBounds para ubicar y dar tamaño al JFrame, llamamos al método setResizable pasando el valor
false para no permitir modificar el tamaño del JFrame en tiempo de ejecución y finalmente llamamos
al método setVisible para que se visualice el JFrame:

formulario1.setResizable(false);
}

Problema propuesto
Crear tres objetos de la clase JLabel, ubicarlos uno debajo de otro y mostrar nombres de colores.
Control: JButton
El tercer control visual de uso muy común es el que provee la clase JButton. Este control visual
muestra un botón.
El proceso para añadir botones a un control JFrame es similar a añadir controles de tipo JLabel.
Ahora veremos la captura de eventos con los controles visuales. Uno de los eventos más comunes es
cuando hacemos clic sobre un botón.
Java implementa el concepto de interfaces para poder llamar a métodos de una clase existente a una
clase desarrollada por nosotros.
Problema 1
Confeccionar una ventana que muestre un botón. Cuando se presione finalizar la ejecución del
programa Java.
import java.awt.event.*;
public class Formulario extends JFrame implements ActionListener {

JButton boton1;
setLayout(null);
boton1=new JButton("Finalizar");
boton1.setBounds(300,250,100,30);
add(boton1);
boton1.addActionListener(this);
}
public void actionPerformed(ActionEvent e) {

if (e.getSource()==boton1) {
System.exit(0);
}
}

}
}
La mecánica para atrapar el clic del objeto de la clase JButton se hace mediante la implementación
de una interface. Una interface es un protocolo que permite la comunicación entre dos clases. Una
interface contiene uno o más cabeceras de métodos, pero no su implementación. Por ejemplo la
interface ActionListener tiene la siguiente estructura:
interface ActionListener {
}
Luego las clases que implementen la interface ActionListener deberán especificar el algorítmo del
método actionPerformed.
Mediante el concepto de interfaces podemos hacer que desde la clase JButton se puede llamar a un
método que implementamos en nuestra clase.
Para indicar que una clase implementará una interface lo hacemos en la declaración de la clase con
la sintaxis:
public class Formulario extends JFrame implements ActionListener {
Con esto estamos diciendo que nuestra clase implementa la interface ActionListener, luego estamos
obligados a codificar el método actionPerformed.
Definimos un objeto de la clase JButton:
JButton boton1;
En el constructor creamos el objeto de la clase JButton y mediante la llamada del método

addActionListener le pasamos la referencia del objeto de la clase JButton utilizando la palabra clave
this (this almacena la dirección de memoria donde se almacena el objeto de la clase Formulario,
luego mediante dicha dirección la clase Jbutton puede llamar al método actionPerformed que
implementamos en la clase Formulario):
setLayout(null);
boton1=new JButton("Finalizar");
add(boton1);
}
El método actionPerformed (este método de la interface ActionListener debe implementarse

obligatoriamente, en caso de no codificarlo o equivocarnos en su nombre aparecerá un mensaje de
error en tiempo de compilación de nuestro programa.
El método actionPerformed se ejecutará cada vez que hagamos clic sobre el objeto de la clase
JButton.
La interface ActionListener y el objeto de la clase ActionEvent que llega como parámetro están
definidos en el paquete:
Es decir que cada vez que se presiona el botón desde la clase JButton se llama al método
actionPerformed y recibe como parámetro un objeto de la clase ActionEvent.
En el método actionPerformed mediante el acceso al método getSource() del objeto que llega como
parámetro podemos analizar que botón se presionó:

System.exit(0);
}
}
Si se presionó el boton1 luego el if se verifica verdadero y por lo tanto llamando al método exit de la
clase System se finaliza la ejecución del programa.
La main no varía en nada con respecto a problemas anteriores.
Problema 2
Confeccionar una ventana que contenga tres objetos de la clase JButton con las etiquetas "1", "2" y
"3". Al presionarse cambiar el título del JFrame indicando cuál botón se presionó.

public class Formulario extends JFrame implements ActionListener{
private JButton boton1,boton2,boton3;
setLayout(null);
boton1=new JButton("1");
add(boton1);
add(boton2);
add(boton3);
}

setTitle("boton 1");
}
}
}
}
public static void main(String[] ar){

}
}
Debemos declarar 3 objetos de la clase JButton:
private JButton boton1,boton2,boton3;
En el constructor creamos los tres objetos de la clase JButton y los ubicamos dentro del control
JFrame (también llamamos al método addActionListener para enviarle la dirección del objeto de la
clase Formulario):
setLayout(null);
add(boton1);
add(boton2);
add(boton3);
}
Cuando se presiona alguno de los tres botones se ejecuta el método actionPerformed y mediante tres
if verificamos cual de los botones se presionó:
}
}
}
}
Según el botón presionado llamamos al método setTitle que se trata de un método heredado de la
clase JFrame y que tiene por objetivo mostrar un String en el título de la ventana.
Problema 3
Confeccionar una aplicación que muestre un tablero de TaTeTi utilizando 9 objetos de la clase
JButton (se inicializan con cadena vacía en su etiqueta)
Cuando se presiona un botón se debe disponer un caracter “X” o una “O”.
Para disponer en forma alternativa cada caracter definir un atributo en la clase con el caracter “X”,
cambiar esta variable cada vez que se presiona algún botón.

El código fuente completo es:
public class TaTeTi extends JFrame implements ActionListener{

JButton b1,b2,b3,b4,b5,b6,b7,b8,b9;
String actual="X";
public TaTeTi()
{
setLayout(null);
b1=new JButton("");
b1.setBounds(10,10,100,100);
b1.addActionListener(this);
add(b1);
b2=new JButton("");
b2.setBounds(120,10,100,100);
add(b2);
b3=new JButton("");
b3.setBounds(230,10,100,100);
add(b3);
b4=new JButton("");
b4.setBounds(10,120,100,100);
add(b4);
b5=new JButton("");
b5.setBounds(120,120,100,100);
add(b5);
b6=new JButton("");
b6.setBounds(230,120,100,100);
add(b6);
b7=new JButton("");
b7.setBounds(10,230,100,100);
add(b7);
b8=new JButton("");
b8.setBounds(120,230,100,100);
add(b8);
b9=new JButton("");
b9.setBounds(230,230,100,100);
add(b9);
}

if (e.getSource()==b1) {
b1.setText(actual);
}
b2.setText(actual);
}
b3.setText(actual);
}
b4.setText(actual);
}
b5.setText(actual);
}
b6.setText(actual);
}
b7.setText(actual);
}
b8.setText(actual);
}
b9.setText(actual);
}
if (actual.equals("X")) {
actual="O";
} else {
actual="X";
}
}
public static void main(String[] ar){

TaTeTi tateti1;
tateti1=new TaTeTi();
tateti1.setBounds(0,0,350,400);
tateti1.setVisible(true);
}
}
Definimos 9 objeto de la clase JButton:

JButton b1,b2,b3,b4,b5,b6,b7,b8,b9;
Definimos un atributo llamado actual de tipo String y almacenamos el String con el carácter
“X”:
String actual="X";
Cada botón lo creamos pasando en el constructor la cadena vacía:

b1=new JButton("");
Para ubicar cada botón tenemos que tener bien en cuenta los dos primeros parámetros que
indican la columna y fila donde se ubicará el botón (el tercer y cuarto parámetro indica el
ancho y alto del botón):
b1.setBounds(10,10,100,100);
add(b1);
El segundo botón lo único que difiere que lo ubicamos en la columna 120 y en la misma fila
10:
b2=new JButton("");
b2.setBounds(120,10,100,100);
add(b2);
En el método actionPerformed analizamos cual botón se presionó con una serie de if:
Si se presiona el botón b1 luego cambiamos la etiqueta del botón llamando al método setText
y disponemos el valor almacenado en la variable actual (la primer vez tiene el caracter “X”):
b1.setText(actual);
}

En forma idéntica analizamos los otros 8 botones:
b2.setText(actual);
}
………..
Luego de verificar que botón se presionó procedemos a cambiar el contenido de la variable

actual (si tiene actualmente el String “X” procedemos a asignarle “O” y viceversa.
if (actual.equals("X")) {
actual="O";
} else {
actual="X";
}
Problemas propuestos
1 - Disponer dos objetos de la clase JButton con las etiquetas: "varón" y "mujer", al presionarse
mostrar en la barra de títulos del JFrame la etiqueta del botón presionado.
2 – Modificar el programa del TaTeTi para mostrar en el título de JFrame cuando alguno de los dos
jugadores ganó (verificar si en forma vertical, horizontal o diagonal hay tres String iguales distintos a
cadena vacía “”)
Para saber el contenido de un botón debemos llamar al método getText():
String valor=b1.getText();

Clase-3 Programación en Java

Cargado por

Copyright:

Formatos disponibles

Clase-3 Programación en Java

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Clase-3 Programación en Java

Cargado por

Copyright:

Formatos disponibles

UNIDAD Nº 2: TEMAS: Clase

Estructura básica de una aplicación

public class Formulario extends JFrame{

public static void main(String[] ar) {

Instituto Superior Santo Domingo Página 1 de 15

Otra sintaxis para importarla es:

En lugar de las dos líneas anteriores es mejor utilizar la sintaxis:

public class Formulario extends JFrame{

private JLabel label1;

En el constructor de la clase llamamos al método heredado de la clase JFrame llamado setLayout y le

label1=new JLabel("Hola Mundo.");

label1=new JLabel("Hola Mundo.");

public static void main(String[] ar) {

Podemos hacer una aplicación mínima con la clase JFrame:

Como vemos importamos la clase JFrame del paquete javax.swing:

public static void main(String[] ar) {

public static void main(String[] ar) {

Importamos el paquete donde se encuentra la clase JFrame:

Planteamos una clase que herede de la clase JFrame:

public class Formulario extends JFrame{

Instituto Superior Santo Domingo Página 4 de 15

public static void main(String[] ar) {

Veamos la segunda componente de la librería swing llamada JLabel.

public static void main(String[] ar) {

Heredamos de la clase de JFrame:

public class Formulario extends JFrame {

Definimos dos atributos de la clase JLabel:

private JLabel label1,label2;

public static void main(String[] ar) {

Instituto Superior Santo Domingo Página 6 de 15

Instituto Superior Santo Domingo Página 7 de 15

public void actionPerformed(ActionEvent e) {

public static void main(String[] ar) {

public class Formulario extends JFrame implements ActionListener {

En el constructor creamos el objeto de la clase JButton y mediante la llamada del método

El método actionPerformed (este método de la interface ActionListener debe implementarse

public void actionPerformed(ActionEvent e) {

Instituto Superior Santo Domingo Página 9 de 15

public void actionPerformed(ActionEvent e) {

public static void main(String[] ar){

Debemos declarar 3 objetos de la clase JButton:

private JButton boton1,boton2,boton3;

Instituto Superior Santo Domingo Página 11 de 15

public class TaTeTi extends JFrame implements ActionListener{

public void actionPerformed(ActionEvent e) {

public static void main(String[] ar){

Definimos 9 objeto de la clase JButton:

Cada botón lo creamos pasando en el constructor la cadena vacía:

Instituto Superior Santo Domingo Página 14 de 15

Luego de verificar que botón se presionó procedemos a cambiar el contenido de la variable

Instituto Superior Santo Domingo Página 15 de 15

También podría gustarte