UNIVERSIDAD DE GUAYAQUIL

FACULTAD CIENCIAS Y MATEMATICAS

NOMBRES: ISAAC ANTONIO ORTIZ CABRERA
MATERIA: PROGRAMACION ORIENTADA A OBJETOS I FECHA: 03/02/ 2023
CURSO: MA 4-5 DOCENTE: ING. TORRES MARTINEZ DENNISSE EUGENIA

COMPONENTES GUI

Componentes GUI (widgets): Objetos visuales del interfaz - Un programa gráfico es un

conjunto de componentes anidados: • ventanas, contenedores, menús, barras, botones,
campos de texto, etc.

Componentes: Etiquetas, Botones, Campos, …

 Botón - Clase JButton

Botón de interacción que puede tener una etiqueta

 Menús - Clase JMenuBar, JMenu, y JMenuItem

Para definir una barra de menús, cada menú y los elementos de cada menú

Uso de componentes:

Botón - Clase JButton

1) Crear el componente

usando new:

JButton b = new JButton(“Correcto”);

2) Añadirlo al contenedor

usando add:

contentPane.add(b); // añadir en el contenedor contentPane

// crear y añadir el componente en una sóla operación:

contentPane.add(new Label(“Etiqueta 1”));

contentPane.add(new Label(“Etiqueta 2”));

Si luego se quiere quitar, usar remove(componente)

3) Invocar métodos sobre el componente y manejar eventos

System.out.println(b.getLabel());

b.setLabel(“etiqueta modificada”);

Creación de una barra de menús

private void makeMenuBar(JFrame frame) {

JMenuBar menubar = new JMenuBar();

frame.setJMenuBar(menubar);

// create the File menu

JMenu fileMenu = new JMenu("File");

menubar.add(fileMenu); // se añade a la barra de menús

JMenuItem openItem = new JMenuItem("Open");

fileMenu.add(openItem); // se añade al menú File

JMenuItem quitItem = new JMenuItem("Quit");

fileMenu.add(quitItem);

Textfield

Los campos de texto (JTextField) son componentes gráficos muy importantes en la

construcción de interfaces para cualquier tipo de aplicación en Java, nos permite
suministrarle al usuario un espacio donde colocar datos, para luego realizar diversas
actividades con dichos datos ingresados, en este artículo veremos como usar JTextField
en Java, haciendo uso de NetBeans como entorno de desarrollo integrado (IDE).

Primero que todo debemos definir las funcionalidades principales de un JTextField en

Java y estas son:

Obtener datos: Posibilidad para que el usuario escriba un valor solicitado.

Mostrar datos: Posibilidad de mostrar al usuario un valor

Si estamos haciendo uso de un IDE como NetBeans, solo debemos arrastrar el
componente JTextField o Campo de texto al Jframe o JDialog que estemos diseñando,
por otro lado si estamos trabajando sin IDE podemos crear el componente de la
siguiente forma:

private javax.swing.JTextField Campo1;

Campo1 = new javax.swing.JTextField();

¿Como obtener valores de un JTextField en Java?

Como citamos anteriormente, una de las funciones primordiales de este componente es
capturar datos que el usuario ingresa, esto lo hacemos por medio de variables.

String valor = Campo1.getText();

En el código anterior tendremos en la variable «valor«, el valor lo ingresado por el

usuario, hay que tener en cuenta que todo lo que escribimos en un JTextField es tratado
como texto, así sea que estemos ingresando números, serán tratados como texto.

¿Como usar números en los JTextField?

Para el uso de números debemos capturar los valores igual como hicimos anteriormente
con un String, luego debemos convertir ese valor al formato correspondiente, veamos:

String valor = Campo1.getText();

int valor_entero = Integer.parseInt(valor);
double valor_double = Double.parseDouble(valor);
float valor_float = Float.parseFloat(valor);

¿Como validar cuando un JTextField esta vacío?

Esta es una necesidad muy común en la programación de interfaces, evitar que el
usuario deje campos vacíos, esto se puede hacer de varias maneras, una podemos
validar las variables que capturan los valores de las JTextField o bien podemos validar
directamente las JTextField, veamos ambas formas.

Validando una variable que obtiene el valor de un JTextField

 String valor = Campo1.getText();
if (valor.equals("")) {
System.out.println("El campo 1 esta vacío");
}else{
System.out.println("El campo 1 esta lleno");
}

Validando directamente el JTextField

if (Campo1.getText().isEmpty()) {
System.out.println("El campo 1 esta vacio");
}else{
System.out.println("El campo 1 esta lleno");
}

Combos

JComboBox

El último componente del capítulo es el JComboBox, que nos permite seleccionar

un String de una lista.

Para inicializar los String que contendrá el JComboBox debemos llamar al

método addItem tantas veces como elementos queremos cargar.

Un evento muy útil con este control es cuando el operador selecciona un Item de la lista.
Para capturar la selección de un item debemos implementar la
interface ItemListener que contiene un método llamado itemStateChanged.

Ejemplo: Cargar en un JComboBox los nombres de varios colores. Al seleccionar

alguno mostrar en un JLabel el color seleccionado.

import javax.swing.*;

import java.awt.event.ItemEvent;

import java.awt.event.ItemListener;

public class Ejemplo12 extends JFrame implements ItemListener {

private JComboBox combo1;

private JLabel label1;

public Ejemplo12() {
//Añado el ComboBox con sus items y su ItemListener, así como la etiqueta

combo1=new JComboBox();

combo1.setBounds(10,10,80,20);

add(combo1);

combo1.addItem("ninguno");

combo1.addItem("rojo");

combo1.addItem("verde");

combo1.addItem("azul");

combo1.addItemListener(this);

label1 = new JLabel("Color seleccionado: ninguno");

label1.setBounds(10,80,200,30);

add(label1);

//Configurar y mostrar JFrame

initPantalla();

private void initPantalla() {

setLayout(null); //Layout absoluto

setTitle("Ejemplo 12"); //Título del JFrame

setSize(300, 200); //Dimensiones del JFrame

setResizable(false); //No redimensionable

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //Cerrar proceso al cerrar

ventana

setVisible(true); //Mostrar JFrame

public static void main(String[] args) {

new Ejemplo12();
}

public void itemStateChanged(ItemEvent e) {

String texto = "Color seleccionado: ";

if (e.getSource() == combo1) {

String seleccionado=(String)combo1.getSelectedItem();

texto += seleccionado;

label1.setText(texto);

cajas de diálogo

Cuadros de dialogo JOptionPane.

La forma más sencilla de crear ventanas gráficas en Java es utilizar cuadros de diálogo
JOptionPane. Estos son simples cajas de texto que aparecen en la pantalla y nos
permiten mostrar un mensaje o pedir un dato al ausuario o usuaria.

La clase de Java que se utiliza es JOptionPane y pertenece al paquete javax.swing.

Fijate que el nombre del paquete empieza por javax en vez de java. Esto es debido a que
en sus origenes Swing fue una extensión de las funcionalidades de Java.

Como veremos a continuación, JOptionPane se puede entender como un equivalente

gráfico simple del System.out.println y del Scanner que usamos para leer datos por
consola.

El siguiente código crea el programa "Hola mundo" pero mostrando el mensaje

mediante un objetoo de la clase JOptionPane:

import javax.swing.*;

public class HolaMundoGrafico {

public static void main(String[] args) {

JOptionPane.showMessageDialog(null, "Hola, Mundo!");

}
 Menus

No hay ningún método para diseñar un buen interfaz de usuario, todo depende del
programador. Los Menús son siempre el centro de la aplicación, porque son el medio de
que el usuario interactúe con esa aplicación. La diferencia entre una aplicación útil y
otra que es totalmente frustrante radica en la organización de los menús, pero eso, las
reglas del diseño de un buen árbol de menús no están claras. Hay un montón de libros
acerca de la ergonomía y de cómo se debe implementar la interacción con el usuario. Lo
cierto es que por cada uno que defienda una idea, seguro que hay otro que defiende la
contraria. Todavía no hay un acuerdo para crear un estándar, con cada Window
Manager se publica una guía de estilo diferente. Así que, vamos a explicar lo básico, sin
que se deba tomar como dogma de fe, para que luego cada uno haga lo que mejor le
parezca.

En Java, la jerarquía de clases que intervienen en la construcción y manipulación de

menús es la que se muestra en la lista siguiente:

java.lang.Object

MenuShorcut

java.awt.MenuComponent

java.awt.MenuBar

java.awt.MenuItem

java.awt.Menu

java.awt.CheckboxMenuItem

java.awt.PopMenu

MenuComponent, es la superclase de todos los Componentes relacionados con menús.

MenuShortcut, representa el acelerador de teclado, o la combinación de teclas rápidas, para acceder

a un MenuItem.

MenuItem, representa una opción en un menú.

Menu, es un Componente de una barra de menú.

MenuBar, encapsula el concepto de una barra de menú en un Frame.

Clase MenuComponent

Esta clase no contiene campos, solamente tiene un constructor y dispone de una docena
de métodos que están accesibles a todas sus subclases.

Clase Menu

Esta es la clase que se utiliza para construir los menús que se manejan habitualmente,
conocidos como menús de persiana (o pull-down). Dispone de varios constructores para
poder, entre otras cosas, crear los menús con o sin etiqueta. No tiene campos y
proporciona varios métodos que se pueden utilizar para crear y mantener los menús en
tiempo de ejecución. En el programa de ejemplo java1317.java, se usarán algunos de
ellos.

Clase MenuItem

Esta clase se emplea para instanciar los objetos que constituirán los elementos
seleccionables del menú. No tiene campos y dispone de varios constructores, entre los
que hay que citar a:

MenuItem( String, MenuShortcut );

que crea un elemento el menú con una combinación de teclas asociada para acceder
directamente a él. Esta clase proporciona una veintena de métodos, entre los que
destacan los que se citan ahora:

addActionListener( ActionListener )

que añade el receptor específico que va a recibir eventos desde esa opción del menú

removeActionListener( ActionListener )

contrario al anterior, por lo que ya no se recibirán eventos desde esa opción del menú

setEnabled( boolean )

indica si esa opción del menú puede estar o no seleccionable

isEnabled()

comprobación de si la opción del menú esta habilitada

Clase MenuShortcut

Esta clase se utiliza para instanciar un objeto que representa un acelerador de teclado, o
una combinación de teclas rápidas, para un determinado MenuItem. No tiene campos y
dispone de dos constructores.

Aparentemente, casi todas las teclas rápidas consisten en mantener pulsada la tecla
Control a la vez que se pulsa cualquier otra tecla. Uno de los constructores de esta clase:
MenuShortcut( int,boolean );

dispone de un segundo parámetro que indica si el usuario ha de mantener también

pulsada la tecla de cambio a mayúsculas (Shift). El primer parámetro es el código de la
tecla, que es el mismo que se devuelve en el campo keyCode del evento KeyEvent,
cuando se pulsa una tecla.

La clase KeyEvent define varias constantes simbólicas para estos códigos de teclas,
como son: VK_8, VK_9, VK_A, VK_B.

Clase MenuBar

No tiene campos, sólo tiene un constructor público, y es la clase que representa el

concepto que todo usuario tiene de la barra de menú que está presente en la mayoría de
las aplicaciones gráficas basadas en ventanas.

En el programa java1317.java, ilustra algunos de los aspectos que intervienen en los

menús. Es una aplicación que coloca dos menús sobre un objeto Frame. Uno de los
menús tiene dos opciones y el otro, tres. La primera opción del primer menú también
tiene asignada una combinación de teclas rápidas: Ctrl+Shift+K.

Cuando se selecciona un elemento del menú, éste genera un evento de tipo ActionEvent,
que presenta una línea de texto en pantalla indicando cuál ha sido el elemento del menú
que se ha seleccionado, por ejemplo:

% java java1317

java.awt.MenuItem[menuitem0,label=Primer Elemento del Menu A,

shortcut=Ctrl+Shift+K]

java.awt.MenuItem[menuitem1,label=Segundo Elemento del Menu A]

java.awt.MenuItem[menuitem0,label=Primer Elemento del Menu A,

shortcut=Ctrl+Shift+K]

java.awt.MenuItem[menuitem3,label=Segundo Elemento del Menu B]