Manuales seminario java-manualdejava-sem 3 - 4

1
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.
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.

2
Jerarquía de clases de Swing
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,
Object
Graphics
Component
TextComponent Container
TextField TextArea Window Panel ScrollPane
Frame Dialog
FileDialog
Canvas
Button
Choice
Checkbox
List
Scrollbar
Java.applet
Applet

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

4
Eventos para cerrar la ventana
JPanel
JButton
JFrame
JLabel
JFrame
JPanel
JButton JLabel
containers

5
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).

6
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);
}
}

7
2. Cree un formulario con una imagen centrada.
import java.awt.*;
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++;}
});
}
JFrame03 jf=new JFrame03("JFrame con eventos",300,200);
}
}

8
3. Cree un JFrame que muestre un botón el cual al pulsarlo indique
cuantas veces.
import java.awt.*;
int nveces=1;
JLabel label = new JLabel();
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));
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++;
}
});
}
JFrame03 jf=new JFrame03("JFrame con eventos",300,200);

9
4. Cree un Frame que muestre los dos tipos de botones:
import java.awt.*;
Button b1,b2,b3,b4;
JButton jb1,jb2,jb3;
super(nombre);
setLayout(null);
//creando componentes AWT
Button b1 = new Button("boton AWT 1");
//creando componentes Swing
JButton jb1 = new JButton("b Swing 1");
//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);

10
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:
//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);
}
// --- Creando componentes
JFrame04 jf=new JFrame04("Comparación de clases",500,400);
}
}

11
Para crear un JPanel
Método Propósito
JPanel()
JPanel(boolean)
JPanel(LayoutManager)
JPanel(LayoutManager,
boolean)
Crea un panel. Cuando está presente, el
parámetro boolean determina la estrategia de
buffer del panel. Un valor true indica doble
buffer. El parámetro LayoutManager
proporciona el controlador de distribución para el
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)
void add(Component,
int)
void add(Component,
Object)
void add(Component,
Object, int)
void add(String,
Component)
Añade el componente especificado al panel.
Cuando existe, el parámetro int es la posición o
índice del componente dentro del contenedor. El
parámetro Object depende del controlador de
distribución y normalmente proporciona
información sobre el posicionamiento y
restricciones de distribución cuando se añaden
componentes. El parámetro String proporciona
un nombre para el componente.
int
getComponentCount()
Obtiene el número de componentes en este
panel.
Component
getComponent(int)
Component
getComponentAt(int,
int)
Component
getComponentAt(Point)
Component[]
getComponents()
Obtiene el componente o componentes
especificados. Se pueden obtener basándose en
su índice, o en sus posiciones x,y.
void
remove(Component)
void remove(int)
void removeAll()
Elimina el componente o componentes
especificados.
Seleccionar/Obtener el Controlador de Distribución
Método Propósito
void Selecciona u obtiene el controlador de

12
setLayout(LayoutManager)
LayoutManager
getLayout()
distribución para este panel. El controlador de
distribución es el responsable de posicionar
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.
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
import java.awt.*;
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)
// {
// …
// }
}

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

14
Ajuste fino de la apariencia del botón
Método o constructor Propósito
void
setHorizontalAlignment(int)
void setVerticalAlignment(int)
int getHorizontalAlignment()
int getVerticalAlignment()
Selecciona u obtiene dónde debe situarse
el contenido del botón. La clase
AbstractButton permite uno de los
siguientes valores para alineamiento
horizontal: LEFT, CENTER (por defecto),
y LEFT. Para alineamiento vertical: TOP,
CENTER (por defecto), y BOTTOM.
void
setHorizontalTextPosition(int)
void
setVerticalTextPosition(int)
int
getHorizontalTextPosition()
int getVerticalTextPosition()
Selecciona u obtiene dónde debería
situarse el texto del botón con respecto a
la imagen. La clase AbstractButton
permite uno de los siguientes valores para
alineamineto horizontal: LEFT, CENTER
(por defecto), y LEFT. Para alineamiento
vertical: TOP, CENTER (por defecto), y
BOTTOM.
void setMargin(Insets)
Insets getMargin()
Selecciona u obtiene el número de pixels
entre el borde del botón y sus contenidos.
void
setFocusPainted(boolean)
boolean isFocusPainted()
Selecciona u obtiene si el botón debería
parecer diferente si obtiene el foco.
void
setBorderPainted(boolean)
boolean isBorderPainted()
Selecciona u obtiene si el borde del botón
debería dibujarse.
Implementa la funcionalidad del botón
Método o Constructor Propósito
void setMnemonic(char)
char getMnemonic()
Selecciona la tecla alternativa para
pulsar el botón.
void setActionCommand(String)
String getActionCommand(void)
Selecciona u obtiene el nombre de la
acción realizada por el botón.
void
addActionListener(ActionListener)
ActionListener
removeActionListener()
Añade o elimina un objeto que
escucha eventos action disparados
por el botón.
void
addItemListener(ItemListener)
ItemListener removeItemListener()
Añade o elimina un objeto que
escucha eventos items disparados
por el botón.
void setSelected(boolean)
boolean isSelected()
Selecciona u obtiene si el botón está
seleccionado. Tiene sentido sólo en

15
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:
Veamos :
import java.awt.*;
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);
}
}

16
n
JPanel: BorderLayout
c
JFrame
JPanel: FlowLayout
JButtonJButton
JTextArea

17
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:
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.

18
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");
public PanelFlowLayout() {
add(b1);
add(b2);
…….

19
Formulario FlowLayout
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.
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.setSize(wF,hF);
}
}

20
Diseñe la clase que implemente el BorderLayout.
Cree el formulario que permita ver el layout asignado.
import java.awt.BorderLayout;
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);
}
}
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);
}

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

Manuales seminario java-manualdejava-sem 3 - 4

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (19)

Destaque

Destaque (20)

Semelhante a Manuales seminario java-manualdejava-sem 3 - 4

Semelhante a Manuales seminario java-manualdejava-sem 3 - 4 (20)

Mais de Robert Wolf

Mais de Robert Wolf (20)

Manuales seminario java-manualdejava-sem 3 - 4