Interfaces gráficas - Facultad de Ciencias de la Computación

Benemérita Universidad Autónoma de Puebla
Carrera
Ingeniería en Ciencias de la Computación
Asignatura
Programación II
Trabajo
Reporte de los entornos gráficos
Catedrático
José Andrés Vázquez Flores
Integrantes
Ricardo Camacho Garza
David Limón Cantú
Heroica Puebla de
Fecha de entrega
Zaragoza a 23 de Noviembre del 2012
1
INDICE
Contenido
Interfaces gráficas .......................................................... 3
AWT .......................................................................... 3
SWING ...................................................................... 4
JFrame ....................................................................... 5
JDialog ...................................................................... 6
JWindow ...................................................................... 6
JTextField ................................................................... 8
JTextArea .................................................................... 9
JPasswordField .............................................................. 10
JEditorPane ................................................................. 11
JTextPane: .................................................................. 12
JMenuBar y JMenu: ........................................................... 12
JMenuItem: .................................................................. 13
JPopupMenu: ................................................................. 14
JCheckBokMenuItem, JRadioButtonMenuItem y JSeparator: ....................... 16
Sub Ventanas: ............................................................... 24
JPanel ...................................................................... 24
2
Interfaces gráficas
Es el conjunto de componentes gráficos que facilitan la comunicación entre el
usuario y el programa, estos pueden ser:





Ventanas
Botones
Cuadros de diálogo
Campos de texto
Etc…
Estructura de las aplicaciones GUI
•Declarar una clase que herede de la superclase JFrame
•Declarar cada componente que hará parte de la GUI
•Dentro del método constructor, crear y organizar los componentes
•Declarar el método main
AWT:
Es el conjunto de clases más básicas para la creación de interfaces gráficas.
No provee componentes complejos.
A continuación se muestra un diagrama que ejemplifica los componentes base de
una interfaz gráfica creada con AWT:
3
Java implemente otra serie de clases, las cuales heredan a las clases de AWT,
las cuales permiten la creación de interfaces gráficas más complejas.
SWING:
Java Swing hereda las clases de AWT, pero incorpora métodos y clases más
avanzadas que facilitan la creación de interfaces gráficas, son fáciles de
identificar gracias al prefijo “J”.
Por sus características, es la forma más conveniente de programar GUI’s en
Java.
A continuación explicaremos cada una de las clases y métodos que contiene
SWING, ejemplificados en el siguiente diagrama:
4
JFrame
Sintaxis:
JFrame (String titulo, GraphicsConfiguration gc)
Ejemplo:
JFrame ventanaPrinc = new JFrame("Ventana Nueva :)"); /*Crea una instancia de
la clase JFrame llamada “ventanaPrinc” con el título “Ventana Nueva”.*/
ventanaPrinc.setVisible(true); /* Alterna el estado de la ventana entre visible
y no visible (TRUE o FALSE)*/
ventanaPrinc.setSize(320, 240);
pixeles, (WIDTH, HEIGHT) */
/*
Establece
el
tamaño
de
la
ventana
en
ventanaPrinc.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); /* Establece el
comportamiento de la ventana al presionar el botón cerrar o terminar la
aplicación, esto para que se cierre correctamente y sin errores*/
/*Parámetros de setDefaultCloseOperation:
 EXIT_ON_CLOSE.- Cierra la ventana y todas las demás ventanas de la
aplicacion
que esten abiertas. Su valor numerico es 3
 DO_NOTHING_ON_CLOSE.-Con esto hacemos que nuestra ventana no se
cierre
cuando le damos click en el boton de cerrar. Su valor numérico
es 0
 DISPOSE_ON_CLOSE.-Cierra solamente la ventana activa, si tenemos mas
ventanas
abiertas no se veran afectadas. Su valor numerico es 2
 HIDE_ON_CLOSE.-Con esto hacemos que al dar click en el boton cerrar
oculte la
ventana y no cerrarla (ojo no es lo mismo cerrar que ocultar).
Su valor numerico es 1*/
Da como resultado una ventana con barra
de titulo y botones para su control,
cerrar, minimizar, maximizar.
5
JDialog
Sintaxis:
JDialog (Frame owner, String title, boolean modal, GraphicsConfiguration gc)
Ejemplo:
JFrame ventanaPrinc = new JFrame("Ventana Nueva :)");
ventanaPrinc.setVisible(true);
ventanaPrinc.setSize(320,
ventanaPrinc.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
240);
/*Ventana de dialogo creada junto con el JFrame principal, se muestra desde el
inicio */
JDialog dialogoP = new JDialog(ventanaPrinc, "Dialogo :)"); /* Crea una ventana
de dialogo que pertenece a "ventanaPrinc" con el título "Dialogo :)"*/
dialogoP.setSize(200, 100); /* Como el JFrame, posee el mismo método para
asignar el tamaño de la ventana*/
dialogoP.setVisible(true); /* Se activa su visibilidad*/
Da como resultado
JDialog, que tiene
limitada (sólo botón
muestra al inicio del
en el código
una ventana tipo
funcionalidad más
de cerrar) que se
programa como dice
JWindow
Sintaxis:
JWindow (Window owner, GraphicsConfiguration gc)
Ejemplo:
6
JFrame ventanaPrinc = new JFrame("Ventana Nueva :)");
ventanaPrinc.setVisible(true);
ventanaPrinc.setSize(320, 240);
ventanaPrinc.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JDialog dialogoP = new JDialog(ventanaPrinc, "Dialogo :)");
dialogoP.setSize(200, 100);
dialogoP.setVisible(true);
/* Ventana tipo JWindow creada y mostrada en el programa, colocada en cierta
posición de la pantalla, se utizan las mismas clases de JFrame para mostrarla y
darle dimension*/
JWindow ventana1 = new JWindow(ventanaPrinc); /* Crea un objeto y lo enlaza a
"ventanaPrinc"*/
ventana1.setVisible(true); /* Lo pone como visible en la pantalla*/
ventana1.setBounds(800, 400, 300,300); /* Posiciona
coordenadas de la ventana, y le da un tamaño w, h*/
el
objeto
en
x,
y
Como se puede observar, el cuadrado gris es el JWindow creado, el cuál no se
puede mover, redimensionar ni cerrar a menos que se especifique, se muestra al
frente de la ventana JFrame principal, pero detrás de JDialog.
7
JTextField
Sintaxis:
public JTextField(Document doc, String text, int columns)
Ejemplo:
public class Pruebaparagui extends JFrame{
public Pruebaparagui(){/* Constructor de la clase principal que hereda a
JFrame, para construir la ventana principal y sus componentes*/
super("Hola mundo");//Título de la ventana, llamando al constructor de JFrame
Container contenedor = getContentPane(); //Creación de un contenedor para
contener el JTextField
contenedor.setLayout(new FlowLayout());//Se establece el layout del container
con respecto a la ventana
JTextField
"campot1"
campot1
=
new
JTextField(10);//Creación
de
un
campo
de
texto
contenedor.add(campot1);//Añadir el campo de texto a contenedor para que se
coloque en la ventana
setSize(320, 200);//tamaño de la ventana (w, h)
setVisible(true);//alterna el estado de la ventana a visible
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
Pruebaparagui aplicacion = new Pruebaparagui();
aplicacion.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
Ventana creada con un Container y un
JTextField de 10 columnas en la posición
asignada por el container
8
Si cambiamos el objeto de JTextField por:
JTextField campot1 = new JTextField("Hola", 10);//Creación de un campo de texto
//"campot1"
Ventana creada con un Container y un
JTextField de 10 columnas en la posición
asignada por el container, que tiene el
texto
asignado
“hola”
JTextArea:
Sintaxis:
JTextArea(String text, int rows, int columns)
Ejemplo:
super("Hola mundo");//Título de la ventana, llamando al constructor de JFrame
Container contenedor = getContentPane(); //Creación de un contenedor para
contener el JTextField
contenedor.setLayout(new FlowLayout());//Se establece el layout del container
con respecto a la ventana
JTextField campot1 = new JTextField("Hola", 10);//Creación de un campo de texto
"campot1"
contenedor.add(campot1);//Añadir el campo de texto a contenedor para que se
coloque en la ventana
setSize(320, 200);//tamaño de la ventana (w, h)
setVisible(true);//alterna el estado de la ventana a visible
JTextArea texto1 = new JTextArea("CampoTexto"); //Se crea un JTextArea
contenedor.add(texto1);//añade el JTextArea creado al contenedor principal de
la ventana
contenedor.add(texto1).setBackground(Color.red);//Asigna un color de fondo al
JTextField
9
CampoTexto
color
es el
rojo
JTextArea
de
creado con
fondo
JPasswordField
Es un derivado de JTextField con la diferencia de que lo que se introduce en
esta campo es de tipo password *****
Sintaxis:
JPasswordField(String text, int columns)
Ejemplo:
super("Hola mundo");//Título de la ventana, llamando al constructor de JFrame
Container contenedor = getContentPane(); //Creación de un contenedor para
contener el JTextField
contenedor.setLayout(new FlowLayout());//Se establece el layout del container
con respecto a la ventana
JTextField campot1 = new JTextField("Hola", 10);//Creación de un campo de texto
"campot1"
contenedor.add(campot1);//Añadir el campo de texto a contenedor para que se
coloque en la ventana
setSize(320, 200);//tamaño de la ventana (w, h)
setVisible(true);//alterna el estado de la ventana a visible
JTextArea texto1 = new JTextArea("CampoTexto"); //Se crea un JTextArea
contenedor.add(texto1);//añade el JTextArea creado al contenedor principal de
la ventana
contenedor.add(texto1).setBackground(Color.red);//Asigna un color de fondo al
JTextField
JPasswordField pass = new JPasswordField(10); /* Creación de JPasswordField con
tamaño de 10 columnas*/
10
contenedor.add(pass);/*
Se
añade
el
JPasswordField al
ordenamiento*/
contenedor,
para
Ventana
creada
con
un
JPassWordField, se observa que al
escribir se muestran * en lugar de
lo escrito.
JEditorPane:
Sintaxis:
public JEditorPane(String type, String text)
Ejemplo:
super("JEditorPane – Ejemplo.");
JEditorPane jedit;
jedit = new JEditorPane();/* Creacion de un nuevo JEditorPane*/
jedit.setContentType("text/html");/* Seteo del tipo
optimizar como trabaja el texto que se introduce*/
de
contenido,
para
jedit.setText("Hola mundo :D"); /* Campo de texto predeterminado al iniciar el
programa*/
jedit.setAutoscrolls(rootPaneCheckingEnabled);/*
Bajar automaticamente
cursor cuando el caption se sale del tamaño de la ventana de JEditorPane*/
el
add(jedit);/* Añadiendo a jframe el jedit para armar la ventana*/
setSize(320,240);/* seteo del tamaño de la ventana (w, h)*/
setVisible(true);/* Cambiar su estado a visible*/
jedit.setText( /* Seteo de texto inicial con formato HTML*/
"<head><base href=\"file:d:/\"></head>"+
"<b>hola</b><br>" + "<i>adios</i><br>" +
"<font face=\"arial\">fuente arial</font><br>" +
"<font face=\"courier\">fuente courier</font><br>" +
"<font size=\"24\">fuente grande</font><br>" +
11
"<font color=\"red\">color rojo</font><br>");
JeditorPane creado, similar a JFrame, con
la diferencia que está compuesto por un
campo de entrada de texto para el usuario.
Ideal para editores de texto, html,
documentos
etc…
JTextPane:
Sintaxis:
JTextPane(StyledDocument doc);
Ejemplo:
// Se instancia el JTextPane
JTextPane editor = new JTextPane();
editor.getStyledDocument();
add(editor);
JButton boton = new JButton("Botón feliz :D");
editor.insertComponent(boton);
Crea un JtextPane, que es como el
JeditorPane pero con la posibilidad de
poder insertar objetos como botones dentro
del
área
de
texto,
con
formato
personalizado
JMenuBar y JMenu:
Sintaxis:
JMenuBar() //sin argumentos de entrada para el constructor
12
public JMenu(String s, boolean b)
Ejemplo:
super("Prueba de JMenuBar");
setLayout(null);/* se le asigna null al layout de la ventana*/
mb=new JMenuBar();/* se crea un nuevo objeto tipo JMenuBar para contener a los
menus del programa*/
setJMenuBar(mb);/* es establece una barra de menus "mb" para el frame*/
menu1=new JMenu("Opciones"); /* Se crea un menu para el menu bar "opciones"*/
mb.add(menu1);/* se añade el menu "opciones" a la barra de menus creada*/
setBounds(10, 20, 300, 200);/* el frame principal se redimensiona y coloca en
ciertas coordenadas*/
setVisible(true);/* se cambia el estado del frame a visible*/
setDefaultCloseOperation(EXIT_ON_CLOSE);
Ventana creada con unJMenuBar y un JMenu
“Opciones”, para notar su implementación y
como se ve el resultado, el menú Opciones no
despliega nada.
JMenuItem:
Sintaxis:
public JMenuItem(String text, int mnemonic)
Ejemplo:
super("Prueba de JMenuBar");
JMenu menu1;
JMenuItem mi1,mi2,mi3;
setLayout(null);/* se le asigna null al layout de la ventana*/
mb=new JMenuBar();/* se crea un nuevo objeto tipo JMenuBar para contener a los
menus del programa*/
setJMenuBar(mb);/* es establece una barra de menus "mb" para el frame*/
menu1=new JMenu("Opciones"); /* Se crea un menu para el menu bar "opciones"*/
13
mb.add(menu1);/* se añade el menu "opciones" a la barra de menus creada*/
menu1=new JMenu("Menu Feliz :)");/* creacion de otro menu para la barra de
menus*/
mb.add(menu1);/* se añade este menu a la barra de menus "mb"*/
mi1=new JMenuItem("opcion1");/* Creacion de un submenu que se añade al menu
"Menu Feliz :)"*/
menu1.add(mi1);
mi2=new JMenuItem("opcion2");/* Lo mismo con este*/
menu1.add(mi2);
mi3=new JMenuItem("opcion3");/* Y este*/
menu1.add(mi3);
setBounds(10, 20, 300, 200);/* el frame
principal se redimensiona y coloca en
ciertas coordenadas*/
setVisible(true);/* se cambia el estado del
frame a visible*/
setDefaultCloseOperation(EXIT_ON_CLOSE);
Al crear JMenuItem y añadirlos a algún JMenu, al dar click sobre ese menú, se
despliega una lista con las opciones dadas en el código.
JPopupMenu:
Sintaxis:
JPopupMenu() //sin argumentos de entrada
Ejemplo:
super("Prueba de JMenuBar");
JMenu menu1;
JMenuItem mi1,mi2,mi3;
setLayout(null);/* se le asigna null al layout de la ventana*/
mb=new JMenuBar();/* se crea un nuevo objeto tipo JMenuBar para contener a los
menus del programa*/
setJMenuBar(mb);/* es establece una barra de menus "mb" para el frame*/
menu1=new JMenu("Opciones"); /* Se crea un menu para el menu bar "opciones"*/
mb.add(menu1);/* se añade el menu "opciones" a la barra de menus creada*/
14
menu1=new JMenu("Menu Feliz :)");/* creacion de otro menu para la barra de
menus*/
mb.add(menu1);/* se añade este menu a la barra de menus "mb"*/
mi1=new JMenuItem("opcion1");/* Creacion de un submenu que se añade al menu
"Menu Feliz :)"*/
menu1.add(mi1);
mi2=new JMenuItem("opcion2");/* Lo mismo con este*/
menu1.add(mi2);
mi3=new JMenuItem("opcion3");/* Y este*/
menu1.add(mi3);
setBounds(10, 20, 300, 200);/* el frame principal se redimensiona y coloca en
ciertas coordenadas*/
setVisible(true);/* se cambia el estado del frame a visible*/
setDefaultCloseOperation(EXIT_ON_CLOSE);
JPopupMenu pmenu = new JPopupMenu();// declaracion de un menu contextual, no
tiene argumentos de entrada
JMenuItem s1 = new JMenuItem("sorpresa1");//creacion de un elemento del menu
contextual, el primero que aparece al dar clic derecho
pmenu.add(s1);//añadir el elemento al menu
//se repite para los siguientes 3 elementos
JMenuItem s2 = new JMenuItem("sorpresa2");
pmenu.add(s2);
JMenuItem s3 = new JMenuItem("sorpresa3");
pmenu.add(s3);
JMenuItem s4 = new JMenuItem(":D");
pmenu.add(s4);
//se enlaza el menu contextual a un elemento de la interfaz, solo se activa
ahí, en este caso la barra de menu
mb.setComponentPopupMenu(pmenu);
Menú contextual mostrado al presionar clic
derecho, con los elementos antes creados
15
JCheckBokMenuItem, JRadioButtonMenuItem y JSeparator:
Sintaxis:
public JCheckBoxMenuItem(String text, Icon icon, boolean b)
public JRadioButtonMenuItem(String text, Icon icon, boolean selected)
public JSeparator(int orientation) //la orientacion en la que se dibujará el
separador, puede ser: SwingConstants.HORIZONTAL o SwingConstants.VERTICAL
Ejemplo:
JMenu menu1,menu2,menu3;
JMenuItem mi1,mi2,mi3;
setLayout(null);/* se le asigna null al layout de la ventana*/
mb=new JMenuBar();/* se crea un nuevo objeto tipo JMenuBar para contener a los
menus del programa*/
setJMenuBar(mb);/* es establece una barra de menus "mb" para el frame*/
menu1=new JMenu("Opciones"); /* Se crea un menu para el menu bar "opciones"*/
mb.add(menu1);/* se añade el menu "opciones" a la barra de menus creada*/
menu2=new JMenu("Menu Feliz :)");/* creacion de otro menu para la barra de
menus*/
mb.add(menu2);/* se añade este menu a la barra de menus "mb"*/
menu3=new JMenu("Botones Radio");/* creacion de otro menu para la barra de
menus*/
mb.add(menu3);/* se añade este menu a la barra de menus "mb"*/
mi1=new JMenuItem("opcion1");/* Creacion de un submenu que se añade al menu
"Menu Feliz :)"*/
menu2.add(mi1);
menu2.addSeparator();
mi2=new JMenuItem("opcion2");/* Lo mismo con este*/
menu2.add(mi2);
menu2.addSeparator();
mi3=new JMenuItem("opcion3");/* Y este*/
menu2.add(mi3);
setBounds(10, 20, 300, 200);/* el frame principal se redimensiona y coloca en
ciertas coordenadas*/
setVisible(true);/* se cambia el estado del frame a visible*/
/* creacion de elementos de menu tipo checkbox, con nombre*/
16
JCheckBoxMenuItem lista1 = new JCheckBoxMenuItem("Nombres");
JCheckBoxMenuItem lista2 = new JCheckBoxMenuItem("Apellidos");
JCheckBoxMenuItem lista3 = new JCheckBoxMenuItem("Recibos");
/* añadiendo los elementos a un menu de la barra*/
menu1.add(lista1);// como parametro se pone el menu al que se agregaran
menu1.addSeparator();//añadir JSeparator
menu1.add(lista2);
menu1.addSeparator();
menu1.add(lista3);
//se repiten los pasos para otros elementos
JRadioButtonMenuItem Rboton1 = new JRadioButtonMenuItem("Boton de la radio");
JRadioButtonMenuItem Rboton2 = new JRadioButtonMenuItem("Radio 1");
JRadioButtonMenuItem Rboton3 = new JRadioButtonMenuItem("Radio 2");
JRadioButtonMenuItem Rboton4 = new JRadioButtonMenuItem("Radio 3");
menu3.add(Rboton1);
menu3.addSeparator();
menu3.add(Rboton2);
menu3.addSeparator();
menu3.add(Rboton3);
menu3.addSeparator();
menu3.add(Rboton4);
Ejemplo de JCheckBoxMenuItem con separadores
resultante del código
Ejemplo
de
JRadioButtonMenuItem
con
separadores resultante del código
17
WIDGETS
Sintaxis:
public JButton(String text, Icon icon);
public JToggleButton(String text, Icon icon, boolean selected);
public JCheckBox(String text, Icon icon, boolean selected);
public JRadioButton(String text, Icon icon, boolean selected);
public JComboBox();
public JLabel();
public JList();
public JTree(TreeModel newModel);
public JToolBar(String name, int orientation);
public JTable();
public JScrollBar();
public JSlider()
public JToolTip();
public JProgressBar();
Ejemplo:
super("Hola mundo Botones");
Container contenedor = getContentPane();
contenedor.setLayout(new FlowLayout());
setSize(640, 480);
setVisible(true);
//creacion de un boton JButton como parametro el texto a mostrar en el
botón
JButton boton1 = new JButton("Click Aqui");
contenedor.add(boton1);
JButton boton2 = new JButton("Click Aca");
contenedor.add(boton2);
JButton boton3 = new JButton("Click Por aca");
contenedor.add(boton3);
// crear un JToggleButton tipo switch que tiene similares propiedades a
JButton :D
18
JToggleButton boton4 = new JToggleButton("Boton Largo");
contenedor.add(boton4);//añadir el botón al contenedor del Frame principal
JToggleButton boton5 = new JToggleButton("Boton mas largoo");
contenedor.add(boton5);
JToggleButton boton6 = new JToggleButton("Boton mas mas largo");
contenedor.add(boton6);
JToggleButton boton7 = new JToggleButton("Boton mas mas mas larguisimo");
contenedor.add(boton7);
//JCheckBox, es una checkbox, se crea desactivada por defecto con una
etiqueta "Listo"
JCheckBox boton8 = new JCheckBox("Listo");
contenedor.add(boton8);
JCheckBox boton9 = new JCheckBox("Casi Listo");
contenedor.add(boton9);
JCheckBox boton10 = new JCheckBox("Listisismo");
contenedor.add(boton10);
//Creacion de JRadioButton, desactivado por defecto y con la etiqueta
proporcionada con el nombre en el constructor
JRadioButton boton11 = new JRadioButton("Radio 1");
contenedor.add(boton11);
JRadioButton boton12 = new JRadioButton("Radio 2");
contenedor.add(boton12);
JRadioButton boton13 = new JRadioButton("Radio 3");
contenedor.add(boton13);
//Creacion de una barra JSlider en las coordenadas x, y, con tamaño w, h
JSlider barra = new JSlider(0, 0, 300, 10);
contenedor.add(barra);
JSlider barra2 = new JSlider(0, 0, 300, 10);
contenedor.add(barra2);
//Leyenda de ayuda de los botones al poner el cursor sobre cada botón, una
propiedad de JButton, radio button y checkbox
boton1.setToolTipText("Que quieres aqui!!!");
19
boton2.setToolTipText("jajajajajajaja");
boton3.setToolTipText("Ayudaaaa Belmonth");
//declaración de un combo box (lista de opciones desplegable)
JComboBox combo1 = new JComboBox();
//colocación en el frame, coordenadas x, y, w, h
combo1.setBounds(50,100,80,20);
add(combo1);
//añadir item a la ista con el método addItem, como parámetro se pone el
texto a mostrar para la opcion
combo1.addItem("rojo");
combo1.addItem("vede");
combo1.addItem("azul");
combo1.addItem("amarillo");
combo1.addItem("negro");
//creacion de jlabel, colocacion y dimensionamiento
JLabel label1=new JLabel("Sistema de Facturación.");
label1.setBounds(10,140,300,30);
//añador a contenedor la jlabel creada
contenedor.add(label1);
JLabel label2=new JLabel("Vesion 1.0");
label2.setBounds(10,150,100,30);
contenedor.add(label2);
//Crear una JList, que almacena un listado de entradas por medio de un
arreglo de String
String[] entries = { "Entry 1", "Entry 2", "Entry 3",
"Entry 4", "Entry 5", "Entry 6" };
//Crear el Jlist con parametro de entrada el arreglo de string "entries"
JList sampleJList = new JList(entries);
//Establecer el numero de elementos visibles en el JList
sampleJList.setVisibleRowCount(4);
//Poner la fuente, tipo y tamaño de la misma a mostrar para los elementos
de la lista
20
Font displayFont = new Font("Serif", Font.BOLD, 18);
//activar la fuente establecida por el objeto Font en la clase setFont
sampleJList.setFont(displayFont);
//instanciado de la clase JScrollPane con parametro de entrada de una JList
para llenar los elementos de la misma
JScrollPane listPane = new JScrollPane(sampleJList);
//Creacion de un nuevo JPanel que contiene otro widget
JPanel listPanel = new JPanel();
//asignación del color de fondo con la clase Color
listPanel.setBackground(Color.white);
//Asignar el borde con nombre "Sample Jlist"
Border listPanelBorder = BorderFactory.createTitledBorder("Sample JList");
listPanel.setBorder(listPanelBorder);
//añadir el borde creado a listPanel, el JPanel creado anteriormente
listPanel.add(listPane);
//añadir el JPanel al Container del frame principal, centrado
contenedor.add(listPanel, BorderLayout.CENTER);
//creacion de elementos para un campo de texto con etiqueta y borde, con
fondo blanco }
//creando JLabel
JLabel valueLabel = new JLabel("Last Selection:");
valueLabel.setFont(displayFont);
//Asignar el valor a un JText field al momento de creación, sus argumentos
son el nombre que contiene (datos que se muestran al peincipio) y el tamaño de
columnas que mide
JTextField valueField = new JTextField("None", 7);
//Asignar la fuente para dibujar el campo de texto
valueField.setFont(displayFont);
//Creacion de un JPanel, sin argumentos de entrada
JPanel valuePanel = new JPanel();
//Asignación del color de fondo del panel, es opcional, se le manda un
objeto Color
valuePanel.setBackground(Color.white);
21
//Asignar el nombre de la etiqueta del borde creado con el constructor de
ValuePanelBorder, que tiene como argumento una clase de BorderFactory que
regresa y asigna en la posición superor de
Border valuePanelBorder =
BorderFactory.createTitledBorder("JList Selection");
//Asignacion de un borde a JPanel, con esto los dos se juntan y el borde se
dibuja alrededor del jPanel con la etiqueta y color previamente asignados, el
valor de entrada de este método es un objeto tipo Border
valuePanel.setBorder(valuePanelBorder);
//Se añade al JPanel el JTextField y el JLabel para que formen parte del
mismo
valuePanel.add(valueLabel);
valuePanel.add(valueField);
//añadir al contenedor del frame principal el JPanel creado y alinearlo a
la izquierda
contenedor.add(valuePanel, BorderLayout.SOUTH);
//Activar la visibilida
booleanos true o false
del
Frame
principal,
valores
de
entrada
son
setVisible(true);
//Creacion
de
un
JTree,
primero
es
necesario
crear
un
DefaultMutableTreeNode que contenga a todos los hijos que aparecerán en la
lista
DefaultMutableTreeNode abuelo = new DefaultMutableTreeNode("abuelo");
//Creación de DefaultTreeModel necesario para instanciar un JTree, el cual
será el padre de todos los nodos que se creen después de instanciar el JTree
DefaultTreeModel modelo = new DefaultTreeModel(abuelo);
//Instanciado de JTree, con argumento DefaultTreeModel explicado más arriba
JTree tree = new JTree(modelo);
//Creación de nodos para la lista del arbol
DefaultMutableTreeNode padre = new DefaultMutableTreeNode("padre");
DefaultMutableTreeNode tio = new DefaultMutableTreeNode("tio");
DefaultMutableTreeNode hijo=new DefaultMutableTreeNode("hijo");
DefaultMutableTreeNode hija=new DefaultMutableTreeNode("hija");
//se añade al contenedor del frame principal el objeto JTree creado
contenedor.add(tree);
22
//Inserta los nodos del arbol, argumentos DefaultMutableTreeNode (el nodo
arbol necesario que será el "hijo" o sub categoria de lo que se inserte),
DefaultMutableTreeNode que será el padre de lo que se inserte y el índice del
orden en el que se colocará
modelo.insertNodeInto(padre,abuelo,0);
modelo.insertNodeInto(tio, abuelo, 1);
modelo.insertNodeInto(hijo, padre, 0);
modelo.insertNodeInto(hija, padre, 1);
//Creación de barra de herramients JToolBar, no tiene argumentos de entrada
JToolBar barraBotones = new JToolBar();
//Es posible añadir widgets dentro de esta barra, por medio del método add,
como argumento pide un widget, el cual puede ser instanciado dentro de los
parámetros o introducido de alguno declarado anteriormente
barraBotones.add(new JButton("1"));
barraBotones.add(new JButton("2"));
barraBotones.add(new JButton("3"));
barraBotones.add(new JButton("4"));
barraBotones.add(new JButton("5"));
//se añade el JToolBar al contenedor del frame principal
contenedor.add(barraBotones);
//Creación de un JScrollBar, no tiene argumentos de entrada para crearse,
tiene varios métodos para introducirse en donde sea necesaria una barra de
desplacamiento, en este ejemplo sólo se enseña como instanciar
JScrollBar scrollBar = new JScrollBar();
//se añade el scrollBar a el contenedor del frame principal
contenedor.add(scrollBar);
//Se crea una barra de progreso,
JProgressBar Pbarra = new JProgressBar(0, 10);
//añade al contenedor principal la barra de progreso
contenedor.add(Pbarra);
// asignacion de color de fondo de la barra de progreso para simular que
está
llena
Pbarra.setBackground(Color.blue);
23
Sub Ventanas:
JPanel:
Sintaxis:
JPanel(LayoutManager layout, boolean isDoubleBuffered);
Ejemplo:
super( "Demostración JPanel" );
// obtener panel de contenido
Container contenedor = getContentPane();
//crear un arreglo de JButton (botones)
botones = new JButton[ 5 ];
// configurar panel y establecer su esquema
panelBotones = new JPanel();
24
panelBotones.setLayout( new GridLayout( 1, botones.length ) );
// crear y agregar botones por medio de un for, para que los coloque en
orden de izquierda a derecha
for ( int cuenta = 0; cuenta < botones.length; cuenta++ ) {
botones[ cuenta ] = new JButton( "Botón " + ( cuenta + 1 ) );
panelBotones.add( botones[ cuenta ] );
}
//añadir el JPanel de botones al frame principal, organizados al norte
del container (arriba)
contenedor.add( panelBotones, BorderLayout.NORTH );
//poner la dimension de la ventana
setSize( 425, 150 );
//cambiar el estado de la ventana a visible
setVisible( true );
JScrollPane
Sintaxis:
JScrollPane(int vsbPolicy, int hsbPolicy);
Ejemplo:
// La ventana
JFrame ventana = new JFrame("Imagen");
// El panel de scroll
JScrollPane scroll = new JScrollPane();
// La etiqueta.
JLabel etiqueta = new JLabel();
25
// Se carga la imagen, con path absoluto para evitar problemas y debe
// ser un gif.
Icon imagen = new ImageIcon ("C:/Users/David/Pictures/Iconos/starcraft2-13.png");
// Se mete la imagen en el label
etiqueta.setIcon (imagen);
// Se mete el scroll en la ventana
ventana.getContentPane().add(scroll);
// Se mete el label en el scroll
scroll.setViewportView(etiqueta);
// Y se visualiza todo.
ventana.pack();
ventana.setVisible(true);
26