Reporte de Practicas Tap - Carmona Cobaxin y Vichi Ortiz

INSTITUTO TECNOLÓGICO DE SAN
ANDRÉS TUXTLA
INGENIERÍA EN SISTEMAS COMPUTACIONALES
MATERIA:
Tópicos Avanzados de Programación
DOCENTE:
MTI. ANGELINA MÁRQUEZ JIMÉNEZ.
GRUPO:
404- A
REPORTE DE PRÁCTICA No. 1
INTEGRANTES:
ANGEL DE JESUS CARMONA COBAXIN

ALEJANDRA DEL CARMEN VICHI ORTIZ
PERIODO:
ENERO – JULIO 2021

INSTITUTO TECNOLÓGICO SUPERIOR DE SAN
ANDRÉS TUXTLA
REPORTE DE PRÁCTICA TOPICOS AVANZADOS DE PROGRAMACIÓN
PRÁCTICA NO. 1
NOMBRE DE LA PRÁCTICA:
GUI con implementación de listener de teclado
OBJETIVO:
El estudiante desarrollara una GUI que incluya la implementación de listener y

adaptador de mouse, para aprender a utilizar algunos de sus eventos.
FUNDAMENTO TEÓRICO:
La interfaz de usuario es la parte del programa que permite al usuario interaccionar

con él. La API de Java proporciona una biblioteca de clases para el desarrollo de
Interfaces gráficas de usuario (en realidad son dos). La biblioteca proporciona un
conjunto de herramientas para la construcción de interfaces gráficas que tienen una
apariencia y se comportan de forma semejante en todas las plataformas en las que
se ejecuten.
La estructura básica de la biblioteca gira en torno a componentes y contenedores.

Los contenedores contienen componentes y son componentes a su vez, de forma
que los eventos pueden tratarse tanto en contenedores como en componentes. La
API está constituida por clases, interfaces y derivaciones. Component: superclase
de todas las clases de interfaz gráfica.
Al implementar la interface debemos implementar también los métodos que la

componen, veamos cuales son y su funcionamiento básico:
ANDRÉS TUXTLA
• keyPressed(KeyEvent e): Se ejecuta cuando el usuario presiona una tecla.

• keyReleased(KeyEvent e): Se ejecuta cuando el usuario libera una tecla
• keyTyped(KeyEvent e): Se ejecuta cuando el usuario presiona una tecla,
pero solo cuando la tecla corresponde a caracteres, teclas especiales como
F1, F2 entre otras no son identificadas.
Por lo regular el uso de estos métodos es muy específico todo depende de lo que
necesitemos ya que el evento de presionar y soltar pasa muy rápido y casi nunca
nos damos cuenta cual evento se ejecutó, estos métodos son usados básicamente
cuando queremos controlar al detalle lo que queremos que suceda si se hace una
u otra acción.
El desarrollo de GUI puede, fácilmente, convertirse en un proceso caótico. La

dinámica del interfaz (Listeners de los eventos de ratón/teclado), están tienen que
tener acceso a las variables de estado y a los componentes para pintar los
resultados.
AWT permite hacer interfaces gráficas mediante artefactos de interacción con el

usuario, como botones, menús, texto, botones para selección, barras de
deslizamiento, ventanas de diálogo, selectores de archivos, etc. Y por supuesto
despliegue gráfico general. La siguiente figura muestra algunos de estos artefactos
de interacción: Estos artefactos de interacción se denominan widgets.
JERARQUIA DE LAS CLASES DE LA GUI

Container: para agrupar componentes.
JComponent: superclase de todos los componentes de Swing que se dibujan

directamente en los lienzos (canvas). Sus subclases son los elementos básicos de
la GUI.
ANDRÉS TUXTLA
JFrame: ventana que no está contenida en otras ventanas.
JDialog: cuadro de diálogo.
JApplet: subclase de Applet para crear applets tipo Swing.
JPanel: contenedor invisible que mantiene componentes de interfaz y que se puede

anidar, colocándose en otros paneles o en ventanas. También sirve de lienzo.
Graphics: clase abstracta que proporciona contextos gráficos donde dibujar

cadenas de texto, líneas y otras formas sencillas.
Color: color de los componentes gráficos.
Font: aspecto de los caracteres.
FontMetrics: clase abstracta para propiedades de las fuentes.
Categorías de clases:
• Contenedores:
JFrame, JApplet, JWindow, JDialog
• Componentes intermedios:
JPanel, JScrollPane
• Componentes:
JLabel, JBbutton, JTextField, JTextArea, ...
• Clases de soporte:
Graphics, Color, Font.

ANDRÉS TUXTLA
JAVA SWING
Swing es una biblioteca de clases que permite crear interfaces gráficas de usuario
en Java. Swing forma parte del paquete estándar, no hace falta importar ningún
fichero adicional en nuestros proyectos. Es una de las API de JFC (Java Foundation
Classes): AWT, Java 2D, Accessibility, Drag and Drop, Swing.
Escrito totalmente en Java. No reemplaza a AWT. Se apoya sobre AWT y añade
JComponents. Utiliza el modelo de eventos de Java 1.1. Elección entre diferentes

aspectos (look & feel). Arquitectura Model-View- Controller (MVC). Nuevos
componentes (árboles, tablas, frames internos, iconos, bordes, tooltips,
beans,etcétera).
MATERIAL Y EQUIPO EMPLEADO:
Equipo: Lenovo Ideapad S340
Procesador: AMD Ryzen 5 - 3500U
Almacenamiento: 8 GB RAM y 256 GB SSD
Arquitectura: 64 bits
DESARROLLO:
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class DemostracionTeclas extends JFrame implements KeyListener{
ANDRÉS TUXTLA
//nombre de la clase
private String linea1 = "", linea2 = "", linea3 = "";

private JTextArea areaTexto;
//configurar la GUI
public DemostracionTeclas(){
super("Demostracion de eventos de pulsacion de teclas");
areaTexto = new JTextArea(10,15);
areaTexto.setText("Oprima cualquier tecla"); //muestra el mensaje para
que el usuario pueda oprimir cualquiera tecla
areaTexto.setEnabled(false);
areaTexto.setDisabledTextColor(Color.red);
areaTexto.setBackground(Color.yellow);
getContentPane().add(areaTexto);
addKeyListener(this);
setSize(650,400);
setVisible(true);
}
public static void main(String []args){ //método principal
JFrame.setDefaultLookAndFeelDecorated(true);
DemostracionTeclas aplicacion = new DemostracionTeclas();
aplicacion.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //cierre
de la ventana
}
public void keyPressed (KeyEvent evento){ //método que se ejecutara cada

que se presione una tecla
ANDRÉS TUXTLA
linea1 = "Se oprimio la tecla: "+

evento.getKeyText(evento.getKeyCode());
establecerLineas2y3(evento);
}
public void keyReleased(KeyEvent ev){ //método que se ejecutara cada
que se suelte una tecla
linea1 = "se solto tecla: " + ev.getKeyText(ev.getKeyCode());

establecerLineas2y3 (ev);
}
public void keyTyped(KeyEvent ev){ //método que se ejecutara cada que se
precione una tecla especial
linea1 = "Se escribio la tecla: "+ ev.getKeyChar();

establecerLineas2y3 (ev);
}
private void establecerLineas2y3 (KeyEvent ev){
linea2 = "Esta tecla: "+ (ev.isActionKey()?"":" no ") + "es una tecla de
accion";
String temp = ev.getKeyModifiersText(ev.getModifiers());
linea3 = "Teclas modifcadora oprimidas : "+
(temp.equals("")?"nunguna":temp);
areaTexto.setText(linea1+"\n"+linea2+"\n"+linea3+"\n");
}
}
ANDRÉS TUXTLA
RESULTADOS:
El programa nos muestra una

interfaz gráfica de interacción
creando un programa el cual le
permita la usuaria ver la tecla se
oprimió y cuál es la función que
realiza haciendo uso de nuevos
eventos los cuales se describirán
a lo largo de la descripción del
programa.
En el segundo método de la
interface, que se invoca cuando el
usuario ha liberado una tecla. En
la línea uno se muestra el
mensaje de que se soltó una tecla
entonces se vuelve a obtener el
código, este trabajo lo hace el
método getKeyCode() que es el
que consigue el código de la letra
y el método getKeyText es el que
traduce dicho código de la letra.
Por último, se imprime el mensaje
completo de la letra que se ha
ANDRÉS TUXTLA
soltado.
En KeyReleased lo que hacemos
es validar el evento cuando se
presiona la tecla Escape para salir
del sistema, al presionar la tecla se
carga el mensaje. Adicional a esto
también imprimimos en consola
cual es la tecla presionada, de esta
manera nos damos cuenta cada
espacio, enter, delete y cualquier
tecla que utilicemos.
Cuando nos identifica una tecla de

acción, nuestro método que
utilizamos para hacer esa acción
es un (ev.isActionKey) el cual
identifica si la tecla que fue
presionada es una tecla de acción
o no
ANDRÉS TUXTLA
Existe una parte del código que

nos identifica cuando se oprime
una tecla modificadora y cuando
se deja de oprimir, el evento que
se utiliza para realizar esa opción
es un (ev.getModifiers) y para
poderlo visualizar hicimos uso de
linea3 = "Teclas modificadora
oprimidas: "+
(temp.equals("")?"Ninguna":temp);
para indicar en la interfaz gráfica
cuando se pulsar la tecla
modificadora o se deja de pulsar.
ANDRÉS TUXTLA
CONCLUSIONES
En el presente reporte de práctica 1, se incluye el código fuente de la clase

DemostracionTeclas, en el cual la interfaz y los métodos se ven explicados en orden
para que el lector pueda comprenderlo mejor, asimismo para que cualquier usuario
pueda editar y probar la interfaz. Los métodos keyPressed, keyTyped y
getKeyCode, sirven para ver la interacción del usuario y la interfaz gráfica al oprimir
cualquier tecla. En keyPressed validamos cuando se presionan las vocales para ir
asignando los valores correspondientes al área de texto y a la variable que las
cuenta. Se aprecia que la interfaz gráfica es entendible y amigable para el usuario.
ANDRÉS TUXTLA
REFERENCIAS
[1] Aguilar, L. J. (2010). Programación en c/c++ java y UML. México: McGraw Hill.
[2] Ceballos, F. J. (2010). JAVA 2: Curso de programación. Madrid: RA-MA.
[3] Dean, J. (2009). Introducción a la programación con Java. México: McGraw Hill.
[4] Deitel, D. y. (2010). Java Cómo Programar. México: Prentice Hall

ANDRÉS TUXTLA
MATERIA:
DOCENTE:
GRUPO:
404- A
INTEGRANTES:

PERIODO:

ANDRÉS TUXTLA
PRÁCTICA NO. 2
GUI con implementación de lis tener de teclado
OBJETIVO:
El estudiante desarrollara una GUI que incluya la implementación de listener y
adaptador de mouse, para aprender a utilizar algunos de sus eventos.
INTERFAZ GRÁFICA GUI
DEFINICIONES
Se llama Interfaz Gráfica GUI (Graphical User Interface) al conjunto de

componentes gráficos que posibilitan la interacción entre el usuario y la aplicación.
Es decir, ventanas, botones, combos, listas, cajas de diálogo, campos de texto, etc.
GUI es un conjunto de formas y métodos que posibilitan a los usuarios la interacción

con un sistema, empleando para esto gráficos e imágenes.
Con formas gráficas nos referimos a botones, íconos, ventanas, fuentes, etc. los
cuales representan funciones, acciones e información en el contexto de ese
sistema. Un entorno de desarrollo integrado IDE, es un entorno de programación
que ha sido empaquetado como un programa de aplicación, es decir, consiste en
ANDRÉS TUXTLA
un editor de código, un compilador, un depurador y un constructor de interfaz gráfica

(GUI).
Los IDE proveen un marco de trabajo amigable para la mayoría de los lenguajes de
programación tales como C++, PHP, Python, Java, C#, Delphi, Visual Basic, etc.
En algunos lenguajes, un IDE puede funcionar como un sistema en tiempo de
ejecución, en donde se permite utilizar el lenguaje de programación en forma
interactiva, sin necesidad de trabajo orientado a archivos de texto.
Un IDE debe tener las siguientes características:
• Multiplataforma
• Soporte para diversos lenguajes de programación
• Integración con Sistemas de Control de Versiones
Los eventos son el medio como interactúa una clase con otras o con el propio
usuario, se encargan de avisar que algo ha ocurrido y de manejarlo de una forma o
de otra. Cada vez que escribimos con nuestro teclado, que hacemos clic en un
botón o un link, que cambiamos el tamaño de un objeto, estamos generando
eventos.Primero tenemos que diseñar la aplicación, programarla y por último los
eventos que se generan a medida que el usuario interactúa con la Interfaz.
Los componentes son objetos de las clases que heredan de la clase base
componente como Button, List, TextField, TextArea, Label, etc.
En una GUI los componentes son contenidos en Contenedores o containers. Un

Containes es un objeto cuya clase hereda de Container(clase que a su vez es
subclase de Component) y tiene la responsabilidad de contener Componentes.
Generalmente una GUI se monta sobre un Frame. Esté será el Container principal
que contendrá a los componentes de la Interfaz Gráfica, un Container podría
contener a otros containers.
ANDRÉS TUXTLA
Distribución de componentes (layouts)
Los containers contienen componentes y estos son acomodados dentro del espacio
visual del container respetanto unaa cierta distribución que llamaremos layout.
AWT Y SWING
Java provee dos API's con las que podemos trabajar para desarrollar GUIs, la más
básica es AWT (Abstrct Window Toolkit). Las más desarrolladas se hacen con
Swing, las cuales son más identificables ya que todas comienzan con "J", por
ejemplo: JButton, JTextField, JTextArea, JPanel y JFrame son clases de Swing.
Todo el manejo de eventos y layouts es exactamente el mismo para AWT y Swing.
DISTRIBUCIONES RELATIVAS
Los layouts determinan el criterio con el que se van a distribuir los componentes
dentro del container
• FlowLayout: Distribuye los componentes uno al lado del otro en la parte

superior del container. Por defecto provee una alineación centrada, pero
también puede alinear a la izquierda o derecha.
• BorderLayout: Divide el espacio del container en 5 regiones: NORTH,
SOUTH, EAST, WEST y CENTER, admite un único componente por región
• GridLayout: Divide el espacio del container en una grilla de n filas por m
columnas, en donde las celdas son de igual tamaño
• GridBagLayout: Divide el espacio del container en una grilla donde cada
componente puede ocupar varias filas y columnas. Además, permite
distribuir el espacio interno de cada celda.
ANDRÉS TUXTLA
LA CLASE GRAPHICS
Java proporciona la clase Graphics, que permite dibujar elipses, cuadrados, líneas,
mostrar texto y mucho más. Esta clase proporciona el entorno de trabajo para
cualquier operación gráfica que se realice dentro del AWT.
Para poder pintar, un programa necesita un contexto gráfico válido, representado

por una instancia de la clase Graphics, pero esta clase no se puede instanciar
directamente, sino que debemos crear un componente y pasarlo al programa como
un argumento al método paint().
El único argumento del método paint() es un objeto de esta clase. La clase Graphics
dispone de métodos para soportar tres categorías de operaciones gráficas:
• Dibujo de primitivas gráficas (elipses, cuadrados, líneas, etc.)

• Dibujo de texto
• Presentación de imágenes en diferentes formatos
Además, la clase Graphics mantiene un contexto gráfico, entro otras, con las
siguientes características:
• un área de dibujo actual

• un color de dibujo del Background
• un color de dibujo del Foreground
• un Font con todas sus propiedades, etc.
ANDRÉS TUXTLA
DESARROLLO:
Import java.awt. *;
import javax.swing.*;
import java.awt.Color.*;
public class EventosRaton extends JFrame { //nombre de la clase

private int xPos,yPos;
public EventosRaton () {
super ("clics y botones del raton");
getContentPane().addMouseListener(new ManejadorClicsRaton());
setSize(650,400);
setBounds(450,300,650,400);
setVisible(true);
setLocationRelativeTo(null);
this.getContentPane().setBackground(Color.blue);
}
public void paint(Graphics g){
super.paint(g);
g.drawString("Se hizo clic en:["+ xPos +","+yPos+"]",xPos,yPos);
ANDRÉS TUXTLA
}
public static void main (String [] args) { //método principal
JFrame.setDefaultLookAndFeelDecorated(true);
EventosRaton aplicacion = new EventosRaton();
}
private class ManejadorClicsRaton extends MouseAdapter {

public void mouseClicked (MouseEvent evento) {
xPos = evento.getX();
yPos = evento.getY();
String titulo="se hizo clic \n"+""+evento.getClickCount()+"\n" +"\n veces";
if(evento.isMetaDown())
titulo+="\n con el boton derecho del raton";
else if(evento.isAltDown())
titulo+="\n con el boton del raton";
else
titulo+="\n con el boton izquierdo del raton";
setTitle(titulo);
repaint ();
}
}
}
ANDRÉS TUXTLA
RESULTADOS:
Compilamos el código y como al hacerlo

no presenta errores, pasamos a
ejecutarlo.
El programa nos muestra una interfaz

gráfica haciendo uso del evento
getContentPane().addMouseListener(new
ManejadorClicRaton()); el cual hace la
función de agragar el contenido en
nuestro panel y el listener se encarga de
controlar nuestro evento.
Para poder manejar nuestra interfaz

gráfica se desarrolló el evento
super.paint(g); el cual permite usar los
graficos de formas geométricas y con un
g.drawString("se hizo clic en
|["+xPos+","+yPos+"]",xPos, yPos); nos
ANDRÉS TUXTLA
indicara la posición del pulsor y del raton.

Que se encuentra mostrado en la pantalla.
En esta otra descripción se muestra la

reacción de la interfaz gráfica cuando se
da un pulsor de lado derecho y muestra su
posición y de qué lado fue pulsado.
En esta otra captura se muestra la

reacción de la interfaz gráfica al hacer clic
y muestra su coordenada haciendo uso
del parte del código
xPos = evento.getX();
yPos = evento.getY();
Que indica la posición y detectando el
botón con el que fue pulsado, en este caso
fue el botón izquierdo.
ANDRÉS TUXTLA
CONCLUSIONES:
En conclusión, las interfaces gráficas de Java también son muy conocidas como
GUI. GUI, es un término que proviene de Graphical User Interface. Un ejemplo de
GUI, podría ser una aplicación de escritorio para leer de PDFs. Primero tenemos
que diseñar la aplicación, programarla y por último los eventos que se generan a
medida que el usuario interactúa con la Interfaz.
Los componentes son objetos de las clases que heredan de la clase base
componente como Button, List, TextField, TextArea, Label, etc.
En una GUI los componentes son contenidos en Contenedores o containers. Un

Containes es un objeto cuya clase hereda de Container(clase que a su vez es
subclase de Component) y tiene la responsabilidad de contener Componentes.
ANDRÉS TUXTLA
REFERENCIAS:

ANDRÉS TUXTLA
MATERIA:
DOCENTE:
GRUPO:
404- A
INTEGRANTES:

PERIODO:

ANDRÉS TUXTLA
PRÁCTICA NO. 3
Control de componentes
OBJETIVO:
Emplear listeners de componentes indicados en la práctica para ejemplificar el

manejo de componentes gráficos de control.
Cuando el usuario de un programa o applet mueve el ratón, o hace un clic o usa el

teclado, genera un Evento. En Java los eventos, como cualquier otra cosa, se
representan como instancias u objetos de alguna clase. Para programar una
interfaz gráfica es necesario aprender a utilizar los eventos.
Los eventos son las acciones que puede realizar el usuario, al realizar un evento
se produce una serie de acciones. Por ejemplo, si el usuario pulsa un botón llamado
“Salir” cerrara la aplicación. Otro ejemplo muy usado es para validar texto que
introduzcamos en un campo de texto.
Los Listeners (oyentes o escuchadores en español) se encargan de controlar los

eventos, esperan a que el evento se produzca y realiza una serie de acciones.
Según el evento, necesitaremos un Listener que lo controle.
ANDRÉS TUXTLA
Cada Listener tiene una serie de métodos que debemos implementar

obligatoriamente, aunque solo queramos usar uno solo de ellos.
Los Listeners que usaremos estarán en el paquete java.awt.event.
Interfaz Métodos
ActionListener actionPerformed(ActionEvent)
AdjustmentListener adjustmentValueChanged(AdjustementEvent)
ComponentListener componentHidden(ComponentEvent)
componentMoved(ComponentEvent)
componentResized(ComponentEvent)
componentShown(ComponentEvent)
ContainerListener componentAdded(ContainerEvent)
componentRemoved(ContainerEvent)
FocusListener focusGained(FocusEvent)
focusLost(FocusEvent)
ItemListener itemStateChanged(ItemEvent)
KeyListener keyPressed(KeyEvent)
keyReleased(KeyEvent)
keyTyped(KeyEvent)
MouseListener mouseClicked(MouseEvent)
mouseEntered(MouseEvent)
mouseExited(MouseEvent)
mousePressed(MouseEvent)
mouseReleased(MouseEvent)
ANDRÉS TUXTLA
MouseMotionListener mouseDragged(MouseEvent)
mouseMoved(MouseEvent)
TextListener textValueChanged(TextEvent)
WindowListener windowActivated(WindowEvent)
windowClosed(WindowEvent)
windowClosing(WindowEvent)
windowDeactivated(WindowEvent)
windowDeiconified(WindowEvent)
windowIconified(WindowEvent)
windowOpened(WindowEvent)
Los listeners que usaremos estarán en el paquete java.awt.event (que debemos

importar antes de implementarlos) y nos podemos encontrar los siguientes:
• Nombre: ActionListener
Descripción: Se produce al hacer click en un componente, también si se pulsa Enter

teniendo el foco en el componente.
Método:
public void actionPerformed(ActionEvent e)
Eventos:
JButton: click o pulsar Enter con el foco activado en él.
JList: doble click en un elemento de la lista.
JMenuItem: selecciona una opción del menú.
JTextField: al pulsar Enter con el foco activado.

ANDRÉS TUXTLA
• Nombre: KeyListener
Descripción: Se produce al pulsar una tecla. según el método cambiara la forma de

pulsar la tecla.
Métodos:
public void keyTyped(KeyEvent e)
public void keyPressed(KeyEvent e)
public void keyReleased(KeyEvent e)
Eventos: Cuando pulsamos una tecla, según el listener:
keyTyped: al pulsar y soltar la tecla.
keyPressed : al pulsar la tecla.
keyReleased : al soltar la tecla.
• Nombre: FocusListener
Descripción: Se produce cuando un componente gana o pierde el foco, es decir,

que esta seleccionado.
Métodos: Recibir o perder el foco.
• Nombre: MouseListener
Descripción: Se produce cuando realizamos una acción con el ratón.
Métodos:
public void mouseClicked(MouseEvent e)
public void mouseEntered(MouseEvent e)
public void mouseExited(MouseEvent e)

ANDRÉS TUXTLA
public void mousePressed(MouseEvent e)
public void mouseReleased(MouseEvent e)
Eventos: Según el listener:
mouseClicked: pinchar y soltar.
mouseEntered: entrar en un componente con el puntero.
mouseExited: salir de un componente con el puntero
mousePressed: presionar el botón.
mouseReleased: soltar el botón.
• Nombre: MouseMotionListener
Descripción: Se produce con el movimiento del mouse.
Métodos:
public void mouseDragged(MouseEvent e)
public void mouseMoved(MouseEvent e)
Eventos: Según el listener:
mouseDragged: click y arrastrar un componente.
mouseMoved: al mover el puntero sobre un elemento.
ANDRÉS TUXTLA
DESARROLLO:
import java.awt.*;
import javax.swing.*;\\Librerias ocupadas para hacer la interfaz gráfica
public class MiPrimerGUI2mod extends JFrame{ //nombre de la clase
public static void main(String args[]){ //método principal

MiPrimerGUI2mod obj= new MiPrimerGUI2mod();
try{
obj.setDefaultLookAndFeelDecorated(true);
JDialog.setDefaultLookAndFeelDecorated(true); \\ Método
para darle mejor vista a la interfaz
UIManager.setLookAndFeel("com.sum.java.swing.plaf.nimbus.NimbusLook
AndFeel");
}catch (Exception e){
e.printStackTrace();
}
obj.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
//cierra de la ventana
}
//Creación de las etiquetas (Jlabel), los cuadros de textos que sirven como
espacio para la escritura de datos (JTextField), y también se crean los botones
para nuestra interfaz (JButton). De igual forma se le da nombre a cada uno según
corresponde.
JLabel eti1 = new JLabel("NUmero1: ");
JLabel eti2 =new JLabel("NUmero2: ");
JLabel eti3 =new JLabel("Resultado=");
ANDRÉS TUXTLA
JTextField txtNum1 =new JTextField(9);

JTextField txtNum2 =new JTextField(9);
JButton btn1=new JButton("Calcular");
JButton btn2=new JButton("Clean");
MiPrimerGUI2mod(){
setTitle("Sumadora");
\\ En getContentPane se agregan los botones, etiquetas y cuadros de textos de la
interfaz gráfica
Container cp= getContentPane();
//Modificacion
cp.setLayout(new BoxLayout(cp,BoxLayout.Y_AXIS));
cp.setLayout(new FlowLayout());
//5,1,30,30
cp.setLayout(new GridLayout(5,1,30,30));
cp.add(eti1);
cp.add(txtNum1);
cp.add(eti2);
cp.add(txtNum2);
cp.add(btn1);
cp.add(btn2);
cp.add(eti3);
setSize(300,300);
setVisible(true);
btn1.addActionListener(new MiOyente());
btn2.addActionListener(new MiOyente());
}
ANDRÉS TUXTLA
\\ En esta parte se crea el código que generará internamente el resultado de las

sumas. Con la ayuda de If else.
class MiOyente implements ActionListener{
public void actionPerformed(ActionEvent event){
if(event.getSource()==btn1){
int num1 = Integer.parseInt(txtNum1.getText());
int num2 = Integer.parseInt(txtNum2.getText());
int res= num1+num2;
eti3.setText("Su Resultado es="+res);
}
else {txtNum1.setText("");
txtNum2.setText("");
eti3.setText("Resultado=");
}
}
}
}
ANDRÉS TUXTLA
RESULTADOS:
Compilamos y ejecutamos
el código del programa.
En la interfaz están las

JLabel y los botones que se
les ha dado inicialización en
el código, como se ve es
una calculadora que solo
realizará sumas.
ANDRÉS TUXTLA
Ingresamos los valores que

deseemos para hacer el
cálculo de nuestra
sumatoria.
Una vez ingresados los dos

números, el código ejecuta
la suma y arroja en la
interfaz nuestro resultado.
ANDRÉS TUXTLA
CONCLUSIONES:
En Java, cada evento está representado por un objeto que es una subclase de la
clase EventObject en el paquete java.util. Cada subclase de EventObject
representa un tipo de evento particular. Por ejemplo:
• MouseEvent, para representar acciones del ratón: mover, arrastrar, hacer

clic en un botón del ratón, etc.
• KeyEvent, para representar acciones del teclado, esto es, pulsar teclas.
• ActionEvent, para representar una acción del usuario en la interfaz, por
ejemplo, pulsar un botón en la pantalla.
No obstante, en el modelo de eventos de Java, los EventObject no realizan

acciones por si mismos, sino que esos eventos son enviados a otro objeto
encargado de responder a un tipo de evento en particular. Estos objetos son los
que conocemos como listeners o "escuchadores", y existen diferentes listeners que
"escuchan" a los diferentes eventos, tales como los mouses listeners, key listeners
o action listeners.
Los listener no se implementan como clases en java, sino como interfaces. Una
interface sería entonces una colección de métodos que definen un comportamiento
en particular. De este modo, cualquier clase que suministre información para dichos
métodos puede declarar que implementa a dicho interface.
ANDRÉS TUXTLA
REFERENCIAS:

Reporte de Practicas Tap - Carmona Cobaxin y Vichi Ortiz

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Reporte de Practicas Tap - Carmona Cobaxin y Vichi Ortiz

Cargado por

Copyright:

Formatos disponibles

INSTITUTO TECNOLÓGICO DE SAN

INGENIERÍA EN SISTEMAS COMPUTACIONALES

REPORTE DE PRÁCTICA No. 1

ANGEL DE JESUS CARMONA COBAXIN

ENERO – JULIO 2021

INGENIERÍA EN SISTEMAS COMPUTACIONALES

REPORTE DE PRÁCTICA TOPICOS AVANZADOS DE PROGRAMACIÓN

GUI con implementación de listener de teclado

El estudiante desarrollara una GUI que incluya la implementación de listener y

La interfaz de usuario es la parte del programa que permite al usuario interaccionar

La estructura básica de la biblioteca gira en torno a componentes y contenedores.

Al implementar la interface debemos implementar también los métodos que la

INGENIERÍA EN SISTEMAS COMPUTACIONALES

REPORTE DE PRÁCTICA TOPICOS AVANZADOS DE PROGRAMACIÓN

• keyPressed(KeyEvent e): Se ejecuta cuando el usuario presiona una tecla.

El desarrollo de GUI puede, fácilmente, convertirse en un proceso caótico. La

AWT permite hacer interfaces gráficas mediante artefactos de interacción con el

JERARQUIA DE LAS CLASES DE LA GUI

JComponent: superclase de todos los componentes de Swing que se dibujan

INGENIERÍA EN SISTEMAS COMPUTACIONALES

REPORTE DE PRÁCTICA TOPICOS AVANZADOS DE PROGRAMACIÓN

JFrame: ventana que no está contenida en otras ventanas.

JDialog: cuadro de diálogo.

JApplet: subclase de Applet para crear applets tipo Swing.

JPanel: contenedor invisible que mantiene componentes de interfaz y que se puede

Graphics: clase abstracta que proporciona contextos gráficos donde dibujar

Color: color de los componentes gráficos.

Font: aspecto de los caracteres.

FontMetrics: clase abstracta para propiedades de las fuentes.

JFrame, JApplet, JWindow, JDialog

JLabel, JBbutton, JTextField, JTextArea, ...

Graphics, Color, Font.

INGENIERÍA EN SISTEMAS COMPUTACIONALES

REPORTE DE PRÁCTICA TOPICOS AVANZADOS DE PROGRAMACIÓN

Escrito totalmente en Java. No reemplaza a AWT. Se apoya sobre AWT y añade

JComponents. Utiliza el modelo de eventos de Java 1.1. Elección entre diferentes

MATERIAL Y EQUIPO EMPLEADO:

Equipo: Lenovo Ideapad S340

Procesador: AMD Ryzen 5 - 3500U

Almacenamiento: 8 GB RAM y 256 GB SSD

INGENIERÍA EN SISTEMAS COMPUTACIONALES

REPORTE DE PRÁCTICA TOPICOS AVANZADOS DE PROGRAMACIÓN

private String linea1 = "", linea2 = "", linea3 = "";

public void keyPressed (KeyEvent evento){ //método que se ejecutara cada

INGENIERÍA EN SISTEMAS COMPUTACIONALES

REPORTE DE PRÁCTICA TOPICOS AVANZADOS DE PROGRAMACIÓN

linea1 = "Se oprimio la tecla: "+

linea1 = "se solto tecla: " + ev.getKeyText(ev.getKeyCode());

linea1 = "Se escribio la tecla: "+ ev.getKeyChar();

INGENIERÍA EN SISTEMAS COMPUTACIONALES

REPORTE DE PRÁCTICA TOPICOS AVANZADOS DE PROGRAMACIÓN

El programa nos muestra una

INGENIERÍA EN SISTEMAS COMPUTACIONALES

REPORTE DE PRÁCTICA TOPICOS AVANZADOS DE PROGRAMACIÓN

Cuando nos identifica una tecla de

INGENIERÍA EN SISTEMAS COMPUTACIONALES

REPORTE DE PRÁCTICA TOPICOS AVANZADOS DE PROGRAMACIÓN

Existe una parte del código que

INGENIERÍA EN SISTEMAS COMPUTACIONALES

REPORTE DE PRÁCTICA TOPICOS AVANZADOS DE PROGRAMACIÓN

En el presente reporte de práctica 1, se incluye el código fuente de la clase

INGENIERÍA EN SISTEMAS COMPUTACIONALES

REPORTE DE PRÁCTICA TOPICOS AVANZADOS DE PROGRAMACIÓN