Download - Reporte unidad1
Instituto Tecnológico Superior de Felipe Carrillo Puerto
Ingeniería en Sistemas Computacionales
Materia: Tópicos Avanzados de Programación
Docente: Dr. Niels Henryk Aranda Cuevas
Reporte Técnico
Unidad 1: Eventos
Integrantes:
Chable Pat Jhonny Gabriel
Balam Yam Wilberth
Ayala Mutul Ezer Abizai
Vega Segura Adrián Asís
Poot Tuz Efraín Antonio
Aké Pech Jorge Manuel
Semestre: 4th
Aula: J-3 Grupo: “a”
Ciclo Escolar: Enero – Julio
Unidad 1. Eventos
• Mediante la estructura de control Switch se puede seleccionar una opción de
acuerdo con una serie de casos (case). Esta selección se debe al valor que recibe
el parámetro selector. Es similar a la estructura if, sin embargo aglutina de mejor
manera las posibles sentencias que pueda ejecutar según el valor del parámetro
decisor (selector). Un ejemplo simple del uso del Switch sería el siguiente: Se tiene
un programa que al ejecutarse, lo primero que hace es solicitar un número, el
usuario puede ingresar un número entero del 1 al 7 y dependiendo del número
ingresado se manda un mensaje con el día correspondiente.
Código Java:
package practica1; //Este nombre puede variar
import java.util.Scanner;
public class practica1 {
static String dia(int ndia) {
String nomdia = null;
switch(ndia) {
case 1 : nomdia = "lunes"; break;
case 2 : nomdia = "martes"; break;
case 3 : nomdia = "miercoles"; break;
case 4 : nomdia = "jueves"; break;
case 5 : nomdia = "viernes"; break;
case 6 : nomdia = "sábado"; break;
case 7 : nomdia = "domingo"; break;
}
return (nomdia);
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Digite un numero de dia : ");
int Dia = scanner.nextInt();
System.out.println("El dia es "+dia(Dia)); }
}
• Mediante For se puede ejecutar un grupo de sentencias, de acuerdo con un valor
inicial y un valor final. Se usa cuando se conoce de dónde y hasta dónde deben
ejecutarse las sentencias. Por ejemplo: El programa que se realizará a continuación
implementa el uso de un vector de 5 elementos. La funcionalidad básica consiste
en cargar el vector y desplegarlo. También determina cuál es el valor mayor alojado
en el mismo.
El código es el siguiente: Vectores.java
package vectores;
import javax.swing.JOptionPane;
public class Vectores {
static void funcionvector()
{
int vector[]= new int[5];
int i;
for(i=0;i<5;i++)
{
vector[i]=Integer.parseInt(JOptionPane.showInputDialog("Ingresa el
valor para la posicion "+i));
}
for(i=0;i<5;i++)
JOptionPane.showMessageDialog(null,"Valor de la Posicion: "+i+" = "+
vector[i]);
//Mayor de los números
int mayor=vector[0];
for(i=0;i<5;i++)
if (vector[i]>mayor)
{mayor=vector[i];}
JOptionPane.showMessageDialog(null,"El valor mayor es: "+ mayor);
}
static void mensaje(){
JOptionPane.showMessageDialog(null, "Ejecucion Finalizada!!!");
}
public static void main(String[] args) {
funcionvector();
mensaje();
} //Fin main
}//Fin clase vectores
Clases Abstractas
• Una clase abstracta implementa la estructura genérica de la funcionalidad que deberá
ser implementada en una clase derivada. Una clase abstracta en realidad no puede
usarse, es decir, no se puede instanciar en un objeto para ser utilizada. Más bien se
deriva en otra clase y sobre ésta es que se crea la instanciación. Una clase abstracta
se puede crear o definir cuándo se necesita englobar objetos de tipo diferente y se
quiere implementar polimorfismo. A continuación se muestra un ejemplo de
implementación de clases abstractas. Creación de una clase abstracta llamada
Vehículo:
Vehículo.java
package clase_abstracta;
public abstract class vehiculo
{
protected int modelo;
protected String color;
protected String marca;
protected double precio;
public vehiculo(int modelo, String color, String marca, double precio)
{
//(This) Es la referencia al objeto que está ejecutando el método
this.modelo= modelo;
this.color=color;
this.marca= marca;
this.precio=precio;
}
public vehiculo ()
{
}
public abstract void registrarVehiculo();//Función abstracta
}
Creación de la clase Automóvil que reescribe el método abstracto: automóvil.java
package clase_abstracta;
import javax.swing.JOptionPane;
public class automovil extends vehiculo {
@Override
public void registrarVehiculo()
{
modelo = Integer.parseInt(JOptionPane.showInputDialog("Digite el modelo
del Automovil: "));
JOptionPane.showMessageDialog(null,"El modelo del Automóvil es: "+modelo);
color=JOptionPane.showInputDialog("Digite el Color del Automóvil: ");
JOptionPane.showMessageDialog(null,"El Color del Automóvil es: "+color);
marca=JOptionPane.showInputDialog("Digite la Marca del Automovil: ");
JOptionPane.showMessageDialog(null,"La Marca del Automóvil es: "+marca);
precio = Double.parseDouble(JOptionPane.showInputDialog("Digite el Precio
del Automovil: "));
}
}
Ahora crearemos otra clase, denominada bicicleta, con el siguiente código:
bicicleta.java
package clase_abstracta;
import javax.swing.JOptionPane;
public class bicicleta extends vehiculo{
@Override
public void registrarVehiculo()
{
modelo = Integer.parseInt(JOptionPane.showInputDialog("Digite el modelo de
la Bicicleta: "));
JOptionPane.showMessageDialog(null,"El modelo de la Bicicleta es:
"+modelo);
color=JOptionPane.showInputDialog("Digite el Color de la Bicicleta: ");
JOptionPane.showMessageDialog(null,"El Color de la Bicicleta es: "+color);
marca=JOptionPane.showInputDialog("Digite la Marca de la Bicicleta: ");
JOptionPane.showMessageDialog(null,"La Marca de la Bicicleta es: "+marca);
precio = Double.parseDouble(JOptionPane.showInputDialog("Digite el Precio
de la Bicicleta: "));
JOptionPane.showMessageDialog(null,"El Precio de la Bicicleta es:
"+precio);
} //Fin del Main
} // Fin de la clase bicicleta
Ahora vamos a implementar la clase Principal que es la que tiene el
main() que permite ejecutar los programas del proyecto.
package clase_abstracta;
public class Principal {
public static void main (String [] args)
{
//Implementa la funcionalidad de la clase abstracta
automovil auto = new automovil();
auto.registrarVehiculo();
bicicleta Bici = new bicicleta();
Bici.registrarVehiculo();
} //Fin del método Main
} //Fin de la clase Principal
Interfaces
• Mediante interfaces puede cubrir la necesidad de que una clase herede de otras
clases (al menos dos). Dado que en Java no existe el uso de la herencia múltiple,
entonces se tiene que utilizar una interface como enlace entre una subclase y dos
superclases. El siguiente ejemplo demuestra la necesidad de asociar una clase empleado
con las clases departamentos y operadoras de pensión. Como Java no puede
implementar la herencia múltiple, tendrá que acudir a una interface para que las
relacione. Es por ello que primero se crean dos interfaces con la declaratoria de los
atributos y métodos que requiere y posteriormente las hereda de las interfaces.
Se crea un proyecto llamado Interface, ya creado el proyecto se procede a crear una
interface que se denomine iDepartamentos.
El código que escribirá en el editor es el siguiente: iDepartamentos.java
package Interfaces;
public interface iDepartamentos {
//Se crean vectores de tipo cadena y enteros y se inicializan sus
respectivos valores
public static final String dptos[]={"Recursos
Humanos","Informática","Financiero","Contabilidad","Ventas"};
public static final int exts[]={123,345,324,125,423};
//Se crea un método vacío (sin implementar)
void asignarDpto();
}
Ahora proceda a crear la interface iOperadoraPension, procediendo de la misma
manera que en el punto anterior.
El código de esta interface se muestra a continuación: iOperadoraPension.java
package Interfaces;
public interface iOperadoraPension {
//Se crean vectores de tipo cadena con sus respectivos valores
public static final String entidades[]={"Banco de pensiones","Pensiones
Costa Rica","Banco Municipal","Sistema de Pensiones","Pensiones Acme"};
public static final String
tasaRinde[]={"0.12",".13",".12",".12",".12"};
void asignarOperadora();
}
Ahora se implementan estas interfaces en la clase Empleado. Para ello escriba el
siguiente código: Empleado. Java
package Interfaces;
import javax.swing.JOptionPane;
public class Empleado implements iDepartamentos,iOperadoraPension{
int i;
@Override
public void asignarDpto()
{
int dpto, ext;
String nombre,ent;
nombre=JOptionPane.showInputDialog("Escriba Nombre del Empleado: ");
//Se recorre el vector Departamentos
for(i=0;i<dptos.length;i++)
JOptionPane.showMessageDialog(null,i+1+" "+dptos[i]);
//Se muestran valores del vector
ent=JOptionPane.showInputDialog("Seleccione Dpto: ");
dpto=Integer.parseInt(ent);JOptionPane.showMessageDialog(null,"Departamen
to seleccionado: "+dptos[dpto-1]);
//Se recorre el vector de extensiones
for(i=0;i<exts.length;i++)
JOptionPane.showMessageDialog(null,i+1+" "+exts[i]);//Se muestran
valores del vector
ent=JOptionPane.showInputDialog("Seleccione la Extension: ");
ext=Integer.parseInt(ent);
JOptionPane.showMessageDialog(null,"Extension: "+exts[ext-1]);
}
@Override
public void asignarOperadora()
{
int opera, tasa;
String ent;
for(i=0;i<entidades.length-1;i++)
JOptionPane.showMessageDialog(null,i+1+" "+entidades[i]);//Se muestran
valores del vector
ent=JOptionPane.showInputDialog("Selecciona Operadora: ");
opera=Integer.parseInt(ent);
JOptionPane.showMessageDialog(null,"Departamento seleccionado:
"+entidades[opera-1]);
for(i=0;i<tasaRinde.length-1;i++)
JOptionPane.showMessageDialog(null,i+1+" "+tasaRinde[i]);//Se muestran
valores del vector
ent=JOptionPane.showInputDialog("Seleccione la Tasa de Rendimiento: ");
tasa=Integer.parseInt(ent);
JOptionPane.showMessageDialog(null,"Extension: "+tasaRinde[tasa-1]);
}
}
Finalmente, implemente el uso de la clase que implementa las dos interfaces creando
la instancia de la clase Empleado. El código en el programa principal (que contiene el
Main) es el siguiente:
Principal.java
package Interfaces;
public class Principal {
public static void main (String[] Args )
{
Empleado aux= new Empleado();
aux.asignarDpto();
aux.asignarOperadora();
}
}
Polimorfismo
• El polimorfismo (llamado también Upcasting) brinda la posibilidad de que una referencia
a un objeto de una clase pueda utilizarse también en las clases derivadas de éstas. En
otras palabras el polimorfismo se refiere a la capacitad de clases derivadas de utilizar un
método en forma diferente.
Suponga que tiene una clase que implementa tres métodos que tienen el
mismo nombre pero que reciben parámetros de distinto tipo y devuelven resultados
también diferentes. Proceda a crear el ejemplo:
Crea un proyecto y agrega una nueva clase y denomínelo Polimorfismo. El código de
esta clase es el siguiente:
package polimorfismo;
public class Polimorfismo {
int sumar(int a, int b)
{
return a+b;//Retorna un valor de tipo Entero
}
double sumar(double a, double b)
{
return a+b;//Retorna un valor de tipo Double
}
String sumar(String a, String b)
{
return a+b;//Retorna un valor de tipo Cadena
}
}
La llamada a estas funciones dependerá del tipo de dato que envía dicha llamada, es
decir, si se envían datos de tipo cadena se ejecutará la función que recibe ese tipo de
parámetros. Y la clase que llama a ejecutar la funcionalidad de la clase (donde se
encuentra el main) contiene el siguiente código:
package polimorfismo;
import javax.swing.JOptionPane;
public class Principal {
public static void main(String[] args) {
Polimorfismo aux= new Polimorfismo();
int x=Integer.parseInt(JOptionPane.showInputDialog("Ingresa el Primer
Entero: "));
int y=Integer.parseInt(JOptionPane.showInputDialog("Ingresa el Segundo
Entero: "));
JOptionPane.showMessageDialog(null,"La suma de los Enteros es: "+
aux.sumar(x,y));
String c1=JOptionPane.showInputDialog("Ingresa la primera Cadena: ");
String c2=JOptionPane.showInputDialog("Ingresa la segunda Cadena: ");
JOptionPane.showMessageDialog(null,"La suma de las Cadenas es: "+
aux.sumar(c1+" ",c2));
double d1=Double.parseDouble(JOptionPane.showInputDialog("Ingresa el
Primer Num. Double: "));
double d2=Double.parseDouble(JOptionPane.showInputDialog("Ingresa el
Segundo Num. Double: "));
JOptionPane.showMessageDialog(null,"La suma de los Doubles es: "+
aux.sumar(d1,d2));
}
}
CONCLUSIÓN
BALAM YAM WILBERTH:
En esta primera unidad empezamos con el desarrollo de interfaces gráficas para
desarrollar software con entornos amigables para el usuario, de igual manera
repasamos conceptos básicos cobre la programación orientada a objetos, que es el
paradigma más usado en el mundo de los programadores.
POOT TUZ EFRAIN ANTONIO
En la unidad uno vimos que son los eventos es una acción iniciada por el usuario por
ejemplo vimos que los eventos son presionar un botón, cambiar un texto etc. y cada
vez que creamos un evento se crea un objeto. y vimos la creación de eventos para
crear un evento necesitamos saber el a síntesis de evento el cual le guía a través de
las tareas para crear un nombre y un resumen.
AYALA MUTUL EZER ABISAI
En esta primera unidad trabajamos con los componentes de una aplicación de
escritorio que van desde los controles que proporciona como las son etiquetas,
botones, tablas, cajas de texto, listas, etc. Esto nos ayudara a realizar aplicaciones
con una interfaz amigable y fácil de usar. Al igual vimos cómo crear aplicaciones
básicas con programación concurrente.
AKE PECH JORGE MANUEL
En la unidad aprendimos a cómo hacer clases abstractas, la cual implementa una
estructura genérica que debe ser implementada en una clase derivada, ya que esta
no se puede instanciar en un objeto. Se deriva en otra clase y en esta se hace una
instanciación. Además de eso aprendimos a hacer las interfaces, en la cual utilizamos
una interface como enlace entre una subclase y dos superclases.
Además de eso, aprendimos a utilizar el polimorfismo, en la cual brinda la posibilidad
de que una referencia a un objeto de una clase pueda utilizarse.
VEGA SEGURA ADRIÁN ASIS
En esta primera unidad repasamos conceptos básicos acerca de la programación
orientada a objetos (en Java), realizamos pequeños programas donde salían a
relucir el polimorfismo, el uso del switch, for, clases abstractas y nos adentramos a
algo nuevo, que viene siendo las interfaces que bien resulto bastante útil para
realizar las aplicaciones, estuvimos explorando sus opciones y la infinidad de cosas
que se pueden hacer con ella.
CHABLE PAT JHONNY GABRIEL
En la tercera unidad aprendimos a utilizar los eventos en cualquier objeto, por ejemplo
en los botones , etiquetas, menús, etc., en donde cada componente tiene un
escuchador de eventos el cual recibe la acción de dicho evento, y la fuente de eventos
que es el objeto mismo. Realizamos prácticas de los eventos en la implementación
grafica de nuestro proyecto para mejorarle la interfaz. Aplicar los eventos en los
componentes nos ayudan para especificar qué tipo de acción se va a realizar.
