OBJETIVOS

 Conocer y usar objetos básicos de programación con Swing.

 Conocer la nueva tecnología para la creación de interfaces gráficas.

 Comprender y utilizar las clases JFrame, JPanel y JButton.

1. JAVA FOUNDATION CLASSES (JFC)

JFC es la abreviatura de Java Foundation Classes, que comprende un

grupo de características para ayudar a construir interfaces gráficos de
usuario (GUIs). Se creo como una extensión de AWT. Comprende las
siguientes características:
 Componentes Swing.
 API de accesibilidad.
 Java 2D API
 Soporte de Drag and Drop.

1
 Jerarquía de clases de Swing
Object
Button

Canvas
Graphics
Component Checkbox

Choice

TextComponent Container List

Scrollbar
TextField TextArea Window Panel ScrollPane

Frame Dialog Java.applet

Applet

FileDialog

2. La clase JComponent
Extiende de Container, la lcual a su vez hereda de la clase Component;
todas estas del paquete java.awt. Incluye eventos de y tiene soporte
para agregar o quitar componentes al contenedor.

3. Clase JFrame:

La clase JFrame implementa un objeto ventana, JFrame es una

extensión de la clase Frame del paquete AWT. Para crear una ventana,
existen dos formas principales de hacerlo:

 Crear un objeto de la clase JFrame

 Extender la clase JFrame

El último método es muy útil cuando se crean ventanas personalizadas

que se invocan repetidamente (como ventanas de error, o de
información).

 Crearemos una ventana con el primer método:

ventana = new JFrame();

 Una vez creado una ventana JFrame, ésta obtiene el tamaño

necesario para mostrar los componentes que existen dentro de la
aplicación, como en nuestro ejemplo no existe componente,

2
 cambiaremos su tamaño inicial, con el método: setSize(int ancho,
int largo)

ventana.setSize(200,300);

 Después cambiaremos su título para que sea el nombre de

nuestra aplicación con el método: setTitle(String titulo)

ventana.setTitle("Hola mundo Swing");

 El objeto existe, pero no es mostrado por defecto, entonces se

hace la llamada a: setVisible(boolean)

ventana.setVisible(true);

C
ó import java.awt.*;
d import java.awt.event.*;
i import javax.swing.*;
g
o public class Window extends JFrame
: {
public Window()
{
Sthis.setSize(400,500);
e this.setTitle("Primer Aplicacion Swing");
this.setVisible(true);
} d
e
b
public static void main(String []args)
{e
new Window();
n
o JFrame jFrameWindow = new JFrame();
t
a jFrameWindow.setSize(400,500);
r jFrameWindow.setTitle("Segunda Aplicacion Swing");
jFrameWindow.setVisible(true);
} q
} u
e

3
 JFrame
JPanel

JButton
JLabel

JFrame

containers

JPanel

JButton JLabel

Eventos para cerrar la ventana

4
Se puede especificar un comportamiento por defecto al cerrar la ventana
utilizando el método setDefaultCloseOperation. Y colocar los siguientes
valores:
 DO_NOTHING_ON_CLOSE: No hará nada cuando el usuario le
de clic en el botón cerrar de la ventana.
 HIDE_ON_CLOSE (por defecto): Ocultará la ventana y lo
removerá de la pantalla de usuario.
 DISPOSE_ON_CLOSE: Oculta y destruye la ventana cuando el
usuario la cierra.
 EXIT_ON_CLOSE: Termina la ejecución de la aplicación. Es
como si usáramos la sentencia System.exit(0).

5
 ACTIVIDAD
1. Cree un JFrame con dos botones de comando.

Código:

class MiPrimerJFrame extends JFrame{

public MiPrimerJFrame(String nombre, int x, int y){

super(nombre);

Icon icon= new ImageIcon("images/DUKE.GIF","Un Gif

Animado de Duke en Swing");
JLabel label = new JLabel("Swing!",icon,JLabel.CENTER);

add(label,BorderLayout.CENTER);

this.setSize(x,y);
}

public static void main(String[] arg){

// --- Creando componentes
MiPrimerJFrame jf=new MiPrimerJFrame("Mi Primer
JFrame",200,200);

jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
jf.setVisible(true);
}
}

6
 2. Cree un formulario con una imagen centrada.

import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
class JFrame03 extends JFrame{
int nveces=1;
JLabel label = new JLabel();
public JFrame03(String nombre, int x, int y){
super(nombre);
JButton button = new JButton("boton ",new
ImageIcon("images/duke.gif"));
button.setMnemonic('b'); // Alt+B o Alt+b
button.setFont(new Font("Comic sans", Font.PLAIN, 18));
setLayout(new FlowLayout());
add(button);
add(label);
setSize(x,y);
button.addActionListener( new ActionListener(){
public void actionPerformed(ActionEvent event){

label.setText(event.getActionCommand()+" fue activado "+nveces+" veces");

nveces++;}
});
}

public static void main(String[] arg){

JFrame03 jf=new JFrame03("JFrame con eventos",300,200);
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
jf.setVisible(true);
}
}

7
3. Cree un JFrame que muestre un botón el cual al pulsarlo indique
cuantas veces.

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

class JFrame03 extends JFrame{

int nveces=1;
JLabel label = new JLabel();

public JFrame03(String nombre, int x, int y){

super(nombre);
JButton button = new JButton("boton ",new
ImageIcon("images/duke.gif"));

button.setMnemonic('b'); // Alt+B o Alt+b

button.setFont(new Font("Comic sans", Font.PLAIN, 18));

setLayout(new FlowLayout());
add(button);
add(label);
setSize(x,y);

button.addActionListener( new ActionListener(){

public void actionPerformed(ActionEvent event){
label.setText(event.getActionCommand()+" fue
activado "+nveces+" veces");
nveces++;
}
});

public static void main(String[] arg){

JFrame03 jf=new JFrame03("JFrame con eventos",300,200);
8
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
jf.setVisible(true);
 4. Cree un Frame que muestre los dos tipos de botones:

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

class JFrame04 extends JFrame{

Button b1,b2,b3,b4;
JButton jb1,jb2,jb3;

public JFrame04(String nombre, int x, int y){

super(nombre);

setLayout(null);

//creando componentes AWT

Button b1 = new Button("boton AWT 1");
Button b2 = new Button("boton AWT 2");
Button b3 = new Button("boton AWT 3");
Button b4 = new Button("boton AWT 4");

//creando componentes Swing

JButton jb1 = new JButton("b Swing 1");
JButton jb2 = new JButton("b Swing 2");
JButton jb3 = new JButton("b Swing 3");

//definiendo coordenadas botones AWT

b1.setBounds(10,10,150,25);
b2.setBounds(10,65,150,25);
b3.setBounds(10,100,150,25);
b4.setBounds(10,130,150,25);

9
 //definiendo coordenadas botones Swing
jb1.setBounds(170,25,100,40);
jb2.setBounds(170,65,100,40);
jb3.setBounds(170,105,100,40);

//agregando botones awt

add(b1);
add(b2);
add(b3);
add(b4);

//agregando botones swing

add(jb1);
add(jb2);
add(jb3);

this.setSize(x,y);
}

public static void main(String[] arg){

// --- Creando componentes

JFrame04 jf=new JFrame04("Comparación de clases",500,400);
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
jf.setVisible(true);
}
}

La clase JPanel
JPanel es un contenedor de propósito general para componentes de peso
ligero. Como todos los contenedores, utiliza un Controlador de
Distribución para posicionar y dimensionar sus componentes. Como todos
los componentes Swing, JPanel permite añadirle bordes y determinar si
utiliza el doble buffer para aumentar el rendimiento.
Los métodos básicos para trabajar con JPanel son:

10
Para crear un JPanel
Método Propósito
Crea un panel. Cuando está presente, el
JPanel() parámetro boolean determina la estrategia de
JPanel(boolean) buffer del panel. Un valor true indica doble
JPanel(LayoutManager) buffer. El parámetro LayoutManager
JPanel(LayoutManager, proporciona el controlador de distribución para el
boolean) nuevo panel. Si no se especifica, el panel utiliza
FlowLayout para distribuir sus componentes.

Para manejar Componentes en un Contenedor

Método Propósito
void add(Component) Añade el componente especificado al panel.
void add(Component, Cuando existe, el parámetro int es la posición o
int) índice del componente dentro del contenedor. El
void add(Component, parámetro Object depende del controlador de
Object) distribución y normalmente proporciona
void add(Component, información sobre el posicionamiento y
Object, int) restricciones de distribución cuando se añaden
void add(String, componentes. El parámetro String proporciona
Component) un nombre para el componente.
int Obtiene el número de componentes en este
getComponentCount() panel.
Component
getComponent(int)
Component
getComponentAt(int, Obtiene el componente o componentes
int) especificados. Se pueden obtener basándose en
Component su índice, o en sus posiciones x,y.
getComponentAt(Point)
Component[]
getComponents()
void
remove(Component) Elimina el componente o componentes
void remove(int) especificados.
void removeAll()

Seleccionar/Obtener el Controlador de Distribución

Método Propósito
void Selecciona u obtiene el controlador de

11
 setLayout(LayoutManager) distribución para este panel. El controlador de
LayoutManager distribución es el responsable de posicionar
getLayout() los componentes dentro del panel de acuerdo
con alguna filosofía.

Tenemos la siguiente plantilla de JPanel que insertamos en el área cliente

de un JFrame. Normalmente en este JPanel ubicamos todos nuestros
componentes Swing, además, también podemos insertar en este JPanel
otros JPanels.

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

class MiPanel extends JPanel // implements ActionListener, …

{
// Aquí declaramos los componentes globales

public MiPanel()
{
// Aquí añadimos controles al panel
// ...
// Adicionamos interface a los componentes
// ...
}
// --------------------------------------------------------------------Para eventos
// public void actionPerformed(ActionEvent e)
// {
// …
// }
}

2. La clase JButton

JButton desciende de la clase AbstractButton que define un pequeño API

público adicional. La siguiente tabla muestra las subclases de
AbstractButton definidas en Swing que podemos utilizar:

Clase Sumario
JButton Un botón común
JCheckBox Un checkbox típico
JRadioButton Un botón de radio de un grupo.
JMenuItem Un ítem de un menú.
JToggleButton Implementa la funcionalidad heredada de JCheckBox y

12
 JRadioButton.

JButton en su nueva versión Swing permite insertar sobre él gif animados

(como lo veremos en un ejercicio posterior).

Las siguientes tablas listan los métodos y constructores más utilizados de

AbstractButton y JButton.

Seleccionar u obtener el contenido de un botón

Método o Constructor
JButton(String, Icon)
JButton(String)
JButton(Icon)
JButton()
void setText(String)
String getText()
void setIcon(Icon)
Icon getIcon()
void setDisabledIcon(Icon)
Icon getDisabledIcon()
void setPressedIcon(Icon)
Icon getPressedIcon()
void setSelectedIcon(Icon)
Icon getSelectedIcon()
void
setDisabledSelectedIcon(Icon)
Icon
getDisabledSelectedIcon()
setRolloverEnabled(boolean)
boolean getRolloverEnabled()
void setRolloverIcon(Icon)
Icon getRolloverIcon()
void
setRolloverSelectedIcon(Icon)
Icon
getRolloverSelectedIcon()
Propósito
Crea un ejemplar de JButton, lo inicializa
para tener el texto/imagen especificado.
Selecciona u obtiene el texto mostrado en
el botón.
Selecciona u obtiene la imagen mostrada
por el botón, cuando no está
seleccionado o pulsado.
Selecciona u obtiene la imagen mostrada
por el botón cuando está desactivado. Si
no se especifica una imagen, el aspecto y
comportamiento crea una por defecto.
Selecciona u obtiene la imagen mostrada
por el botón, cuando está pulsado.
Selecciona u obtiene la imagen mostrada
por el botón cuando está seleccionado. Si
no se especifica una imagen de botón
desactivado seleccionado, el aspecto y
comportamiento crea una manipulando la
imagen de seleccionado.
Utiliza setRolloverEnabled(true) y
setRolloverIcon(someIcon) para hacer
que el botón muestre el ícono
especificado cuando el cursor pasa sobre
él.

13
Ajuste fino de la apariencia del botón
Método o constructor Propósito
Selecciona u obtiene dónde debe situarse
void el contenido del botón. La clase
setHorizontalAlignment(int) AbstractButton permite uno de los
void setVerticalAlignment(int) siguientes valores para alineamiento
int getHorizontalAlignment() horizontal: LEFT, CENTER (por defecto),
int getVerticalAlignment() y LEFT. Para alineamiento vertical: TOP,
CENTER (por defecto), y BOTTOM.
Selecciona u obtiene dónde debería
void
situarse el texto del botón con respecto a
setHorizontalTextPosition(int)
la imagen. La clase AbstractButton
void
permite uno de los siguientes valores para
setVerticalTextPosition(int)
alineamineto horizontal: LEFT, CENTER
int
(por defecto), y LEFT. Para alineamiento
getHorizontalTextPosition()
vertical: TOP, CENTER (por defecto), y
int getVerticalTextPosition()
BOTTOM.
void setMargin(Insets) Selecciona u obtiene el número de pixels
Insets getMargin() entre el borde del botón y sus contenidos.
void
Selecciona u obtiene si el botón debería
setFocusPainted(boolean)
parecer diferente si obtiene el foco.
boolean isFocusPainted()
void
Selecciona u obtiene si el borde del botón
setBorderPainted(boolean)
debería dibujarse.
boolean isBorderPainted()

Implementa la funcionalidad del botón

Método o Constructor
void setMnemonic(char)
char getMnemonic()
void setActionCommand(String)
String getActionCommand(void)
void
addActionListener(ActionListener)
ActionListener
removeActionListener()
void
addItemListener(ItemListener)
ItemListener removeItemListener() por el botón.
void setSelected(boolean)
boolean isSelected()
Propósito
Selecciona la tecla alternativa para
pulsar el botón.
Selecciona u obtiene el nombre de la
acción realizada por el botón.
Añade o elimina un objeto que
escucha eventos action disparados
por el botón.
Añade o elimina un objeto que
escucha eventos items disparados
Selecciona u obtiene si el botón está
seleccionado. Tiene sentido sólo en

14
 botones que tienen un estado on/off,
como los checkbox.

El código para este programa está dado por 2 clases: Formulario y MiPanel.
El código de la clase Formulario fue dado en anteriores páginas, sin
embargo, el código de MiPanel es el siguiente:

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

class MiPanel extends JPanel implements ActionListener

{
// -------------------------------------------------------Para variables globales
JButton bV= new JButton("Víctor ",
new ImageIcon(getClass().getResource("images/V.gif")));
JButton bB= new JButton("Balta ",
new ImageIcon(getClass().getResource("images/B.gif")));
// ----------------------------------------------------------------------------------
public MiPanel()
{
bV.setMnemonic('V'); // Alt+V o Alt+v
bV.setFont(new Font("Arial", Font.PLAIN, 18));
bV.addActionListener(this);
add(bV);

bB.setMnemonic('B'); // Alt+B o Alt+b

bB.setFont(new Font("Arial", Font.PLAIN, 18));
bB.addActionListener(this);
add(bB);
}
// --------------------------------------------------------------------------Para eventos
public void actionPerformed(ActionEvent e)
{
if(e.getSource().equals(bV)) setBackground(Color.cyan);
if(e.getSource().equals(bB)) setBackground(Color.green);
}
}

Veamos :

15
 JButton JButton
JFrame

n
JPanel: FlowLayout
JPanel: BorderLayout

JTextArea
c

16
OBJETIVOS
 Comprender y utilizar los diferentes tipos de diseño en Swing.

 Crear diversos diseños de JFrame y distribución de objetos en el Frame.

1. Concepto:

Los layout managers o manejadores de composición, en traducción

literal, ayudan a adaptar los diversos Componentes que se desean
incorporar a un Panel, es decir, especifican la apariencia que tendrán los
Componentes a la hora de colocarlos sobre un Contenedor. Java
dispone de varios, en la actual versión, tal como se muestra en la
imagen:

17
a. FlowLayout

Es el más simple y el que se utiliza por defecto en todos los Paneles

si no se fuerza el uso de alguno de los otros. Los Componentes
añadidos a un Panel con FlowLayout se encadenan en forma de lista.
La cadena es horizontal, de izquierda a derecha, y se puede
seleccionar el espaciado entre cada Componente.

Código : Implemente la clase PanelFlowLayout

public class PanelFlowLayout extends JPanel {

JButton b1=new JButton("Boton 1");

JButton b2=new JButton("Boton 2");
JButton b3=new JButton("Boton 3");
JButton b4=new JButton("Boton 4");
JButton b5=new JButton("Boton 5");
JButton b6=new JButton("Boton 6");
JButton b7=new JButton("Boton 7");
JButton b8=new JButton("Boton 8");
JButton b9=new JButton("Boton 9");
public PanelFlowLayout() {
setLayout(new FlowLayout());
add(b1);
add(b2);
…….

18
 Formulario FlowLayout

public class FormularioFlowLayout extends JFrame{

static int wF=400,hF=300;
public FormularioFlowLayout(String s) {
super(s);
setContentPane(new PanelFlowLayout());
setLocation((getToolkit().getScreenSize().width -
wF)/2,(getToolkit().getScreenSize().height - hF)/2);
}
public static void main(String[] args) {
FormularioFlowLayout jf = new
FormularioFlowLayout("FlowLayout");
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
jf.setSize(wF,hF);
jf.setVisible(true);
}
}

b. BorderLayout
La composición BorderLayout (de borde) proporciona un esquema más
complejo de colocación de los Componentes en un panel. La
composición utiliza cinco zonas para colocar los Componentes sobre
ellas: Norte, Sur, Este, Oeste y Centro. Es el layout o composición que
se utilizan por defecto Frame y Dialog. El Norte ocupa la parte superior
del panel, el Este ocupa el lado derecho, Sur la zona inferior y Oeste el
lado izquierdo.

19
Diseñe la clase que implemente el BorderLayout.

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

public class PanelBorderLayout extends JPanel {

JButton sur =new JButton("Sur");

JButton norte =new JButton("Norte");
JButton este =new JButton("Este");
JButton oeste =new JButton("Oeste");
JButton centro =new JButton("Centro");
public PanelBorderLayout() {
setLayout(new BorderLayout());
add(sur,BorderLayout.SOUTH);
add(norte,BorderLayout.NORTH);
add(este, BorderLayout.EAST);
add(oeste, BorderLayout.WEST);
add(centro, BorderLayout.CENTER);
}
}

Cree el formulario que permita ver el layout asignado.

public class FormularioBorderLayout extends JFrame{

static int wF=400,hF=300;
public FormularioBorderLayout(String s) {
super(s);
add(new PanelBorderLayout());
setLocation((getToolkit().getScreenSize().width -
wF)/2,(getToolkit().getScreenSize().height - hF)/2);
}

20
 ACTIVIDAD
Implemente la clase GridLayout de tal forma que se mueste de la
siguiente manera:

21