Vous êtes sur la page 1sur 21

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

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 Propósito
void setMnemonic(char) Selecciona la tecla alternativa para
char getMnemonic() pulsar el botón.
void setActionCommand(String) Selecciona u obtiene el nombre de la
String getActionCommand(void) acción realizada por el botón.
void
Añade o elimina un objeto que
addActionListener(ActionListener)
escucha eventos action disparados
ActionListener
por el botón.
removeActionListener()
void Añade o elimina un objeto que
addItemListener(ItemListener) escucha eventos items disparados
ItemListener removeItemListener() por el botón.
void setSelected(boolean) Selecciona u obtiene si el botón está
boolean isSelected() 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