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

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.

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

}

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

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

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

}

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

}

}

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

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.

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.