Los programas enseñaron cómo implementar interfaces en Java usando eventos. Se crearon dos botones que muestran mensajes diferentes y una calculadora básica. Para crear la interfaz gráfica se usó la clase Frame que genera una ventana y da herramientas para agregar botones y campos de texto. También se usaron listeners para enlazar la interfaz con el código y detectar las acciones del usuario. Aunque las interfaces simplifican el uso para los usuarios, complican la programación al requerir diseño e implementación de acciones.

1. INSTITUTO TECNOLOGICO SUPERIOR DE
FELIPE CARRILLO PUERTO
TÓPICOS AVANZADOS DE PROGRAMACIÓN.
TRABAJO: INFORME TECNICO.
De los dos programas.
-hola y adiós.
-calculadora.
UNIDAD I
EVENTOS.
ALUMNO
MATEO MIGUEL ARISTIDES
MARTIN MARTIN ELISEO.
JOSÉ DANIEL PUC POOT.
ALEXIS KAUIL CHIN.
DOCENTE:
Dr. Niels Henryk Aranda Cuevas
CUARTO SEMESTRE

2. Introducción:
En el siguiente informe damos a conocer las actividades en las cuales hemos estado trabajando en
la materia de Tópicos avanzados de programación, durante la unidad 1.
Conociendo, analizando y practicando un tema importante que es la implementación de interfaz
gráfica para los usuarios, un tema de suma importancia dado que nos ayuda a facilitar el uso del
software final a los usuarios finales aparte de darle una vista llamativa a nuestro programa. Como
desventaja podemos mencionar que su implementación hace un poco más difícil la programación
para los desarrolladores de software. Se presentaran dos pequeños proyectos individuales en los
cuales implementamos lo ya aprendido y estudiado en clase.
El primer trata de una sencilla interfaz gráfica con dos botones y un textField (Campo para ingresar
o mostrar cadenas de caracteres), cada botón implementa ya un código para poder realizar una
acción, en el botón 1 al momento de hacer “click” en el Textfield mostrara un mensaje con la cadena
de caracteres “Hola”, al hacer la misma acción en el botón 2 el Textfield mostrara una cadena de
caracteres “Adiós” reemplazando lo que anterior mente mostró.
El segundo programa es un software algo más complejo, al codificar una interfaz de una calculadora
básica que multiplique y sume.

3. Primer programa:
Codigo clase Igu:
package principal;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
public class Igu extends Frame {
Button hola, adios;
TextField campo_texto;
Igu(String nombre) {
super(nombre);
hola = new Button("1");
adios = new Button("2");
campo_texto = new TextField(12);
FlowLayout diseñador= new FlowLayout();
setLayout(diseñador);
add(hola);
add(adios);
add(campo_texto);
Oyente oy=new Oyente();
hola.addActionListener(oy);
adios.addActionListener(oy);
Oyente_marco oy1=new Oyente_marco();
this.addWindowListener(oy1);
}

4. En este programa creamos dos botones los cuales despliegan mensajes diferentes y es una manera
básica de mostrar de qué manera funcionan las interfaces en java puesto que cuando el usuario
clickea a un botón este debe realizar una acción ya programada, la manera en la que esto funciona
es implementando una interfaz la cual e realiza creando una ventana por medio de la palabra
reservada extends de herencia a frame la cual nos crea un espacio de trabajo o marco para ello al
igual que necesitamos importar la librería java.awt la cual nos permitirá poder dar las herramientas
class Oyente implements ActionListener
{
// clase oyente de eventos de botón
@Override
public void actionPerformed(ActionEvent e)
{
String res;
if (e.getSource()==hola)
res="Hola c:";
else
res = "Adios :c";
campo_texto.setText(res);
}}
class Oyente_marco extends WindowAdapter implements WindowListener
{
@Override
public void windowClosing(WindowEvent e)
{
dispose();
System.exit(0);
}}
}

5. necesarias para agregar objetos a nuestro marco como lo son botones, de igual se importan más
paqueterías como lo son las de escucha o los listener que se encarga de ejecutar ls líneas de código
para la reacción de cada botón, de igual manera se nos enseña que debemos programar el botón
de cerrar en el marco puest que al crear el marco este por default posee los botones de minimizar
y maximizar pero el botón de cerrar debemos crearlo
Segundo programa (calculadora sencilla).
package practicasniels;
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
public class PracticaDos extends JFrame implements ActionListener{
//se declaran los elementos del JFrame
JLabel elemento1= new JLabel ("primer elemento");
JLabel elemento2= new JLabel ("segundo elemento");
JLabel resultado= new JLabel ("resultado");
JTextField elemen1 = new JTextField (5);
JTextField elemen2= new JTextField (5);
JTextField resul = new JTextField (5);
JButton suma = new JButton("suma");
JButton producto = new JButton("producto");
//El constructor que nos permite declarar las caracteristicas
de la ventana principal
public PracticaDos (){
super ("Operaciones");
setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
setSize(800,200);
//Se declara el listener de Los botones suma y producto
suma.addActionListener(this);
producto.addActionListener(this);
//Se crea un contenedor del tipo FlowLayout dentro del
Jfframe
FlowLayout ver = new FlowLayout ();
setLayout(ver);

6. En la calculadora aplicamos los mismos conceptos que en el programa de los botones hola y adiós,
en este caso se utilizó para crear nuestro espacio de trabajo la librería de javax.swing y la clase
Jframe que es más flexible y más actual que la clase frame aunque tengan el mismo fin, de igual
manera hacemos uso de interfaces en java al usar la palabra implements para ActionListener esta
es una interfaz y por tal se debe de implementar todos los métodos que ella posee. Mencionado en
el ejemplo anterior los listener u oyentes sirven para ejecutar lo códigos de acuerdo a lo que el
listener escuche del usuario por medio de sus acciones.
Aquí lo que se hace es agregar los elementos al marco que ya fueron creado como los son los
elementos del del text field y botones que se encargaran de manipular las distintas acciones de la
calculadora.
En esta parte de código generamos nuetras variables que nos servirán para las operaciones de la
calculadora, se solicitan por medio del get.text a los campos de texto predefinidos anteriormente,
se realiza la conversión de cadena a double, se instancia el método calculo que realiza operaciones
esto para darle lo valores creados de acuerdo a lo que el usuario haya seleccionado en la operación
que el desee de la calculadora.
//Agregamos cada elemento al contenedor mediante las reglas de insercion de FlowLayout
add(elemento1);
add(elemen1);
add(elemento2);
add(elemen2);
add(resultado);
add(resul);
add(suma );
add(producto);
setVisible(true);
}
//metodo abstracto de la interfacce ActionListener
public void actionPerformed (ActionEvent evento){
Object fuente = evento.getSource();
String num1,num2,resul1;
double n1,n2,result;
num1=elemen1.getText();
num2=elemen2.getText();
n1=Double.parseDouble(num1);
n2=Double.parseDouble(num2);
Calculo operaciones = new Calculo ();
if (fuente==suma)
result=operaciones.suma(n1, n2);
else
result=operaciones.producto(n1, n2);
resul1=Double.toString(result);
resul.setText(resul1);
}

7. Clase calculo
Ya una vez recibidos los parámetros de operaciones la calculo efectúa valga la redundancia los
cálculo de acuerdo a la selección del usuario, y sea suma o multiplicación por medio de sus dos
métodos definidos
Conclusiones de los integrantes:
Eliseo Martin Martin:
En este programa aplicamos un modo nuevo de programación utilizando eventos, lo cual generamos
un recuadro y botones dentro de ella, que tiene como función un botón activo que uno indica hola
//Se crea una nueva instacia de la clase PracticaDos llamada probar y es lanzado mediante el
main.
public static void main (String [] args){
PracticaDos probar = new PracticaDos();
}
}
package practicasniels;
public class Calculo {
//declaramos un metodo que realizara la suma o la multiplicacion
public double suma (double n1, double n2) {
return(n1+n2);
}
public double producto (double n1, double n2) {
return(n1*n2);
}
}

8. y el otro adiós esto sucede al momento de pulsar el puntero del ratón sobre dicho botones, como
pudimos ver todo estos caracteres esta heredada de clase Jframe que contiene la paquetería que
nos permitirá trabajar manipulando gráficos. También realizamos un programa que realice
operaciones pulsando botones que lo identificamos como calculadora en este creamos varios
botones están separados por categoría por ejemplo insertamos JTextField que es en donde nos
permitirá demostrar o visualizar los caracteres que tenga el botón, luego insertamos botones que
en la cual solo nos representara él en número que está en el botón, luego mas botones que nos
permiten borrar los caracteres que ya han sido llamados en el JTextField, luego tenemos los botones
que nos permitirán realizar las operaciones matematicas que requieramos siempre y cuando qué
operación exista en el botón esa se llevara a cabo y por ultimo tenemos el botón igual que este es
que llama los métodos de las operaciones que tiene cada botón, en el JTextField cada que pulse un
botón se guardara en la memoria1, después pulsamos la operación que es un método llamado signo
de los botones operadores y por ultimo pulsamos otro botón que tenga números para que se a
complete la operación guardando así esto en memoria 2, esta para existan los caracteres y se lleve
a cabo la operación que requiera el usuario de esta aplicación. En general este es un modo de
programación que nos permite interactuar gráficamente con la consola lo cual lo hace que tenga
estetica el programa, es decir que los gráficos interactúen cuando sean requeridos por el usuario
final. En general es un Modo de programación utilizando gráficos, así recalcando la visualización del
programa que se generó.
Arístides Mateo Miguel:
Los programas vistos nos enseñaron de qué manera los conceptos básicos de eventos y la lógica
que se sigue al implementar una interfaz en un programa, puesto que existe un cambio en la manera
que se concibe el programa, ya que normalmente se lleva una programación que va en orden o
secuencial y al implementar interfaces el software tiene que eliminar esa secuencialidad puesto que
existen muchas opciones a realizar por el usuario final. En este software se toma esos nuevos
conceptos al crear dos botones lo cuales realizan diferentes acciones cada uno, se nos explica que
para poder realizar esto primero tenemos que tener un espacio de trabajo o marco el cual al heredar
componentes de una clase predefinida en java llamada “Frame” esta nos dice que genera una
ventana con los botones de maximizar y minimizar y de igual manera nos da las herramientas
necesarias para crear elementos para nuestra ventana como los son los botones y campos de texto.
La calculadora no muestra de igual manera y de una manera más “Gráfica” el como la programación
con interfaces toma forma puesto que la calculadora al tener más opciones este debe ejecutar las
ordenes que el usuario desee y para poder realizar eso hay que tener en cuenta que para la
codificación de la misma se tiene que haber utilizado elementos para genera la venta y botones que
esta posee, de igual manera el código necesario para realizar las distintas operaciones. Es por eso
que se dice que la interacción con un programa a través de una interfaz gráfica, simplifica la labor
del usuario, pero complica la del programador.
José Daniel Puc Poot:
La programación dirigida a eventos es un programa que usa una interfaz gráfica que simplifica la
labor del usuario, pero complica la del programador. En este ejemplo del programa con eventos que
usa una interfaz gráfica que permite al usuario utilizar el mouse para hacer clic sobre un botton y
usar un textfile para imprimir un texto. Aprendimos a usar las palabras reservadas para crear los
frames que utilizaremos en la interfaz. Lo primero que hacemos es crear una clase principal usando

9. la palabra extends frame; La clase Principal se usa para lanzar a ejecución la interfaz gráfica. Crea
un objeto de la clase, establece su tamaño inicial y lo visualiza. Para la estética usamos FlowLayout
que coloca las componentes de izquierda a derecha y de arriba abajo según el orden de ejecución
del método add. Después de hacer todos asignar los eventos al programa, al ejecutarlo se visualiza
una ventana con dos botones (hola y adiós). En el otro programa usamos más paquetes de java,
entre ellos están la paquetería de awt y awt.event; En su implementación podemos distinguir dos
tareas fundamentales: diseño y programación. El diseño supone determinar la cantidad de
componentes, su agrupación y su ubicación en la ventana, mientras que la programación determinar
las acciones que se llevarán a cabo cuando el usuario interactúe con cada componente. En este
programa se construye una calculadora básica que suma o multiplica dos números de valor doublé,
lanzando un mensaje de error en la parte inferior por si el usuario ingresa datos incorrectos, ahora
se utilizó el diseñador borderlayout.
Alexis Kauil Chin:
En el programa hola y adiós programamos nosotros como usuarios no tenemos que introducir un
número o frase, el programa no sabe qué acción va realizar el usuario. Por lo tanto se tuvo que
programar cada una de las acciones que el usuario puede realizar, de forma que si pulsa el botón
etiquetado con el número uno, en el campo de texto aparece la frase “hola”, y si pulsa el botón
etiquetado con el número dos, en el campo de texto aparece la palabra “adiós”. En el otro programa
se construyó una calculadora básica que suma o multiplica dos números de valor doublé, lanzando
un mensaje de error en la parte inferior por si el usuario ingresa datos incorrectos. En este podemos
identificar dos tareas principales el diseño que supone determinar la cantidad de componentes, su
agrupación y su ubicación en la ventana, y la programación determinar las acciones que se llevarán
a cabo cuando el usuario interactúe con cada componente.

10. CONCLUSIÓN:
Los programas vistos nos enseñaron de qué manera los conceptos básicos de eventos y la
lógica que se sigue al implementar una interfaz en un programa, puesto que existe un
cambio en la manera que se concibe el programa, ya que normalmente se lleva una
programación que va en orden o secuencial y al implementar interfaces el software tiene
que eliminar esa secuencialidad puesto que existen muchas opciones a realizar por el
usuario final. En este software se toma esos nuevos conceptos al crear dos botones lo cuales
realizan diferentes acciones cada uno, se nos explica que para poder realizar esto primero
tenemos que tener un espacio de trabajo o marco el cual al heredar componentes de una
clase predefinida en java llamada “Frame” esta nos dice que genera una ventana con los
botones de maximizar y minimizar y de igual manera nos da las herramientas necesarias
para crear elementos para nuestra ventana como los son los botones y campos de texto.
Pero eso no es suficiente puesto que esa simplemente es la parte de diseño y tenemos que
utilizar otros componentes de otras paqueterías como los son los elementos oyentes que
son el código que nos ayuda a enlazar la interfaz con el código ya que estos detectan las
acciones del usuario ya sea un movimiento de mouse o teclado y este por medio de esas
acciones pueda reconocer que líneas de código ejecutar para así hacer lo que el usuario
desea en el software.
La calculadora no muestra de igual manera y de una manera más “Gráfica” el como la
programación con interfaces toma forma puesto que la calculadora al tener más opciones
este debe ejecutar las ordenes que el usuario desee y para poder realizar eso hay que tener
en cuenta que para la codificación de la misma se tiene que haber utilizado elementos para
genera la venta y botones que esta posee, de igual manera el código necesario para realizar
las distintas operaciones. Es por eso que se dice que la interacción con un programa a través
de una interfaz gráfica, simplifica la labor del usuario, pero complica la del programador.
Puesto que este necesita de dos tareas fundamentales, los cuales son diseño y
programación.