Professional Documents
Culture Documents
Instituto Tecnológico de
San Juan del Río
Manual de Prácticas
Programación Visual
Ingeniería Electrónica
Lic. Guadalupe Flores Díaz
2015
INTRODUCCIÓN
En la unidad dos se desarrollan los temas referentes a los elementos básicos para el
diseño y desarrollo de interfaces gráficas de usuario. Se deben cubrir estos temas con
la profundidad necesaria, caracterizando sus propiedades, métodos y atributos de
manera práctica, enfatizando la correcta utilización de cada uno de estos
componentes. Para abordar los temas antes mencionado en esta segunda unidad se
utiliza el lenguaje de JAVA, donde el estudiante conoce los diferentes elementos que
conforman una interfaz gráfica utilizando los métodos y atributos de cada uno de ellos
para poder personalizar las interfaces creadas.
En la unidad tres se tratan los temas referentes a los elementos avanzados para el
diseño y desarrollo de interfaces gráficas de usuario, entre ellos aquéllos que facilitan
la organización y visualización de datos, así como los que permiten una gestión
básica de bases de datos. Las practicas presentadas para el abordaje de estos
temas, implica el desarrollo de aplicaciones sencillas donde se pueda integrar los
Según el Diccionario del Uso del Español de María Moliner (Ed. Gredos, 1983), en la tercera acepción del
término objeto podemos leer: "Con respecto a una acción, una operación mental, un sentimiento, etc., cosa de
cualquier clase, material o espiritual, corpórea o incorpórea, real o imaginaria, abstracta o concreta, a la cual
se dirigen o sobre la que se ejercen."
En POO, un objeto es un conjunto de datos y métodos; como imaginamos que se habrá quedado igual, le
vamos a dar más pistas.
Los datos son lo que antes hemos llamado características o atributos, los métodos son los comportamientos
que pueden realizar.
Lo importante de un sistema POO es que ambos, datos y métodos están tan intrínsecamente ligados, que
forman una misma unidad conceptual y operacional. En POO, no se pueden desligar los datos de los métodos
de un objeto. Así es como ocurre en el mundo real.
Hojas en blanco
Lápices
Goma
Lista de objetos proporcionada porcel docente
4.- PROCEDIMIENTO
1. Identifica la lista de características, valores y acciones que realiza cada uno de los objetos
listados a continuación.
a. Computadora
b. Teléfono Celular
c. Refrigerador
d. Suéter
e. Ventana
f. Camisa
g. Microondas
h. Lápiz
i. Vaso
j. Licuadora
5. RESULTADOS
En la Tabla siguiente, documenta la lista d características, valores y métodos encontrados para cada uno de
los objetos de la lista presentada por el docente
6. CONCLUSIONES
7.-BIBLIOGRAFÍA
1. Java con Programación Orientada a Objetos. Editoria ITEMEX
2. Lenguaje de programación Java. Sun Microsystems, Inc. (2008). SL-275-SE6.
3. Conceptos de la programación orientada a objetos. Alfonseca, M. Alcalá, A.
Los métodos definen el comportamiento de los objetos de una clase dada (lo que podemos hacer con los
objetos de esa clase) Los métodos exponen la interfaz de una clase. Un método define la secuencia de
sentencias que se ejecuta para llevar a cabo una operación:
La implementación de la clase se oculta del exterior.
Los métodos...
Nos dicen cómo hemos de usar los objetos de una clase.
Nos permiten cambiar la implementación de una clase sin tener que modificar su interfaz (esto es, sin
tener que modificar el código que utiliza objetos de la clase cuya implementación cambiamos)
Sintaxis en Java:
modificadores tipo nombre ( parámetros )
{
cuerpo
4.- PROCEDIMIENTO
1. Copia cuidadosamente el siguiente programa el JCreator
parciales = (calp1+calp2+calp3)/3*0.30;
proyFin = cproyFin*0.20;
ExamF = cexamFin*0.10;
practicas = cPracLb*.35;
promedio=parciales+proyFin+ExamF+practicas+tareas;
System.out.print("El promedio Final es : "+promedio);
}
2. Compila el programa copiado, y en caso de tener errores, verifica y corrige lo que te haya
marcado como error
3. Para facilitar el análisis de los resultados, escribe 100 en cada valor que te solicita
4. Contesta las siguientes preguntas
a. ¿Cuál es el resultado obtenido?
b. En que sección se encuentra escrito el código que se ha ejecutado para obtener e
resultado?
5. Ahora copia el siguiente programa
import java.lang.*;
import java.io.*;
parciales = porcentaje(calp1,calp2,calp3);
proyFin = porcentaje(cproyFin,2);
ExamF = porcentaje(cexamFin,3);
practicas = porcentaje(cPracLb,1);
tareas = porcentaje(ctarea1,ctarea2);
promedio=parciales+proyFin+ExamF+practicas+tareas;
System.out.print("El promedio Final es : "+promedio);
}
double porcentaje (double cal, int criterio) // Porcentaje de practicas de laboratorio 30%
{ // proyecto final 25% y Examen Final 20%
double calPor= 0;
switch (criterio)
{
case 1: calPor=cal * .35;break;
return calPor;
double porcentaje (double cal1, double cal2, double cal3 ) // Porcentaje de 3 examenes
{
double calPor=0,prom=0;
prom=(cal1+cal2+cal3)/3;
calPor=prom*0.30;
System.out.println("Porcentaje Examen: "+calPor);
return calPor;
}
double porcentaje (double tarea1, double tarea2)
{
double calPor=0,prom=0;
prom=(tarea1+tarea2)/2;
calPor=prom*0.05;
System.out.println("Porcentaje Tarea: "+calPor+" promedio: "+prom);
return calPor;
}
}
5. RESULTADOS
El alumno habrá identificado la forma en la que el uso de los métodos son aplicados en
programas orientados a objetos.
6. CONCLUSIONES
Escribe al menos tres conclusiones del uso de los métodos aprendido en la presente práctica
1.- OBJETIVO
Realizar la solución de un problema mediante el uso de métodos
Problemática a resolver
Crea un aplicación que nos convierta una cantidad de euros introducida por teclado a otra moneda, estas
pueden ser a dólares, yenes o libras. El cambio de divisas son:
0.86 libras es un 1 €
1.28611 $ es un 1 €
129.852 yenes es un 1 €
5. RESULTADOS
El alumno implementa un programa utilizando métodos
6. CONCLUSIONES
7.-BIBLIOGRAFÍA
Java con Programación Orientada a Objetos. Editoria ITEMEX
Lenguaje de programación Java. Sun Microsystems, Inc. (2008). SL-275-SE6
Conceptos de la programación orientada a objetos. Alfonseca, M. Alcalá, A.
2.2. Ventanas
2.3. Etiquetas
2.4. Botones
1.- OBJETIVO
Crear ventanas de entorno gráfico como base para el desarrollo de formularios para
soluciones de aplicaciones.
En la lista siguiente se describe el hardware, el software necesario para la elaboración de la presente práctica;
4.- PROCEDIMIENTO
1. Copia en el editor JCreator el siguiente código
/*Uso y manejo de Ventanas con Java
*Progamación Visual Ene - Jun 2015
*Elaboró: Lic. Guadalupe Flores Díaz
*/
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
2. Compila y verifica que no existan errores sintácticos, si esto es así, ejecuta el programa.
a. ¿Qué resultado aparece?
3. Analicemos una a una de las instrucciones que permiten que aparezca la ventna resultante,
describe la función que realiza cada una de ellas
4. JFrame ventana = new JFrame("Mi primera Ventana");
____________________________________________________________________________________
_
____________________________________________________________________________________
____________________________________________________________________________________
____________________________________________________________________________________
_____
5. JLabel etiqueta = new JLabel("Hola Mundo"); Cambia Hola mundo por “Hola y tu nombre” ¿Qué
sucede?
____________________________________________________________________________________
____________________________________________________________________________________
___
5.- RESULTADOS
El alumno identifica la forma en la que se puede crear un contenedor para los componentes
gráficos
6.- CONCLUSIONES
Escribe las dudas que hayas tenido en la creación de un contenedor grafico
SUBTEMA: Etiquetas
Práctica 5
Creación y uso de Etiquetas
Nota: Utilizarás el código de la práctica #4, al de creación de ventanas
1.- OBJETIVO
Crear etiquetas dentro de los contenedores, modificando los atributos
principales de cada una de éstas
Las etiquetas en programación de interfaces gráficas de usuario son elementos importantes, ya que
muestran al usuario final información acerca del problema a solucionar, el texto de las etiquetas no
puede ser seleccionado por el usuario, sin embargo existen instrucciones específicas que permiten el
acomodo y personalización de cada una de ellas. En el ejemplo del apartado 2.2, se creó y añadió a la
JLabel etiqueta = new JLabel("Hola Mundo"); Esta es la instrucción que nos permite crear el
texto que queremos que aparezca en nuestra ventana gráfica. El texto que se encuentra entre
comillas es el texto que tu quieres que aparezca, éste lo puedes cambiar de acuerdo a las
necesidades del problema que estas solucionando. Etiqueta representa el nombre que le darás al
componente, es importante mencionar que pongas un nombre relacionado con el texto, ya que de
lo contrario al añadirlas a la interfaz correspondiente puedes equivocarte y ocasionar algunos
problemas en tu programa.
ventana.getContentPane().add(etiqueta); Con esta instrucción podemos añadir a nuestra
ventana la etiqueta(s) creada(s), por cada etiqueta que añadas, deberás poner esta instrucción, ya
que de lo contrario no aparecerán en automático.
Las etiquetas, al igual que en las ventanas tienen asociadas a ellas ciertas instrucciones que te permitirán entre
otras cosas el acomodo de las mimas en la posición correcta, resaltarlas, ponerles imágenes entre otras,
veamos a continuación los métodos más utilizados en las etiquetas.
Las instrucciones antes descritas, al igual que en las de la ventana, debes anteponer el nombre de la
etiqueta, un punto y la instrucción que quieras aplicar. Para Aprender un poco más de acerca del uso y
manejo de las etiquetas, incluya en el programa anterior las siguientes instrucciones una a una, a anote
los comentarios acerca de que es lo que pasa en cada una de ellas:
a) 1 Computadora
b) JDK instalado 1.6 o superior
c) JCreator instalado
4. PROCEDIMIENTO
1. Considerando el código de la práctica anterior, añade la instrucción ventana.setlLayout(null); justo
debajo de la línea que dice JFrame ventana = new JFrame("Mi primera Ventana"); añade una a una
las siguientes instrucciones, compila el programa y anota la función que realiza cada una de ellas. Para
poder observar el efecto que tienen las instrucciones de la tabla siguiente es necesario que después
crear tu ventana, introduzcas la siguiente instrucción, esto solo lo tienes que realizar una sola vez.
etiqueta.setForeground(Color.BLUE);
etiqueta.setBounds(40,100,250,30);
etiqueta.setBounds(100,40,250,30);
etiqueta.setBounds(40,100,30,250);
2. Después de haber analizado el comportamiento de cada una de las instrucciones dela tabla anterior,
realiza el siguiente ejercicio.
Realiza una ventana que contenga seis etiquetas, las cuales deberán decir lo siguiente:
Colocar las etiquetas en posiciones diferentes, y colores también distintos tanto de fondo como de letra,
recuerda el contraste que debe existir para que éstas sean claras a la vista del usuario, no deberán estar
amontonados.
5.- RESULTADOS
6.- CONCLUSIONES.
Anota las conclusiones a las cuales llegaste con el uso de las etiquetas,
7.- BIBLIOGRAFÍA
a) Java 7. Francisco Javier Moldes Teo
b) Java 2. Curso de Programación. Francisco Javier Ceballos Sierra
c) Java 2. Curso Práctico. Antonio J. Martin sierra
d) Como programar con Java. Deitel
1.- OBJETIVO
Implementar Botones, que permitan realizar acciones dentro de un formulario creado.
Los botones dentro de las interfaces gráficas son elementos sumamente importantes, ya que con ellos se le
puede dar funcionalidad a los elementos que la integran, general mente con los botones, el usuario puede dar
una orden de acción a la interfaz en cuestión, al igual que las etiquetas, los botones tienen que ser creados y
añadidos a la interfaz, y podrás crear todos los que necesites, veamos cómo se pueden crear y manipular los
botones.
En lugar de la instrucción JLabel, deberás poner la instrucción JButton y en lugar del nombre etiqueta, pon el
nombre botón(Esto es recomendado para que cuando hagas uso de un elemento sepas exactamente a cual
nombre referenciar). Veamos que sucede y como quedaría tu programa.
4.- PROCEDIMIENTO.
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
ventana.setLayout(null);
ventana.getContentPane().add(boton);
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
ventana.setVisible(true);
ventana.setSize(450,450);
}
2. De igual manera que en las etiquetas, realicemos las pruebas correspondientes a cada una de las
funciones antes descritas, pero ahora con el botón, para poder visualizar las acciones básicas que se
pueden realizar con ellos en cuanto a apariencia se refiere
Instrucción(es) Función que realiza
boton.setText(“Aprendiendo el uso de etiquetas”);
boton.setOpaque(true);
boton.setBackground(new Color(100,200,1));
boton.setForeground(Color.BLUE);
boton.setBounds(40,100,250,30);
boton.setBounds(100,40,250,30);
boton.setBounds(40,100,30,250);
7.- BIBLIOGRAFÍA
1.- OBJETIVO
Implementar comandos de acción a los botones en interfaces gráficas.
Para poder asignar estas instrucciones a un botón determinado, se debe realizar lo siguiente:
1) Añadir a donde dice public class la instrucción implements ActionListener, la cual permite añadir
funcionalidad a los botones y otros elementos que contenga la ventana. De tal manera que debe
quedar la instrucción completa de la siguiente manera.
2) Después de haber creado el botón, es necesario indicarle la acción que debe realizar, existen varias
formas de llevar a cabo esta indicación para efectos de facilidad, utilizaremos la siguiente intruccion:
3) Finalmente debes añadir en un método especial las funciones que el botón debe realizar, lo cual se
hace con el siguiente grupo de instrucciones:
public void actionPerformed(ActionEvent e) //Se crea el método especial para implementar acciones
{
if(e.getSource()==boton) //Se compara si el evento sucedió en el botón se usa el nombre del mismo
{
// En esta sección se ponen todas las instrucciones que se van a realizar al presionar el botón
//Para no hacer un programa tan largo, puedes considerar la opción de crear métodos para
//cada uno de los botones que implementes, y solo pondrías el llamado al método
//correspondiente
JOptionPane.showMessageDialog(null, "Escogiste Guiño");
}
}
El grupo de instrucciones antes descritas, se puden colocar despues del metodo llamado :
public static void main(String ars[ ]), o bien después de haber cerrado la llave del constructor. Veamos el
ejemplo completo de cómo quedaría la implementación y uso de botones. Las partes señaladas en letra negrita
son las complementarias necesarias para el funcionamiento de los botones.
Desarrollar un interfaz que contenga 3 botones, etiquetados como “1”, “2” y “3”, al presionar el botón 1,
el título de la ventana se deberá cambiar a “Titulo Cambiado por Botón 1”, al presionar el botón 2
cambiar el texto del Boton 2 y deberá decir “Acivado 2”, al presionar el botón 3 deberá crear visualizar u
ocultar una etiqueta que diga “Estas usando el botón 3”, si al presionar el botón 3 la etiqueta es visible, el
texto del botón debe decir Ocultar, si no es visible deberá decir Mostrar. (Por default considere al inicio la
etiqueta oculta) Aplique cambio de color del texto del botón en cada acción. Los botones deberán estar
acomodados, con un color de letra diferente cada uno de ellos.
5. RESULTADOS
Captura la ventana con botones creada como prueba de realización de la misma.
6.- CONCLUSIONES
7.- BIBLIOGRAFÍA
1.- OBJETIVO.
Crear y utilizar cuadros de texto para entrada de datos por parte del usuario
Un cuadro de texto es el área destinada en una interfaz gráfica donde el usuario puede introducir información, y
de esta manera poder interactuar con la computadora, al igual que los elementos que hemos estado analizando
anteriormente como son las ventanas, etiquetas y botones, los cuadros de texto se deben declarar, crear y
añadir a la ventana, así como también se le pueden cambiar propiedades como el color del fondo, de la letra, y
la posición donde estará ubicada. Considerando las características que debe tener una buena interfaz gráfica
de usuario. A continuación analizaremos como se puede construir un cuadro de texto, modificar y las diferentes
formas en las que se puede utilizar.
Para crear e inicializar una etiqueta, se utiliza la instrucción JLabel, para un botón el comando JButton y en este
caso para la creación de los cuadros de texto deberás utilizar la instrucción JTextField, de igual manera que en
los componentes anteriores, es necesario que le pongas un nombre adecuado a cada cuadro de texto, esto con
la finalidad de no confundirte cuando los estés utilizando.
4.- PROCEDIMIENTO
1. Tomando coma base el programa de la práctica anterior, guárdalo como ProgCuadroTexto y modifícalo de
tal forma que quede como el siguiente código. (Recuerda cambiar el nombre de la clase por el nombre del
archivo:
import javax.swing.*;
public CuadrosTexto()
{
ventana = new JFrame("Uso de Cuadros de Texto");
bUno = new JButton("Verificar");
etiqueta = new JLabel("Introduza un Dato");
txtTexto = new JTextField();
visible = false;
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
ventana.setLayout(null);
bUno.setOpaque(true);
bUno.setForeground(Color.BLUE);
bUno.setBounds(40,170,250,30);
bUno.addActionListener(this);
etiqueta.setBounds(40,40,120,30);
etiqueta.setOpaque(true);
etiqueta.setBackground(Color.YELLOW);
etiqueta.setForeground(Color.GREEN);
txtTexto.setBounds(180,40,100,30);
ventana.getContentPane().add(etiqueta);
ventana.getContentPane().add(txtTexto);
ventana.getContentPane().add(bUno);
ventana.setIconImage(icono);
2. Identifica que función realiza cada una de las siguientes líneas de comando, y escribe dicha funcionalidad
en las lineas
a) JTextfield txtTexto;
_____________________________________________________________________________________
_____________________________________________
b) txtTexto = new JTextField();
_________________________________________________________________
c) txtTexto.setBounds(180,40,100,30);
_________________________________________________________________
d) Vent ana.getContentPane().add(txtTexto);
_________________________________________________________________
txtTexto.setForeground(Color.BLUE);
txtTexto.setBounds(40,100,250,30);
txtTexto.setBounds(100,40,250,30);
txtTexto.setBounds(40,100,30,250);
txtTexto.setEnabled(false);
txtTexto.setEnabled(true);
etiqueta.setTextext(txtTexto.getText());
5. RESULTADOS
Captura la ventana del ejercicio creado para verificar el uso adecuado de los cuadros de texto
Escribe al menos tres comentarios acerca de la creación, uso y asignación de tareas a los botones dentro de
las ventanas programadas.
7.- BIBLIOGRAFÍA
Las listas desplegables permiten al usuario seleccionar de una lista de opciones, previamente establecidos,
este componente al igual que el anterior debe ser creado, inicializado con los valores que contiene la lista, y
posteriormente manipulado para que se pueda utilizar el valor seleccionado por el usuario. Los valores iniciales
pueden estar previamente definidos, en caso de ser necesario pueden ser también añadidos por el usuario,
para lo cual se requiere del uso de almacenamiento de datos, lo cual se analizará en la unidad tres. Analicemos
las instrucciones que son necesarias para el uso y manejo de este componente gráfico.
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public UsoVentanas()
{
ventana = new JFrame("Mi primera Ventana");
boton = new JButton("Boton 1");
lista = new JComboBox();
cuadroTxt= new JTextField();
cuadroTxt.setBounds(200,150,100,50);
lista.setBounds(50,150,100,50);
lista.addItem("Valor 1 Lista");
lista.addItem("Valor 2 Lista");
lista.addItem("Valor 3 Lista");
lista.addItem("Valor 4 Lista");
lista.addItem("Valor 5 Lista");
lista.addActionListener(this);
ventana.getContentPane().add(cuadroTxt);
ventana.getContentPane().add(lista);
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
ventana.setLayout(null);
boton.addActionListener(this);
ventana.getContentPane().add(boton);
}
public void actionPerformed(ActionEvent e) //sobreescribimos el metodo del listener
{
if(e.getSource()==boton)//podemos comparar por el nombre del objeto del boton
{
JOptionPane.showMessageDialog(null,"Has presionado el Boton");
}
if(e.getSource()==lista)//podemos comparar por el nombre del objeto del boton
{
cuadroTxt.setText(lista.getSelectedItem().toString());
}
}
// ************** Implementacion de clase principal, que se encarga de ejecutar el programa
public static void main(String args [])
{
UsoVentanas MiAplicacón = new UsoVentanas();
}
}
4.- PROCEDIMIENTO
Las instrucciones anteriores son las básicas que deben utilizarse, a continuación analizaremos algunas
otras que existen en torno a este componente.
3. basado en el programa del ejemplo, añade una a una las siguientes instrucciones, compila y ejecuta el
programa, anota en el recuadro que es lo que hace cada una de ellas.
Instrucción Descripción
lista.setEnabled(false);
lista.setEnabled(true);
cuadroTxt.setText(“El elemento 3 es:
Crear una ventana con dos listas desplegables, y dos cuadros de texto, la primera lista desplegable
contendrá los nombres de 10 estados de la República, la segunda lista desplegable contendrá 10
nombres de carreras universitarias. Cada vez que se seleccione un elemento de cada lista, en el primer
cuadro de texto se deberá indicar el nombre de la lista de la cual se ha seleccionado un elemento y en el
segundo el número de elemento que ha seleccionado, así mismo cuando seleccione un estado, los
cuadros de texto deben ser en color de fondo rojo con color de letra blanco, y cuando se seleccione una
carrera universitaria, los cuadros debe cambiar a fondo negro con letras amarillas. Recuerda poner las
etiquetas que consideres necesarias. Así como también acomódalos de una manera visualmente
ordenado.
5. RESULTADOS
6.- CONCLUSIONES
Unidad 3.
Elementos avanzados de la interfaz gráfica
de usuario
Las clases del API JDBC se encuentran en el paquete java.sql. Este paquete contiene clases para cargar los drivers,
realizar conexiones a bases de datos, consultar datos y manejar un conjunto de registros. También incluye el manejo
de excepciones que se produzcan en el acceso a bases de datos.
Cuando la clase Driver es cargada en la aplicación de Java, ésta debe crear una instancia y registrarse en el
El lenguaje estructurado de consultas SQL es utilizado para acceder a la información contenida en la base de datos.
El método getConnection, de la clase DriverManager intenta localizar un driver apropiado que fueron
cargados en el proceso de inicialización y aquellos cargados explícitamente en el código.
Ejemplo:
while (rs.next()) {
int x = rs.getInt("a");
String s = rs.getString("b");
float f = rs.getFloat("c");
}
}
Para conectarse a una base de datos a través de JDBC desde una aplicación Java, lo primero que
se requiere es cargar el driver que será el 'puente' para interactuar entre la aplicación y la base de
datos.
Por ejemplo, si el driver que se emplea es el puente JDBC-ODBC, entonces el código para
cargarlo sería:
Class.forName("com.mysql.jdbc.Driver").newInstance();
El código para cargar el driver podría lanzar una excepción de tipo ClassNotFoundException que
debe ser capturada.
Para conectarse a una fuente de datos específica, una vez que se ha cargado el driver, se utiliza
una dirección (URL), que indicará la base de datos con la sintaxis:
e) Copia el código que a continuación se te muestra, ejecútalo y observa los resultados generados para cada uno de los
métodos
import java.sql.*;
// ABRIR CONEXION
//CERRAR LA CONEXION
public void cerrarconexion() {
try {
con.close();
System.out.println("Conexion cerrada");
}
catch (SQLException e) {
System.out.println("Error al cerrar conexion");
}
}
//MOSTRAR DATOS
//MODIFICAR DATOS
//INSERTAR DATOS
public void insertar(String m, String mar, int p, String d) {
try {
PreparedStatement ps = con.prepareStatement("insert into coches values (?,?,?) "); ps.setString(1, m);
ps.setString(2, mar);
ps.setInt(3, p);
ps.setString(1, d);
System.out.println("Elemento insertado");
import java.io.*;
5. RESULTADOS
Después de copiar, corregir y ejecutar el código anterior, contesta las siguientes preguntas:
6.- CONCLUSIONES
El alumno establece conexión con la base de datos y comprende el acceso a los datos utilizando un
manejador de base de datos.
7.- BIBLIOGRAFÍA
1.- OBJETIVO.
Considerar los elementos gráficos de las interfaces y desarrollar una aplicación que realice lo
especificado en la problemática presentada.
4.- PROCEDIMIENTO
Problemática Presentada
Una empresa de transporte ofrece la posibilidad de que sus clientes puedan comprar y cancelar asientos al
único destino que ofrece la compañía, el costo del destino es de: $ 320; Se sabe que a los niños menores de
12 años y a los adultos mayores de 60 se les hace un 50 % de descuento. Así mismo a los docentes el 25% y a
los estudiantes el 40%. Se sabe que solo existen 2 lugares disponibles para docentes y 4 para estudiantes, mas
sin embargo no existe limite en niños y/o adultos mayores.
Para poder realizar las operaciones antes mencionadas, se sabe que la forma de operar es la siguiente:
a) Un cliente podrá comprar todos los boletos que requiera, siempre y cuando haya disponibilidad en el
autobús.(Los boletos comprados por el cliente pueden ser de la misma categoría o diferente)
b) Para poder hacer valido el descuento de niño o adulto mayor, preguntar al usuario si el cliente presenta o
no tarjeta de INSEN .
c) Deberá pagar el costo del boleto(s) comprado(s) y no deberá permitir un costo menor a menos que en
ese momento decida ya no comprar los boletos. En caso de que ingrese una cantidad menor le deberá
indicar cuanto le falta por cubrir el monto total, o dar la opción de cancelar la venta de ese momento.
a) El cliente podrá cancelar todos los boletos que dese reintegrándose el monto total del boleto. Tomar en
cuenta que el costo puede variar si es niño, adulto mayor, estudiante o profesor.
b) La cancelación solo procede con boletos comprados
Cada vez que se venda un boleto debe verificarse la disponibilidad de lugares en el autobús. Al iniciar las
ventas existen 40 lugares disponibles.
5. RESULTADOS
Integración de habilidades
6.- CONCLUSIONES
Anota al menos tres situaciones que se te presentaron durante el desarrollo de la aplicación solicitada, y a
forma en la que fueron resueltas.