Entornos Graficos

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ú
Fecha de entrega
Heroica Puebla de 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); /* Establece el tamaño de la ventana en

pixeles, (WIDTH, HEIGHT) */
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, 240);
ventanaPrinc.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
/*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 una ventana tipo

JDialog, que tiene funcionalidad más
limitada (sólo botón de cerrar) que se
muestra al inicio del programa como dice
en el código
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 el objeto en x, y

coordenadas de la ventana, y le da un tamaño w, h*/
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 = new JTextField(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
/**
* @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:



"campot1"

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 es el JTextArea creado con
color rojo de 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:



"campot1"

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 contenedor, para
ordenamiento*/
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 de contenido, para

optimizar como trabaja el texto que se introduce*/
jedit.setText("Hola mundo :D"); /* Campo de texto predeterminado al iniciar el

programa*/
jedit.setAutoscrolls(rootPaneCheckingEnabled);/* Bajar automaticamente el

cursor cuando el caption se sale del tamaño de la ventana de JEditorPane*/
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>"+
"hola " + "adios " +
"fuente arial " +

"fuente courier " +
"fuente grande " +

11
"color rojo ");
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:
JMenu menu1;
JMenuItem mi1,mi2,mi3;
13
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
setVisible(true);/* se cambia el estado del

frame a visible*/
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:
JMenu menu1;
14
menus*/

"Menu Feliz :)"*/
menu1.add(mi1);
menu1.add(mi2);
menu1.add(mi3);

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;

menus*/
menu3=new JMenu("Botones Radio");/* creacion de otro menu para la barra de

menus*/

"Menu Feliz :)"*/
menu2.add(mi1);
menu2.addSeparator();
menu2.add(mi2);
menu2.add(mi3);

/* 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.add(lista3);
//se repiten los pasos para otros elementos
JRadioButtonMenuItem Rboton1 = new JRadioButtonMenuItem("Boton de la radio");
JRadioButtonMenuItem Rboton2 = new JRadioButtonMenuItem("Radio 1");
menu3.add(Rboton1);
menu3.add(Rboton2);
menu3.add(Rboton3);
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");
JButton boton3 = new JButton("Click Por aca");
// 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");
JToggleButton boton6 = new JToggleButton("Boton mas mas largo");
JToggleButton boton7 = new JToggleButton("Boton mas mas mas larguisimo");
//JCheckBox, es una checkbox, se crea desactivada por defecto con una

etiqueta "Listo"
JCheckBox boton8 = new JCheckBox("Listo");
JCheckBox boton9 = new JCheckBox("Casi Listo");
JCheckBox boton10 = new JCheckBox("Listisismo");
//Creacion de JRadioButton, desactivado por defecto y con la etiqueta

proporcionada con el nombre en el constructor
JRadioButton boton11 = new JRadioButton("Radio 1");
//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 del Frame principal, valores de entrada son

booleanos true o false
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"));
//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/starcraft-

2-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

Entornos Graficos

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Entornos Graficos

Enviado por

Direitos autorais:

Formatos disponíveis

Benemérita Universidad Autónoma de Puebla

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

Es el conjunto de clases más básicas para la creación de interfaces gráficas.

A continuación se muestra un diagrama que ejemplifica los componentes base de

Por sus características, es la forma más conveniente de programar GUI’s en

A continuación explicaremos cada una de las clases y métodos que contiene

JFrame (String titulo, GraphicsConfiguration gc)

JFrame ventanaPrinc = new JFrame("Ventana Nueva :)"); /*Crea una instancia de

ventanaPrinc.setVisible(true); /* Alterna el estado de la ventana entre visible

ventanaPrinc.setSize(320, 240); /* Establece el tamaño de la ventana en

 EXIT_ON_CLOSE.- Cierra la ventana y todas las demás ventanas de la

que esten abiertas. Su valor numerico es 3

 DO_NOTHING_ON_CLOSE.-Con esto hacemos que nuestra ventana no se

cuando le damos click en el boton de cerrar. Su valor numérico

 DISPOSE_ON_CLOSE.-Cierra solamente la ventana activa, si tenemos mas

abiertas no se veran afectadas. Su valor numerico es 2

 HIDE_ON_CLOSE.-Con esto hacemos que al dar click en el boton cerrar

ventana y no cerrarla (ojo no es lo mismo cerrar que ocultar).

Su valor numerico es 1*/

Da como resultado una ventana con barra

JDialog (Frame owner, String title, boolean modal, GraphicsConfiguration gc)

JFrame ventanaPrinc = new JFrame("Ventana Nueva :)");

/*Ventana de dialogo creada junto con el JFrame principal, se muestra desde el

JDialog dialogoP = new JDialog(ventanaPrinc, "Dialogo :)"); /* Crea una ventana

dialogoP.setSize(200, 100); /* Como el JFrame, posee el mismo método para

dialogoP.setVisible(true); /* Se activa su visibilidad*/

Da como resultado una ventana tipo

JDialog dialogoP = new JDialog(ventanaPrinc, "Dialogo :)");

/* Ventana tipo JWindow creada y mostrada en el programa, colocada en cierta

JWindow ventana1 = new JWindow(ventanaPrinc); /* Crea un objeto y lo enlaza a

ventana1.setVisible(true); /* Lo pone como visible en la pantalla*/

ventana1.setBounds(800, 400, 300,300); /* Posiciona el objeto en x, y

Como se puede observar, el cuadrado gris es el JWindow creado, el cuál no se

public JTextField(Document doc, String text, int columns)

public class Pruebaparagui extends JFrame{

public Pruebaparagui(){/* Constructor de la clase principal que hereda a

super("Hola mundo");//Título de la ventana, llamando al constructor de JFrame

Container contenedor = getContentPane(); //Creación de un contenedor para

contenedor.setLayout(new FlowLayout());//Se establece el layout del container

JTextField campot1 = new JTextField(10);//Creación de un campo de texto

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();

Ventana creada con un Container y un

JTextField campot1 = new JTextField("Hola", 10);//Creación de un campo de texto

Ventana creada con un Container y un

JTextArea(String text, int rows, int columns)

super("Hola mundo");//Título de la ventana, llamando al constructor de JFrame

Container contenedor = getContentPane(); //Creación de un contenedor para

contenedor.setLayout(new FlowLayout());//Se establece el layout del container

JTextField campot1 = new JTextField("Hola", 10);//Creación de un campo de texto

contenedor.add(campot1);//Añadir el campo de texto a contenedor para que se

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

contenedor.add(texto1).setBackground(Color.red);//Asigna un color de fondo al