Int Prog Java
-
Upload
maestria20090 -
Category
Documents
-
view
201 -
download
0
Transcript of Int Prog Java
Curso: BSI-03 Programación I Universidad Latina
1
CONTENIDO
1. VARIABLES Y TIPOS DE DATOS ............................................................................................................. 2
1.1 Variables ...................................................................................................................................... 2
1.2 Tipos de datos .............................................................................................................................. 2
1.3 Conversión explícita de tipos (Casting) .......................................................................................... 3
2. OPERADORES ...................................................................................................................................... 4
2.1 Introducción ................................................................................................................................. 4
2.2 Operadores Aritméticos ............................................................................................................... 4
2.3 Operadores Relacionales y Condicionales ..................................................................................... 4
2.4 Operadores Relacionales And y Or ................................................................................................ 4
2.5 Operadores de Asignación ............................................................................................................ 5
2.6 Precedencia de Operadores en Java ............................................................................................. 5
3. SENTENCIAS DE CONTROL DE FLUJO.................................................................................................... 5
3.1. Toma de decisiones ...................................................................................................................... 5
3.1.1. If ........................................................................................................................................... 5
3.1.2. If/else ................................................................................................................................... 6
3.1.3. Switch ................................................................................................................................... 7
3.2. Bucles o ciclos .............................................................................................................................. 8
3.2.1. For ........................................................................................................................................ 8
3.2.2. While / Do While .................................................................................................................. 9
4. EL ENTORNO DE DESARROLLO DE NETBEANS .....................................................................................11
5. PRIMER PROYECTO EN JAVA ..............................................................................................................13
6. ABREVIATURA DE LOS NOMBRE DE LOS CONTROLES BÁSICOS DE JAVA ............................................17
7. EJERCICIOS EN NETBEANS 6.9.1 EN ESPAÑOL .....................................................................................18
8. UTILIZACIÓN DE LAS CAJAS DE TEXTO PARA CAPTURA DE DATOS......................................................36
10. PROGRAMAS CON CÁLCULOS .............................................................................................................39
11. CUADROS DE MENSAJE, CONFIRMACIÓN E INTRODUCCIÓN DE DATOS .............................................42
12. CADENAS ............................................................................................................................................43
13. LA CLASE JFRAME ...............................................................................................................................45
14. VARIABLES GLOBALES ........................................................................................................................45
15. CUADROS DE DIÁLOGO ......................................................................................................................47
16. EJERCICIOS PROPUESTOS....................................................................................................................50
16.1. Sentencias de control repetitivas .................................................................................................50
16.2. Ejercicios propuestos funciones ...................................................................................................52
Curso: BSI-03 Programación I Universidad Latina
2
1. VARIABLES Y TIPOS DE DATOS
1.1 Variables
Las variables se utilizan para almacenar datos asociados a nombres. Cada variable tiene un nombre que sirve de referencia para introducir datos o acceder a los mismos. Un ejemplo de utilización de variable es: Edad = 23; en este caso, introducimos el valor numérico 23 en la variable Edad. A partir de ahora podemos utilizar la variable a través de su nombre (Edad) para referirnos a su valor (23). Los nombre de las variables, en Java, pueden tener cualquier longitud y deben comenzar con una letra, el símbolo de subrayado “_” o el dólar “$”. El resto de los caracteres del nombre pueden ser cualquiera, salvo los que puden dar lugar a confusión. Los nombre de variables no deben tener espacios en blanco, puesto que el compilador identifacaría más de una variable; por ejemplo, NumeroDeAciertos es un nombre de variable correcto, sin embargo Numero De Aciertos no lo es, porque el compilador identificaría tres variables diferentes: Numero, De y Aciertos.
Los nombre de variables no deben coincidir con palabras reservadas (tales como public, static, class, final, main, etc.). Existe una serie de palabras reservadas las cuales tienen un significado especial para Java y por lo tanto no se pueden utilizar como nombres de variables. Dichas palabras son:
(*) Son palabras reservadas, pero no se utilizan en la actual implementación del lenguaje Java. En Java, los identificadores de variables suelen definirse empezando por un carácter en minúscula, por ejemplo contador. Si en el identificador existe más de una palabra, los comienzos del resto de las palabras se ponen con mayúsculas, ejemplo: contadorDeAciertos. Los identificadores deben ser representativos de los datos que almacenan, de esta manera valorAcumulado, numeroAlumnos, cantidadEuros, edad, potencia son variables que determinan de forma adecuada el significado de sus contenidos, mientras que los nombres de variable: valor V1, V2, X, Y, Z no son representativos de sus contenidos. La longitud de los identificadores no debe ser excesivamente larga, para no dificultar la legibilidad de las instrucciones. Los identificadores en mayúscula se suelen reservar para nombres (normalmente cortos) de constantes, de esta manera las instrucciones son más legibles, al utilizarse minúsculas. Ejemplo: PI, STOCK, PRECIOHORA, IVA, etc. 1.2 Tipos de datos
Las variables almacenan datos de diferentes tipos (numérico decimal, numérico entero, caracteres, etc.). Para indicar el tipo de dato que contendrá las variables debemos “declarar” las mismas, indicando sus tipos. Este mecanismo permite que el traductor (compilador) realice las comprobaciones estáticas de validez, como por ejemplo que no empleamos en el programa una variable que no ha sido declarada, que no asignemos un carácter a una variable de tipo numérico, que no sumemos un carácter a un valor numérico, etc. A continuación se establece una relación de los tipos de datos primitivos (los que proporciona el lenguaje):
Curso: BSI-03 Programación I Universidad Latina
3
TIPOS PRIMITIVOS
NOMBRE DEL TIPO TAMAÑO EN BYTES RANGO
TIPOS NUMÉRICOS ENTEROS
Byte 1 -128 a 127
Short 2 -32768 a 32767
Int 4 -231 a 231
Long 8 -263 a 263
TIPOS NUMÉRICOS DECIMALES
Float 4 -3.4x1038 a 3.4x1038
double 8 -1.7x10308 a 1.7x10308
tipo carácter
Char 2 Almacena un solo carácter
String Almacena un conjunto de caracteres
TIPO LÓGICO (BOOLEANO)
boolean 1 true, false
Para declara una variable se emplea la sintaxis: tipo identificador; //declara una variable
tipo identificador [= valor]; //declara e inicializa una variable
tipo identificador1, identificador2, identificador3, etc.; //declara varias
variables del mismo tipo
tipo identificador1=valor1, identificador2=valor2, etc.; // declara e inicializa
varias variables del mismo tipo
Por ejemplo: byte edad = 60;
short sueldoMensual;
float PrecioEuros, cateto1, cateto2, hipotenusa;
boolean adquirido=false, finalizado=true;
1.3 Conversión explícita de tipos (Casting)
Resulta muy habitual que en los programas nos encontremos con la necesidad de mezclar tipos de datos, por ejemplo al trabajar con un biblioteca matemática que obliga a utiizar tipos de datos double, cuando nosotros las variables las tenemos de tipo float, o mas sencillo todavía, al intentar sumar un 1 (por defecto int) a una variable tipo short. Java en algunos casos, realiza una conversión implícita de datos, sin embargo, por regla general, nos veremos obligados a programar conversiones explícitas de tipos. Para modificar el tipo de un valor, basta con indicar el nuevo tipo entre paréntesis antes del valor, por ejemplo: (byte) 1 convierte el 1 (int) a byte (double) MiVariableDelTipoFloat convierte a doublé una variable de tipo float (short) (VariableDeTipoByte + VariableDeTipoByte) convierte a short el resultado de sumar dos variables de tipo byte.
Curso: BSI-03 Programación I Universidad Latina
4
2. OPERADORES
2.1 Introducción
Los operadores nos permiten realizar operaciones sobre los operandos. Existen operandos unuarios y binarios; un ejemplo de operador unuario es la negación lógica (!). Los operadores tienen unas reglas de precedencia que resulta importante tener en cuenta.
2.2 Operadores Aritméticos
Esta tabla resume todas las operaciones aritméticas binarias en Java:
Operador Uso Descripción
+ op1 + op2 Suma op1 y op2
- op1 - op2 Resta op2 de op1
* op1 * op2 Multiplica op1 y op2
/ op1 / op2 Divide op1 por op2
% op1 % op2 Obtiene el resto de dividir op1 por op2
Nota: El lenguaje Java extiende la definición del operador + para incluir la concatenación de cadenas. Además, existen dos operadores de atajos aritméticos, ++ que incrementa en uno su operando, y -- que decrementa en uno el valor de su operando.
Operador Uso Descripción
++ op ++ Incrementa op en 1; evalúa el valor antes de incrementar
++ ++op Incrementa op en 1; evalúa el valor después de incrementar
-- op -- Decrementa op en 1; evalúa el valor antes de decrementar
-- -- op Decrementa op en 1; evalúa el valor después de decrementar
2.3 Operadores Relacionales y Condicionales
Los valores relacionales comparan dos valores y determinan la relación entre ellos. Por ejemplo, != devuelve true si los dos operandos son distintos. Esta tabla resume los operadores relacionales de Java:
2.4 Operadores Relacionales And y Or
Operador Uso Devuelve true si
&& op1 && op2 op1 y op2 son verdaderos
|| op1 || op2 uno de los dos es verdadero
! ! op op es falso
El operador & se puede utilizar como un sinónimo de && si ambos operadores son booleanos. Similarmente, | es un sinónimo de || si ambos operandos son booleanos.
Operador Uso Devuelve true si
> op1 > op2 op1 es mayor que op2
>= op1 >= op2 op1 es mayor o igual que op2
< op1 < op2 op1 es menor que op2
<= op1 <= op2 op1 es menor o igual que op2
== op1 == op2 op1 y op2 son iguales
!= op1 != op2 op1 y op2 son distintos
Curso: BSI-03 Programación I Universidad Latina
5
2.5 Operadores de Asignación
Puedes utilizar el operador de asignación =, para asignar un valor a otro. Además del operador de asignación básico, Java proporciona varios operadores de asignación que permiten realizar operaciones aritméticas, lógicas o de bits y una operación de asignación al mismo tiempo. Específicamente, suponga que quieres añadir un número a una variable y asignar el resultado dentro de la misma variable, como esto: i = i + 2; Puedes ordenar esta sentencia utilizando el operador +=. i += 2; Las dos líneas de código anteriores son equivalentes. Esta tabla lista los operadores de asignación y sus equivalentes: Operador Uso Equivale a += op1 += op2 op1 = op1 + op2 -= op1 -= op2 op1 = op1 - op2 *= op1 *= op2 op1 = op1 * op2 /= op1 /= op2 op1 = op1 / op2 %= op1 %= op2 op1 = op1 % op2
2.6 Precedencia de Operadores en Java
operadores sufijo [] . (params) expr++ expr--
operadores unarios ++expr --expr +expr -expr ~ !
creación o tipo new (type)expr
multiplicadores * / %
suma/resta + -
relacionales < > <= >= instanceof
igualdad == !=
AND lógico &&
OR lógico ||
condicional ? :
asignación = += -= *= /= %= ^= &= |= <<=
3. SENTENCIAS DE CONTROL DE FLUJO
Las sentencias de control de flujo determinan el orden en que se ejecutarán las otras sentencias dentro del programa. El lenguaje Java soporta varias sentencias de control de flujo, incluyendo:
Sentencias Palabra clave
Toma de decisiones if-else, switch-case
Bucles ó ciclos for, while, do-while
Excepciones try-catch-finally, throw
Misceláneas break, continue, return
3.1. Toma de decisiones
3.1.1. If
La sentencia if (o si condicional), le permite a un programa decidir, mediante la evaluación de una condición o varias condiciones, ejecutar una u otra acción o acciones. La sintaxis General es La siguiente:
if(condicion1) Accion1;
Curso: BSI-03 Programación I Universidad Latina
6
En donde:
Condición 1: Representa una expresión que puede ser del tipo booleana.
Acción 1: es la acción que, al evaluar la condición como verdadera, se ejecutará.
Si son varias acciones, van entre llaves. Ejemplo if Programa en java que solicita al usuario su edad, y si este es mayor se lo indica al usuario.
Explicación: En la línea 18 se declara y se inicializa la variable entera edad. En la línea 20 se declara una variable con el nombre lectura de tipo Scanner que se utiliza para lectura de datos. En la línea 23 se le asigna a la variable edad el valor digitado por el usuario, que es introducido gracias a la variable lectura (esta debe ser convertida a integer). En la línea 24 se utiliza la sentencia if para evaluar el valor de edad y si esta es mayor o igual a 18 se informa al usuario. 3.1.2. If/else
En las sentencias if, podemos agregar la sentencia else, la cual indica que, si al evaluar la condición, ésta es falsa, entonces, realizará las acciones, que estén después del else. La sintaxis es la siguiente: if(condición1) { Acciones; } else { Condiciones; }
Ejemplo if/else Al ingresar la nota de un alumno, se desea saber si éste aprobó o no, una materia en el colegio. Se sabe que para aprobar, se necesita una nota mayor o igual a 70.0. Diseñe una aplicación en Java que, al ingresar la nota, muestre con un mensaje, si el alumno, aprobó o no.
Curso: BSI-03 Programación I Universidad Latina
7
Explicación: En la línea 24, colocamos una condición, si el alumno alcanza una nota mayor o igual a 70, aprobó el examen caso contrario lo reprobó. Sentencia else/if Anidadas Esta estructura, es una consecuencia de las estructuras if anidadas, su formato es el siguiente: if(condicion1) Sentencia 1; elseif(condicion2) Sentencia 2; ... else Sentencia n; Funciona de la siguiente manera: Se evalúa la primera condición, si resulta verdadera se ejecuta la sentencia 1, y se continúa con la ejecución del programa; de lo contrario, de evalúa la condición 2, si resulta verdadera, se ejecuta la sentencia 2, de lo contrario se evalúa la condición 3 y así sucesivamente. Si al evaluar todas las condiciones, ninguna resulta verdadera, se ejecuta el bloque del else.
3.1.3. Switch
Cuando en una condición existen diversas posibilidades, nos vemos obligados a programar usando if anidados, lo que complica la realización y depuración de código. Para facilitar la programación en estas situaciones, se proporciona la instrucción condicional switch, que permite definir un número ilimitado de ramos basadas en la misma condición. Sintaxis switch(expresión) {case valor1: Instrucciones; break; case valor2: instrucciones; break; ……………… default: instrucciones; break; } Cuando el flujo de control del programa llega a la instrucción switch, lo primero que se hace es evaluar la expresión, después se va comparando el valor de cada clausula case con el resultado de la evaluación de la expresión. Cuando en una instrucción case coinciden los valores, se ejecutan las instrucciones asociadas
Curso: BSI-03 Programación I Universidad Latina
8
hasta alcanzar la sentencia break. Si no se incluyen break en un case, se ejecutan todas las instrucciones siguientes (correspondientes a los siguientes grupos case) hasta que se encuentra un break o se termina la instrucción switch. Es importante tener en cuenta que la expresión asociada a la instrucción switch solo debe generar valores de tipo: char, byte, short o int. Ejemplo switch public static void main(String[] args) {
Scanner lectura = new Scanner(System.in);
int numero1 = 0, numero2, resultado = 0, operacion = 0;
System.out.print("Digite el número 1: ");
numero1 = lectura.nextInt();
System.out.print("Digite el número 2: ");
numero2 = lectura.nextInt();
System.out.print("Digite la operación a realizar (1. Sumar/ 2. Restar) ?:");
operacion = lectura.nextInt();
switch (operacion) {
case 1:
System.out.println("Elegió realizar una suma");
resultado = numero1 + numero2;
break;
case 2:
System.out.println("Elegió realizar una resta");
resultado = numero1 - numero2;
break;
default:
System.out.println("No eligió el número 1 ó 2");
System.out.println("Las opciones son 1 ó 2. Por favor intente de
nuevo");
break;
}
System.out.println("El resultado es: "+resultado);
}
3.2. Bucles o ciclos
3.2.1. For
En algunas ocasiones, sabemos a ciencia cierta el número de veces que se tiene que repetir una misma acción o bloque de acciones. Y para ello es que nos sirve, esta estructura. Su sintaxis es la siguiente: for( valor inicial; condición; incremento) accion; Donde:
Valor inicial: es el valor con el cual inicializamos nuestra variable de control.
Condición: si la cumple, ejecuta la acción o acciones e incrementa o decrementa la variable de
control, sino la cumple la condición, se sale del ciclo.
Incremento: que puede ser positivo o negativo (decremento).
La semántica (significado) de la instrucción es la siguiente: se inicializa una variable (inicialización), se evalúa la condición de continuidad y, sí se cumple, se ejecutan las instrucciones situadas entre las llaves, finalmente se ejecuta la expresión de variación y se repite el ciclo hasta que la condición de continuidad se evalúa como false.
Curso: BSI-03 Programación I Universidad Latina
9
Ejemplo:
Salida del programa
En el ejemplo anterior se declara una variable de tipo int en la línea 4 (for). El bucle for contiene sus tres secciones obligatorias, separadas por ;
Declaración e inicialización; int índice =1
Condición de continuidad: índice <=10
Expresión de incremento: índice++ que es igual a índice=índice+1
3.2.2. While / Do While
El bucle while nos permite repetir la ejecución de una serie de instrucciones mientras que se cumpla una condición de continuidad. Su uso resulta recomendable cuando no conocemos a priori el número de iteraciones que debemos realizar. El bucle while tiene dos posibles sintaxis: while (condición de continuidad){
Instrucciones a ejecutar en forma repetitiva } do{ instrucciones a ejecutar en forma repetitiva }while(condición de continuidad); En ambos casos se itera o repite mientras que la “condición de continuidad” se cumpla, abandonándose el bucle cuando la condición se evalúa como false. En el primer caso puede ocurrir que las instrucciones interiores del bucle nunca se ejecuten (si la primera vez que se evalúa la condición resulta como false); en el segundo caso las instrucciones interiores al bucle se ejecutan al menos una vez.
Curso: BSI-03 Programación I Universidad Latina
10
Ejemplos: En el siguiente ejemplo se muestra una implementación muy sencilla del bucle while en la que se pretende imprimir los números 1, 2, 3, y 4. Puesto que conocemos a priori el número de iteraciones sería más adecuado utilizar un bucle for, pero se ha escogido este ejemplo sencillo para mostrar una primera implementación del bucle while.
En el ejemplo se declara una variable de tipo int en la línea 6 y se inicializa a 1; esta variable actuará como contador de iteraciones en el bucle. En la línea 7 se establece la condición de continuidad del bucle (se itera mientras que i<=4). La línea 9 se encarga de imprimir el valor de í y la línea 10 de incrementarlo. Un error muy frecuente cuando se codifica un bucle while es olvidar incrementar al contador (línea 10), generando un bucle infinito. En nuestro ejemplo también crearíamos un bucle infinito si olvidáramos las llaves delimitadoras del ámbito del bucle.
A continuación se muestra la forma alternativa de utilizar un bucle while : do{}while(condición); la semántica en este ejemplo es la misma que en el anterior (se imprimen los valores de 1 a 4). El detalle de la ejecución varía respecto a que la condición de continuidad se evalúa al final en lugar al comienzo del bucle.
Curso: BSI-03 Programación I Universidad Latina
11
4. EL ENTORNO DE DESARROLLO DE NETBEANS
Construcción de su primera aplicación con NetBeans. Inicialmente nos enfocaremos en aprender acerca del entorno de desarrollo de NetBeans y de algunas de las herramientas que proporciona para la construcción de aplicaciones. Aunque NetBeans cuenta con más herramientas de las que usted probablemente utilizaría en cualquier otro trabajo de desarrollo de aplicaciones (incluso más de las que aprendería a utilizar en todo este manual), limitó el enfoque a las principales herramientas que utilizara a lo largo de este manual, así como las aplicaciones que construirá con NetBeans. El entorno de desarrollo de NetBeans: Deberá iniciar el programa de NetBeans IDE 6.7.1 en Español en su computadora, con el fin de observar directamente como se organizan cada una de las áreas y como puede modificarlas y alterar la organización. Después que inicie el entorno de desarrollo, vera una ventana similar a la que se muestra en la figura 1. Cada una de las áreas tiene un propósito específico en el entorno. Puede volver a organizar estas áreas para personalizar el entorno de Desarrollo de NetBeans con el fin de que se ajuste a sus necesidades particulares de desarrollo. El panel de Workspace Cuando inicie por primera vez NetBeans, el área que se ubica en el extremo izquierdo del Entorno, Esta área se conoce como workspace y será su clave para navegar a través de los diversos componentes y partes de sus proyectos de desarrollo. El workspace muestra las partes de su aplicación en dos formas distintas:
Proyectos: Permite navegar y manipular su código fuente.
Archivos: Permite encontrar y editar cada uno de los diferentes recursos de su aplicación,
incluyendo los diseños, iconos y menús de la ventana.
Figura 1. Ventana de Apertura de NetBeans IDE.
Panel Workspace Barra de herramientas Standard Barra Build
Panel Output
Página de inicio
Curso: BSI-03 Programación I Universidad Latina
12
El panel Output El panel Output tal vez no esté visible al iniciar NetBeans por primera vez. Una vez compilada su primera aplicación, dicho panel aparecerá en la parte inferior del entorno y permanecerá abierto hasta que usted decida cerrarlo. El panel Output es el lugar donde presenta cualquier información que deba proporcionarle el programa. Además es donde usted podrá observar las instrucciones de progreso del compilador, las advertencias y los mensajes de error. Después de que cierre el panel output, este se abrirá automáticamente cuando NetBeans necesite desplegar un mensaje. El área de edición La parte del extremo derecho del entorno de desarrollo es el área de edición. Ahí es donde usted realizara toda su edición cuando utilice NetBeans; también es el lugar donde se desplegaran las ventanas necesarias para editar el código fuente, así como el lugar donde se desplegará la ventana necesaria para diseñar su aplicación. Las Barras de Menús Al ejecutar NetBeans por primera vez se desplegaran dos barras de herramientas debajo de la barra de menús. Hay muchas otras barras de herramientas disponibles, a demás puede personalizar y crear las suyas propias para adecuarlas a su mejor forma de trabajar. Las dos barras de herramientas que se abren inicialmente son las siguientes:
La barra de herramientas Standard contiene la mayoría de las herramientas estándar para abrir y
guardar archivos, cortar, copiar, pegar y para una gran variedad de comandos que son sumamente
útiles.
La barra Build le ofrece los comandos de construcción y de ejecución que seguramente utilizara
cuando desarrolle y pruebe sus aplicaciones.
Como reorganizar el entorno de NetBeans El programa ofrece una forma sencilla de reorganizar su entorno de desarrollo. La primera es el hacer clic con el botón derecho en el área de las barras de herramientas. Esta acción abre el menú contextual que se muestra en la figura 1.2, el cual permite activar y desactivar las diversas barras de herramientas.
Como volver a abrir alguna de las ventanas de NetBeans que ya no estén visibles. En el menú Ventana podrá activar cualquiera de las ventanas o paneles que no estén visibles en la pantalla de NetBeans.
Figura 2 Menú para activar y desactivar barras de herramientas
Curso: BSI-03 Programación I Universidad Latina
13
5. PRIMER PROYECTO EN JAVA
PASOS
Abra el programa NetBeans IDE 6.8 en Español
Elija en el menú Archivo la opción Proyecto Nuevo…
Elija la lista de Categorías: Java y de la lista de tipos de Proyectos Aplicación Java. Haga clic en
Siguiente >.
Curso: BSI-03 Programación I Universidad Latina
14
Elija el nombre y la ruta donde desea guardar el proyecto. Recuerde que si lo desea lo puede guardar en su llave maya, dando clic en el botón Examinar…, para buscar la ruta o dirección. Ponga el nombre HolaMundoJava. Presione el botón Terminar. Terminado el paso anterior, ha construido la función principal o programa principal que se ejecuta inicialmente al correr su programa. La pantalla que se mostrada será la siguiente:
El icono de taza de café identifica el proyecto
Es aquí esta línea donde se llama al primer formulario inicial de su programa.
A
B
C
Curso: BSI-03 Programación I Universidad Latina
15
El proyecto se habrá creado y se abrirá el IDE. Deberías de ver los siguientes componentes: La ventana de Proyectos, la cual contiene una vista de árbol de los componentes del proyecto, incluyendo los archivos fuente, las librerías de las que depende tú código y así sucesivamente. La ventana de Edición de Código, con un archivo llamado holamundojava abierto. La ventana del Navegador, la cual puedes utilizar para navegar rápidamente entre los elementos de la clase seleccionada. CREACIÓN DE FORMULARIO Posteriormente vamos a crear un formulario (pantalla) que sirva como interfaz gráfico del proyecto.
Presiona el botón derecho sobre el paquete holamundojava . Elije la opción Nuevo y
posteriormente la opción Formulario Form…
Aparecerá la siguiente ventana donde le solicita el nombre del formulario, el cuál será frmHolaMundoJava, el texto frm indica que es un formulario y HolaMundoJava que nos servirá para nombrar el formulario. Presiona el botón Terminar.
El programa guarda el formulario en forma automática dentro del proyecto. Aparecerá la siguiente ventana. Coloque de la paleta Swing un objeto Etiqueta, un Objeto Campo de Texto y un Botón.
Curso: BSI-03 Programación I Universidad Latina
16
Cambia la propiedad text y el nombre de los objetos colocados según la siguiente tabla.
Objeto Text Name
JLabel1 Nombre etiNombre
JTextField1 Dejar blanco txtNombre
JButton1 Procesar btnProcesar
Para incluir el código fuente al programa debemos presionar doble clic sobre el botón Procesar, esta acción
nos llevará al editor de código fuente, donde digitaremos la siguientes instrucciones en java.
btnProcesar
txtNombre
Curso: BSI-03 Programación I Universidad Latina
17
Presione un clic sobre el bombillo, de la lista desplegable elija Añadir “import” a javax.swing.JOptionPane.
EJECUTAR “CORRER” EL FORMULARIO Presione el botón derecho sobre cualquier parte del área de código, de la lista desplegable elija la opción Run File. La salida será la siguiente
6. ABREVIATURA DE LOS NOMBRE DE LOS CONTROLES BÁSICOS DE JAVA
Existe una convención para los nombres de los controles: Se utiliza siempre
tres letras minúsculas que indican el tipo de control, seguidas por otras
letras (La primera mayúscula, a modo de separación) libremente escogidas
por el usuario, que tienen que hacer referencia al uso que se va a dar a ese
control.
Control Abreviatura
Formulario JFrame frm
Etiqueta eti
Botón btn
Botón de 2 posiciones btn
Casilla de activación chk
Botón de opción opc
Grupo de botones gropc
Lista desplegable cbo
Campo de texto txt
Área de texto txt
Tabla Tbl
Lista de la AWT lst
Curso: BSI-03 Programación I Universidad Latina
18
7. EJERCICIOS EN NETBEANS 6.9.1 EN ESPAÑOL
OBJETIVO:
Elaborar la interfaz gráfica de los ejercicios realizados en las prácticas de Diagramas de Flujos (D-F)
realizados en las primeras semanas de programación I.
7.1. Creación del proyecto
Abra el programa NetBeans IDE 6.8 en Español
Elija en el menú Archivo la opción Proyecto Nuevo…
Elija la lista de Categorías: Java y de la lista de tipos de Proyectos Aplicación Java. Haga clic en
Siguiente >.
Elija el nombre y la ruta donde desea guardar el proyecto. Recuerde que si lo desea lo puede
guardar en su llave maya, dando clic en el botón Examinar…, para buscar la ruta o dirección.
Ponga el nombre ProyectoI. Presione el botón Terminar.
Curso: BSI-03 Programación I Universidad Latina
19
Al presionar el botón Terminar, ha construido la función principal o programa principal que se ejecuta
inicialmente al correr su programa. La pantalla que se mostrada será la siguiente:
7.2. Creación de formulario principal (menú para acceder a los diferentes formularios)
Vamos a crear un formulario que sirva como menú para acceder a todas las pantallas o formularios
de los ejercicios realizados con Diagramas de Flujo pero realizados en Java. Para ello haz clic en el
botón derecho sobre el paquete proyectoi, elije la opción New y posteriormente la opción JFrame
Form…
Aparecerá la ventana donde le solicita el nombre del formulario, el cuál será frmMenu, el texto frm
indica que es un formulario y menú que nos servirá como el menú para acceder a los demás
formularios ó pantallas de cada ejercicio.
Nota: Este formulario es guardado en forma automática dentro del ProyectoI creado.
El icono de taza de café identifica el proyecto
Es aquí esta línea donde se llama al primer formulario inicial de su programa.
Curso: BSI-03 Programación I Universidad Latina
20
Aparecerá la siguiente ventana
Coloque sobre el frmMenu un objeto jPanel que seleccionará de la Paleta Contenedores.
Ajuste el tamaño del JPanel al tamaño del frmMenu. (Como las formas de Word)
Seleccione el objeto JPanel
En la venta de propiedades de este objeto haz clic
sobre la propiedad border y cambia los siguiente:
Al elegir la propiedad border donde están los tres
puntitos *…+, se abrirá la siguiente ventana, elige
de los bordes disponibles la opción TitleBorder
Curso: BSI-03 Programación I Universidad Latina
21
, esta opción permite poner un titulo y un borde al JPanel. Escribe en el espacio Title lo
siguiente: Menú de Opciones
Coloca 10 controles JButton sobre el JPanel. Estos se encuentran en la paleta Swing
Cambia el nombre de los botones por un nombre significativo. Recuerda las abreviaturas dadas para cada tipo de
control la del JButton es: btn, luego escribe nombre de significativo de cada botón sin dejar espacios y respetando
la mayúscula a manera de separación.
Para cambiar el nombre del primer botón presiona el botón derecho del Mouse sobre el botón y se desplegará un
menú elige la opción change variable name y sustituye JButton1 por btnInteresGanado.
7.3. Creación del formulario para el ejercicio cálculo de interese ganado
Suponga que un individuo desea invertir su capital en un banco y desea saber cuánto dinero
ganara después de un mes si el banco paga a razón de 2% mensual la tasa de interés. Cree un
programa en NetBeans que resuelva este enunciado.
Para crear un nuevo formulario del tipo formulario JFrame, presiona el botón derecho sobre el paquete
proyectoi . Elije la opción Nuevo y posteriormente la opción Formulario Form…
Escribe el nombre al formulario (frmInteresGanado). Luego presiona el botón Terminar.
Propiedad Text Propiedad Name
Calcular interés ganado btnInteresGanado
Calculo Total del Salario btnCalcularSalario
Presupuesto Hospital btnPresupuestoHospital
Ganancia Articulo btnGananciaArticulo
Inversión Dinero btnInversionDinero
Leer dos números btnLeer
Tipo de Jubilación btnJubilación
Llantera “Ponchadas” btnLlantera
Venta de Naranjas btnNaranjas
Color bolita btnBolitas
Curso: BSI-03 Programación I Universidad Latina
22
En el paquete proyectoi se agrego el archivo del formulario: frmInteresGanado.
Ya hay dos formularios en el proyecto frmMenu y frmInteresGanado.
Coloque sobre el frmInteresGanado un objeto JPanel que escogerá en la Paleta Contenedores Swing
Ajuste el tamaño del JPanel.
Seleccione el objeto JPanel, en la venta de propiedades de este objeto haz clic sobre la propiedad
border y cambia lo siguiente:
Al elegir la propiedad border…, se abrirá la siguiente ventana, elige de los bordes disponibles la opción
TitleBorder , esta opción permite poner un titulo y un borde al JPanel. Escribe en el
espacio Title lo siguiente Cálculo de interés ganado
Agrega los objetos sobre el JPanel: cuatro JLabel, tres JTextField y un JButton de la paleta Swing.
El JPanel tomará este
aspecto
Curso: BSI-03 Programación I Universidad Latina
23
(Dentro del CD de programación I hay una carpeta con el nombre Imágenes, el Jlabel4 en la propiedad icono… Importar puede asignarle la imagen que muestra la siguiente figura del formulario terminado.)
Cambia los text y el nombre según la siguiente tabla.
Objeto Text Name Editable
JLabel1 Capital invertido etiCapital
JLabel2 Interés ganado etiInteres
JLabel3 Total en el banco etiTotal
JLabel4 etiImagen
JTextField1 txtCapital
JTextField2 txtInteres False
JTextField3 txtTotal False
JButton1 Calcular btnCalcular
JFrame La propiedad Title: Interés ganado
Hasta el momento hemos creado la Interfaz Gráfica de Usuario (IGU) que es la pantalla con que el
usuario interactúa, nos falta agregar el código o instrucciones en el lenguaje java que serán las
encargadas de realizar las peticiones del usuario. Para ello utilizaremos el botón etiquetado Calcular.
Para incluir el código fuente al programa debemos presionar clic derecho sobre el botón Calcular, esta
acción desplegará un menú de opciones como se muestra en la figura. Debe elegir la opción
Events\Action\actionPerformed lo que nos llevará al editor donde digitaremos la instrucciones en
java. (Ó podemos darle doble clic encima del botón calcular)
Curso: BSI-03 Programación I Universidad Latina
24
Luego de realizado el paso anterior, se presenta la siguiente pantalla
NetBeans se encargó de incluir el código inicial para nuestro objetivo (el texto que se encuentra en las líneas
sombreadas de celeste), borramos la línea //TODO add your handling code here: añadir su código aquí. Y digitamos el
siguiente código:
private void btnCalcularActionPerformed(java.awt.event.ActionEvent evt) {
//Declaración e Inicialización de variables double capital=0.0; //declara e inicializa en 0 la variable capital double interes=0.0; //declara e inicializa en 0 la variable interes double total=0.0; //declara e inicializa en 0 la variable total //Lectura de datos de entrada //Captura la información del la caja de texto capital y se la asigna a //la variable capital convertida en dobule capital=Double.parseDouble(txtCapital.getText()); //Procesos interes=capital*0.02; total=capital+interes; //Salida de resultados txtInteres.setText(String.valueOf(interes)); txtTotal.setText(String.valueOf(total)); }
Para utilizar la instrucción que muestra el
mensaje, antes se debe utilizar la librería
correspondiente.
Para “correr” el programa y utilizarlo como
“usuario” presionamos clic derecho en
cualquier parte del código para que se
despliegue un menú emergente del cual
escogeremos la opción “Run File”. Esta
acción desplegará la siguiente pantalla en la
cual introducimos una cantidad en el capital
y luego presionamos el botón calcular para
que muestre el resultado del cálculo del
interés y el monto total en el banco.
Curso: BSI-03 Programación I Universidad Latina
25
Desde la barra Generar de NetBeans se puede correr el programa o función principal con los iconos
Pero para ello se debe incluir el código necesario para que despliegue el formulario del menú que accede a los
programas.
7.4. Pasos para cargar una ventana desde la función principal Main:
1. Ubicarse en el archivo frmMenu del panel izquierdo. En la ventana del código fuente.
2. Buscar el código fuente donde se ubica la función que “carga” el formulario
3. Seleccionar y copiar (Ctrl + C) la instrucción que es la encargada de cargar el formulario
4. Ubiarse en el archivo Main del panel izquierdo
5. Sustituir la instrucción //TODO code application logic here por la instrucción que se encuentra en el
portapapeles (new frmMenu().setVisible(true);). Utilizar Ctrl + V.
6. Corra el programa, desde la barra Generar de NetBeans.
Curso: BSI-03 Programación I Universidad Latina
26
7.5. Acceder desde el Menú Principal al Formulario Interés Ganado
Pasos para cargar desde el botón Calcular interés ganado del formulario Menú al formulario
frmInteresGanado.
1. Ubicarse en la ventana del código fuente del frmInteresGanado.
2. Copiar en el portapapeles la instrucción que “carga el formulario”
new frmInteresGanado().setVisible(true);
3. Ubicarse en la ventana diseño del formulario frmMenu
4. Presionar doble clic sobre el botón Calcular interés ganado
5. Pegar el código previamente copiado en el portapapeles de Windows
6. Correr el programa.
7.6.
7.7. Creación del formulario para el ejercicio calculo de salario.
Un vendedor recibe un sueldo base más un 10% extra por comisión de sus ventas, el vendedor desea saber cuánto dinero obtendrá por concepto de comisiones por las tres ventas que realiza en el mes y el total que recibirá en el mes tomando en cuenta su sueldo base y comisiones.
Cree un nuevo formulario JFrame con nombre: frmCalculoSalario.
Coloque sobre el frmCalculoSalario un objeto JPanel que escogerá en la Paleta Contenedores Swing .
Ajuste el tamaño del JPanel al tamaño del frmCalculoSalario.
Agregue los controles necesarios y cambie las propiedades Text y Name de cada control.
Objeto Propiedad Text Propiedad Name JLabel1 Monto salario base
JLabel2 Monto venta 1
JLabel3 Monto venta 2
JLabel4 Monto venta 3
JLabel5 Comisión obtenida de ventas
JLabel6 Salario total obtenido
Al presionar con el mouse este
botón se cargue el formulario
frmCalculoInteres
Si al cerrar el formulario frmInteresGanado, se
cierra también el formulario frmMenu. Debes
cambiar la propiedad defaultCloseOperation (del
frmInteresGando) por Dispose para que el menú
se mantenga visible.
Curso: BSI-03 Programación I Universidad Latina
27
JTextField1 txtSalarioBase
JTextField2 txtVenta1
JTextField3 txtVenta2
JTextField4 txtVenta3
JTextField5 txtComsion
JTextField6 txtSalarioTotal
JButton1 Calcular salario total btnCalcular
El objetivo de este sencillo programa es capturar el monto del salario base, el monto de cada una de las comisiones. Luego sumar las comisiones, calcular el 10% del resultado de la suma de las comisiones. Para el salario final sumar el salario base más el monto del porcentaje obtenido de las comisiones. private void btnCalcularActionPerformed(java.awt.event.ActionEvent evt) { // Declaracion e Inicialización de Variables double salarioBase=0.0, venta1=0.0,venta2=0.0, venta3=0.0; double comision=0.0, salarioTotal=0.0; //Lectura de datos de entrada salarioBase = Double.parseDouble(txtSalarioBase.getText()); venta1=Double.parseDouble(txtVenta1.getText()); venta2=Double.parseDouble(txtVenta2.getText()); venta3=Double.parseDouble(txtVenta3.getText()); //Proceso cálculo de comisión comision=(venta1+venta2+venta3)*0.10; //Proceso calculo del salario total salarioTotal=salarioBase+comision; //Salida de datos txtComision.setText(String.valueOf(comision)); txtSalarioTotal.setText(String.valueOf(salarioTotal)); } Detalle de las instrucciones:
// Declaración e Inicialización de Variables double salarioBase=0.0, venta1=0.0,venta2=0.0, venta3=0.0; double comision=0.0, salarioTotal=0.0;
Las instrucciones anteriores declaran 6 variables de tipo double y las inicializa a 0, como las tres variables son del mismo tipo se pueden declarar en la misma línea separada por coma y al final lleva punto y coma ;
//Lectura de datos de entrada salarioBase = Double.parseDouble(txtSalarioBase.getText()); venta1=Double.parseDouble(txtVenta1.getText()); venta2=Double.parseDouble(txtVenta2.getText()); venta3=Double.parseDouble(txtVenta3.getText());
En resumen, captura el salario base digitado en la caja de texto txtSalarioBase, lo convierte en double y se lo asigna a la variable salarioBase. Hace lo mismo con los montos de cada una de las tres ventas.
//Proceso Cálculo de comisión comision=(venta1+venta2+venta3)*0.10; //Proceso calculo del salario total salarioTotal=salarioBase+comision;
Después de tener el valor del salario base y el valor de cada una de las ventas realizadas en el mes que se capturaron en las instrucciones anteriores. Calcula el monto de la comisión y el monto total del salario.
Curso: BSI-03 Programación I Universidad Latina
28
//Salida de datos txtComision.setText(String.valueOf(comision)); txtSalarioTotal.setText(String.valueOf(salarioTotal));
Las dos instrucciones anteriores muestran el valor de la comisión y el valor del salario total en las cajas correspondiente, pero como las variables comisión y salarioTotal son double y las cajas solo pueden mostrar String “cadena” las convierte primero en cada, antes de mostrarlas utilizando: String.valueOf().
Para “correr” el programa y utilizarlo como “usuarios” presionamos clic derecho en cualquier parte del código para que se despliegue un menú del cual escogeremos la opción “Run File”. Esta acción desplegará la ventana en la cual introducimos un salario base en la caja de texto salario base y luego introducir los valores de cada una de las ventas realizadas en el mes y por último presionamos el botón calcular para que muestre el resultado de la comisión y del salario total.
Agregue al botón Cálculo total del salario del formulario frmMenú el código necesario para que permita mostrar el formulario frmCalculoSalario al presionar el botón.
7.8. Formulario presupuesto hospital
En un hospital existen tres áreas. Ginecología, Pediatría, Traumatología. El presupuesto anual del hospital se reparte conforme a la siguiente tabla:
ÁREA PORCENTAJE DE PRESUPUESTO
Ginecología 40%
Traumatología 35%
Pediatría 25%
Cree un programa que permita obtener la cantidad de dinero que recibirá cada área, para cualquier monto presupuestal.
Cambia la propiedad Text y el Name de cada control según la siguiente tabla.
Objeto Text Name
JLabel1 Monto del presupuesto etiPresupuesto
JLabel2 Ginecología 40% etiGinecologia
JLabel3 Pediatría 25% etiPediatria
JLabel4 Traumatología 35% etiTraumatologia
JTextField1 txtPresupuesto
JTextField2 txtGinecologia
JTextField3 txtPediatria
JTextField4 txtTraumatologia
JButton1 Calcular btnCalcular
Curso: BSI-03 Programación I Universidad Latina
29
Controles utilizados en el formulario: 1 JPanel, 4 JLabel, 4 JTextField y un 1 JButton
Código fuente
private void btnCalcularActionPerformed(java.awt.event.ActionEvent evt) {
double presupuesto=0, ginecologia=0, pediatria=0, traumatologia=0;
presupuesto=Double.parseDouble(txtPresupuesto.getText());
ginecologia=presupuesto*0.40;
pediatria=presupuesto*0.25;
traumatologia=presupuesto*0.35;
txtGinecologia.setText(String.valueOf(ginecologia));
txtPediatria.setText(String.valueOf(pediatria));
txtTraumatologia.setText(String.valueOf(traumatologia));
}
Descripción de sentencias o instrucciones: double presupuesto=0, ginecologia=0, pediatria=0, traumatologia=0; //Declara tres variables de tipo double y las inicializa con valor 0 presupuesto=Double.parseDouble(txtPresupuesto.getText()); Captura de la cajita de texto txtPresupuesto el valor, lo convierte en doublé y se lo asigna a la variable presupuesto. ginecologia=presupuesto*0.40; pediatria=presupuesto*0.25; traumatologia=presupuesto*0.35; Calcula el % correspondiente a cada área según lo establecido por el enunciado del problema txtGinecologia.setText(String.valueOf(ginecologia)); txtPediatria.setText(String.valueOf(pediatria)); txtTraumatologia.setText(String.valueOf(traumatologia)); Muestra en las cajitas de texto los valores calculados de los porcentajes, pero antes los convierte en Strings.
7.9. Formulario ganancia artículo.
Ejercicio #7 del folleto Introducción al desarrollo de los Algoritmos
El dueño de una tienda compra un artículo a un precio determinado. Obtener el precio en que lo debe vender para obtener una ganancia del 30%. Cambia la propiedad Text y el Name de cada control según la siguiente tabla.
Objeto Text Name
JLabel1 Precio Compra: etiPrecioCompra
JLabel2 Ganancia30%: etiGanancia
JLabel3 Precio Venta: etiPrecioVenta
JTextField1 txtPreciCompra
JTextField2 txtGanancia
JTextField3 txtPrecioVenta
JButton1 Calcular btnCalcular
JButton2 Limpiar btnLimpiar
Controles utilizados en el formulario: 1 JPanel, 3 JLabel, 3 JTextField y 2 JButton.
Código fuente
private void btnCalcularActionPerformed(java.awt.event.ActionEvent evt) { double precioCompra=0; double precioVenta=0; double ganancia=0;
Curso: BSI-03 Programación I Universidad Latina
30
precioCompra = Double.parseDouble(txtPrecioCompra.getText()); ganancia = precioCompra*0.30; precioVenta = precioCompra + ganancia; txtGanancia.setText(String.valueOf(ganancia)); txtPrecioVenta.setText(String.valueOf(precioVenta)); } Descripción de sentencias o instrucciones: double precioCompra=0; double precioVenta=0; double ganancia=0; Declara tres variables de tipo double y las inicializa con valor 0 precioCompra=Double.parseDouble(txtPrecioCompra.getText()); Captura de la cajita de texto txtPrecioCompra el valor ingresado por el usuario, lo convierte en double y se lo asigna a la variable precioCompra. ganancia = precioCompra*0.30; precioVenta = precioCompra + ganancia; Calcula el % correspondiente a la ganancia y calcula el valor al que debe vender el artículo a los clientes. txtGanancia.setText(String.valueOf(ganancia)); txtPrecioVenta.setText(String.valueOf(precioVenta)); Muestra en las cajitas de texto los valores calculados: la ganancia y el precio de venta. private void btnLimpiarActionPerformed(java.awt.event.ActionEvent evt) { txtPrecioCompra.setText(""); txtGanancia.setText(""); txtPrecioVenta.setText(""); } Limpia el contenido de las tres cajitas de texto, para hace la prueba con otro artículo
7.10. Formulario inversión de dinero
Ejercicio #8 del folleto Introducción al desarrollo de los Algoritmos.
Tres personas deciden invertir su dinero para fundar una empresa. Cada una de ellas invierte una
cantidad distinta. Obtener el porcentaje que cada quien invierte con respecto a la cantidad total
invertida. Cambia la propiedad Text y el Name de cada control según la siguiente tabla.
Objeto Text Name
JTextField1 txtMonto1
JTextField2 txtMonto2
JTextField3 txtMonto3
JTextField4 txtPorc1
JTextField5 txtPorc2
JTextField6 txtPorc3
JTextField7 txtTotal
JButton1 Calcular btnCalcular
JButton2 Limpiar btnLimpiar
private void btnCalcularActionPerformed(java.awt.event.ActionEvent evt) { double monto1=0,monto2=0,monto3=0, total=0; double porc1=0,porc2=0,porc3=0;
Declara las variables para guardar el monto invertido por cada persona, y los porcentajes que corresponden a cada monto.
Curso: BSI-03 Programación I Universidad Latina
31
monto1=Double.parseDouble(txtMonto1.getText()); monto2=Double.parseDouble(txtMonto2.getText()); monto3=Double.parseDouble(txtMonto3.getText()); total=monto1+monto2+monto3; porc1=monto1*100/total; porc2=monto2*100/total; porc3=monto3*100/total; txtTotal.setText(String.valueOf(total)); txtPorc1.setText(String.valueOf(Math.rint(porc1))); txtPorc2.setText(String.valueOf(Math.rint(porc2))); txtPorc3.setText(String.valueOf(Math.rint(porc3))); } private void btnLimpiarActionPerformed(java.awt.event.ActionEvent evt) { txtMonto1.setText(""); txtMonto2.setText(""); txtMonto3.setText(""); txtPorc1.setText(""); txtPorc2.setText(""); txtPorc3.setText(""); txtTotal.setText(""); }
7.11. Formulario comparar dos números
Leer 2 números, si son iguales que los multiplique, sí el primero es mayor que el segundo que los
reste y si no que los sume.
Cambia la propiedad Text y el Name de cada control según la siguiente tabla.
Controles utilizados en el formulario: 1 JPanel, 2 JLabel, 2 JTextField y 2
JButton.
Código fuente
Objeto Text Name
JTextField1 txtOperación
JTextField2 txtResultado
JButton1 Calcular btnCalcular
JButton2 Limpiar btnLimpiar
Captura los montos que fueron digitados para cada uno de los inversionistas.
Calcula el total de lo invertido por las tres personas
Calcula el porcentaje que invierte cada persona, con las sencilla regla de tres.
Monto1 X% Total 100%
X%=Monto1*100/total
Pone el texto .setText en las cajitas. Los resultados de los cálculos. Math.rint redondea los decimales.
Limpia las cajitas de texto para realizar nuevo
cálculos.
Curso: BSI-03 Programación I Universidad Latina
32
if(num1 = = num2) { resultado=num1*num2; txtOperacion.setText("Multiplicación"); } else if(num1 > num2) { resultado=num1-num2; txtOperacion.setText("Resta"); } else{ resultado=num1+num2; txtOperacion.setText("Suma"); } txtResultado.setText(String.valueOf(resultado)); } private void btnLimpiarActionPerformed(java.awt.event.ActionEvent evt) { txtOperacion.setText(""); txtResultado.setText(""); }
7.12. Formulario jubilación
El IMSS requiere clasificar a las personas que se jubilaran en el año de 1997. Existen tres tipos de jubilaciones: por
edad, por antigüedad joven y por antigüedad adulta. Las personas adscritas a la jubilación por edad deben tener 60
años o más y una antigüedad en su empleo de menos de 25 años. Las personas adscritas a la jubilación por antigüedad
joven deben tener menos de 60 años y una antigüedad en su empleo de 25 años o más. Las personas adscritas a la
jubilación por antigüedad adulta deben tener 60 años o más y una antigüedad en su empleo de 25 años o más.
Determinar por medio de un programa en java en qué tipo de jubilación quedara adscrita una persona.
Código fuente private void btnProcesarActionPerformed(java.awt.event.ActionEvent evt) { int edad=0, antiguedad=0; edad=Integer.parseInt(txtEdad.getText()); antiguedad=Integer.parseInt(txtAntiguedad.getText()); if((edad >= 60) && (antiguedad < 25)) txtTipo.setText("La jubilación es por: EDAD."); else if((edad >= 60) && (antiguedad > 25)) txtTipo.setText("La jubilación es por: EDAD ADULTA."); else if((edad < 60) && (antiguedad > 25)) txtTipo.setText("La jubilación es por: ANTUGÜEDAD JOVÉN."); else txtTipo.setText("No tiene derecho a jubilarse"); }
Objeto Text Name
JTextField1 txtEdad
JTextField2 txtAntiguedad
JTextField3 txtTipo
JButton1 Calcular btnProcesar
JButton2 Limpiar btnLimpiar
Si el valor de num1 es igual al valor de num2 Multiplique los dos números y guarda el resultado en la variable resultado.
Sino preguntar si el valor de num1 es menor que num2 Reste los dos números y guarda el resultado en la variable resultado.
Sino Sume los dos números y guarda el resultado en la variable resultado.
Limpia las cajitas de texto para realizar nuevo cálculos.
Declara las variables necesarias
Captura los datos de entrada de las cajitas de texto
Utiliza un Y lógico Si la edad es mayor o igual a 60 y los años trabajados son menor a 25 años, Imprime la jubilación es por EDAD. Sino …
Curso: BSI-03 Programación I Universidad Latina
33
private void btnLimpiarActionPerformed(java.awt.event.ActionEvent evt) { txtEdad.setText(""); txtAntiguedad.setText(""); txtTipo.setText(""); }
7.13. Formulario llantera
En una llantera se ha establecido una promoción de las llantas marca "Ponchadas", dicha promoción consiste en lo siguiente
Si se compran menos de cinco llantas el precio es de ¢ 3 000 cada una,
¢ 2 500 si se compran de cinco a 10 y de
¢ 2 000 si se compran más de 10
Obtener la cantidad de dinero por cada una de las llantas que compra y el total de la compra.
Objeto Text Name
JTextField1 txtCantidad
JTextField2 txtPrecio
JTextField3 txtTotal
JButton1 Calcular btnProcesar
JButton2 Limpiar btnLimpiar
Código fuente private void btnProcesarActionPerformed(java.awt.event.ActionEvent evt) { int cantidad=0, precio=0, total=0; cantidad=Integer.parseInt(txtCantidad.getText()); if(cantidad<5) precio=3000; else if((cantidad>=5)&&(cantidad<=10)) precio=2500; else precio=2000; total=precio*cantidad; txtPrecio.setText(String.valueOf(precio)); txtTotal.setText(String.valueOf(total)); }
7.14. Formulario venta de manzanas
Objeto Text Name
JTextField1 txtKilos JTextField2 txtPrecio
JTextField3 txtDescuento
JTextField4 txtTotal
JButton1 Calcular btnProcesar
JButton2 Limpiar btnLimpiar
Limpia las cajitas de texto para volver a usarlas
Venta de Manzanas
Curso: BSI-03 Programación I Universidad Latina
34
Código fuente private void btnProcesarActionPerformed(java.awt.event.ActionEvent evt) { double kilos=0, precio=0, descuento=0, total=0; kilos=Integer.parseInt(txtKilos.getText()); precio=Integer.parseInt(txtPrecio.getText()); total=kilos*precio; if((kilos>0)&&(kilos<=2)) descuento=0; else if((kilos>=3)&&(kilos<=5)) descuento=total*0.10; else if((kilos>=6)&&(kilos<=10)) descuento=total*0.15; else descuento=total*0.20; total=total-descuento; txtDescuento.setText(String.valueOf(descuento)); txtTotal.setText(String.valueOf(total)); }
7.15. Formulario color de bolita
Ejercicio #25 del folleto Introducción al desarrollo de los Algoritmos.
Código fuente private void btnProcesarActionPerformed(java.awt.event.ActionEvent evt) { Random rnd = new Random(); double compra=0,descuento=0, total=0; int color=0; if(txtCompra.getText().equals("")) JOptionPane.showMessageDialog(null,"Digite el monto de compra."); else{ compra=Double.parseDouble(txtCompra.getText()); color= (int)(rnd.nextDouble() * 5.0); switch(color) { case 0: //el cero será usuado para el color blanco descuento=0; txtColor.setText("Blanco"); break; case 1: //el uno será usuado para el color verde descuento=compra*0.10; txtColor.setText("Verde"); break; case 2: //el dos será usuado para el color amarillo descuento=compra*0.25; txtColor.setText("Amarillo");
Objeto Text Name
JTextField1 txtCompra JTextField2 txtColor
JTextField3 txtDescuento
JTextField4 txtTotal
JButton1 Calcular btnProcesar
Color adquiere un valor aleatorio, es decir al azar escogido por la
PC, entre el rango 0 y 5 que serán
sustituidos por los colores del
enunciado.
Curso: BSI-03 Programación I Universidad Latina
35
break; case 3: //el tres será usuado para el color azul descuento=compra*0.50; txtColor.setText("Azul"); break; case 4: //el cero será usuado para el color rojo descuento=compra; txtColor.setText("Rojo"); break; } total=compra-descuento; txtDescuento.setText(String.valueOf(descuento)); txtTotal.setText(String.valueOf(total)) ; } } Para corregir los errores que presenta el código, es decir donde presenta las x rojas deben incluir las libreras necesarias. Es decir para poder utilizar las ventanas de mensajes incluye la librería import javax.swing.JOptionPane;.
Para utilizar los números aleatorios incluye la librería import java.until.Random;.
Curso: BSI-03 Programación I Universidad Latina
36
8. UTILIZACIÓN DE LAS CAJAS DE TEXTO PARA CAPTURA DE DATOS
Los controles campos de texto se utilizan frecuentemente en los programas para obtener los datos del usuario necesarios para procesar la información. Estos controles tienen gran cantidad de métodos entre algunos de los más usados getText() y setText(). Estos métodos se utilizan para obtener y poner los datos que contienen respectivamente, pero al ser controles campos de texto solo se obtiene de ellos datos tipo texto o se pone en ellos datos tipo texto, aunque la información sea numérica NetBeans la trata como texto. Por lo tanto debemos utilizar las funciones que nos permiten convertir los datos que debemos obtener o poner en las cajas de texto. Ejemplo:
Este formulario nos permite obtener el nombre y salario actual de un trabajador, calcula el 30% de aumento en el salario y mostrar cual es su nuevo salario.
El código para realizar este enunciado es el siguiente:
También tenemos la función Integer.parseInt(); para convertir a un tipo int.
Curso: BSI-03 Programación I Universidad Latina
37
9. PRIMEROS PROGRAMAS
Ejercicio 1: Realice un programa en java con las siguientes características: La ventana principal tendrá los siguientes elementos: Una etiqueta que contenga su nombre. Nombre de la etiqueta: etiNombre Una etiqueta que contenga su ciudad. Nombre de la etiqueta: etiCiudad Un botón con el texto “Ocultar Nombre”. Nombre del botón: btnOcultarNombre
Un botón con el texto “Visualizar Nombre”. Nombre del botón: btnVisuNombre Un botón con el texto “Ocultar Ciudad”. Nombre del botón: btnOcultarNombre Un botón con el texto “Visualizar Ciudad”. Nombre del botón: btnVisuCiudad
El funcionamiento del programa será el siguiente: Cuando se pulse el botón btnOcultarNombre, se debe ocultar la etiqueta etiNombre. Cuando se pulse el botón btnVisuNombre, se debe visualizar la etiqueta etiNombre. Cuando se pulse el botón btnOcultarCiudad, se debe ocultar la etiqueta etiCiudad. Cuando se pulse el botón btnVisuCiudad, se debe visualizar la etiqueta etiCiudad. Para hacer esto debe programar el evento actionPerformed de cada botón. Usará el método setVisible de cada etiqueta para visualizarlas u ocultarlas.
Ejercicio 2: Creará un programa java cuya ventana principal contenga los siguientes componentes: Un cuadro de texto. El nombre será txtTexto. Una etiqueta vacía (sin texto dentro). El nombre será etiTexto1. Otra etiqueta vacía (sin texto dentro). El nombre será etiTexto2. Un botón con el texto “Traspasa 1”. El nombre será btnTraspasa1. Un botón con el texto “Traspasa 2”. El nombre será btnTraspasa2. El programa funcionará de la siguiente forma: Cuando el usuario pulse el botón “Traspasa 1”, lo que se haya escrito dentro del cuadro de texto se copiará dentro de la etiqueta 1. Cuando el usuario pulse el botón “Traspasa 2”, lo que se haya escrito dentro del cuadro de texto se copiará dentro de la etiqueta 2. Para hacer esto programará el evento actionPerformed de cada botón. Usará el método setText para situar el texto en la etiqueta, y getText para recoger el texto del cuadro de texto.
Ejercicio 3: Se pide que realice un programa en java cuya ventana principal incluya los siguientes componentes: Un cuadro de texto llamado txtTexto. Una etiqueta vacía llamada etiTexto. Un botón con el texto “Vaciar” llamado btnVaciar. El programa funcionará de la siguiente forma: Cuando el usuario escriba en el cuadro de texto txtTexto, lo que escriba pasará inmediatamente a la etiqueta etiTexto. (Tendrá que programar el evento keyPressed del cuadro de texto) Cuando el usuario pulse el botón “Vaciar” el texto contenido en el cuadro de texto y en la etiqueta se borrará. (Tendrá que programar el evento actionPerformed) Tendrá que usar el método setText para colocar texto en la etiqueta y usar el método getText para recoger el texto escrito en el cuadro de texto.
Curso: BSI-03 Programación I Universidad Latina
38
Ejercicio 4: Se pide que realice un programa en java cuya ventana principal contenga los siguientes elementos:
- Un cuadro de texto llamado txtNombre. - Un cuadro de texto llamado txtCiudad. - Una etiqueta llamada txtFrase. - Un botón con el texto “Aceptar” llamado btnAceptar. - Un botón con el texto “Desactivar” llamado btnDesactivar. - Un botón con el texto “Activar” llamado btnActivar.
El programa funcionará de la siguiente forma:
- El usuario introducirá un nombre en el cuadro de texto txtNombre. Por ejemplo “Juan”. - El usuario introducirá una ciudad en el cuadro de texto txtCiudad. Por ejemplo “Santa Cruz”. - Cuando el usuario pulse el botón “Aceptar”, entonces aparecerá un mensaje en la etiqueta llamada
txtFrase indicando como se llama y donde vive. Por ejemplo: Usted se llama Juan y vive en Santa Cruz. - Cuando el usuario pulse el botón “Desactivar”, entonces los dos cuadros de texto se desactivarán.
Cuando el usuario pulse el botón “Activar”, los dos cuadros de texto se volverán a activar.
Tendrá que programar el evento actionPerformed de los botones.
Tendrá que usar la concatenación de cadenas. Recuerde que se pueden concatenar cadenas a través del operador +.
Tendrá que usar el método setText para colocar el texto en la etiqueta y el método getText para recoger el texto de cada cuadro de texto.
Tendrá que usar el método setEnabled para activar o desactivar cada cuadro de texto.
Ejercicio 5: Debe realizar un programa java cuya ventana principal contenga los siguientes elementos: - Cuatro etiquetas, conteniendo distintas palabras cada una. Puede llamarlas: etiPal1, etiPal2, etiPal3
y etiPal4. - Otra etiqueta que contenga el texto “Ocultar”. Esta etiqueta se llamará etiOcultar y tendrá un
tamaño más grande que las otras y un color de fondo. El programa debe funcionar de la siguiente forma:
- Cuando el puntero del ratón “sobrevuele” la etiqueta etiOcultar, las etiquetas con las palabras deben desaparecer.
- Cuando el puntero del ratón salga de la superficie de la etiqueta etiOcultar, entonces las etiquetas con las palabras volverán a aparecer.
Tendrá que programar los eventos mouseEntered y mouseExited para que el programa detecte cuando el ratón entra o sale de la etiqueta etiOcultar. Debe usar el método setVisible de las etiquetas para ocultarlas o visualizarlas.
Ejercicio 6: Debe realizar un programa java cuya ventana principal contenga los siguientes elementos: - Una etiqueta que contenga su nombre. Esta etiqueta se llamará etiNombre. Esta etiqueta debe
tener un color de fondo. - Un botón con el texto “Esquina”. Este botón se llamará btnEsquina. - Un botón con el texto “Centro”. Este botón se llamará btnCentro. - Un botón con el texto “Agrandar”. Este botón se llamará btnAgrandar. - Un botón con el texto “Achicar”. Este botón se llamará btnAchicar.
Curso: BSI-03 Programación I Universidad Latina
39
El programa debe funcionar de la siguiente forma: - Cuando el usuario pulse el botón “Esquina”, la etiqueta etiNombre se colocará en la esquina de la ventana. - Cuando el usuario pulse el botón “Centro”, la etiqueta etiNombre se colocará en el centro de la ventana. - Cuando el usuario pulse el botón “Agrandar”, la etiqueta etiNombre cambiará de tamaño, agrandándose. - Cuando el usuario pulse el botón “Achicar”, la etiqueta etiNombre cambiará de tamaño, empequeñeciéndose. - Cuando el usuario lleve el puntero sobre uno de los botones, el botón cambiará de tamaño agrandándose.
Cuando el puntero salga del botón, el botón volverá a su tamaño normal.
Debe programar los eventos actionPerformed, mouseEntered y mouseExited para los botones. Tendrá que usar el método setLocation para cambiar la posición de la etiqueta. Este método recibe como parámetro la posición x e y donde situará el componente. Tendrá que usar el método setSize para cambiar el tamaño de la etiqueta y de los botones. Este método recibe como parámetro el ancho y alto del componente. La propiedad preferredSize permite definir un tamaño inicial a cada componente de la ventana.
Ejercicio 7 Se pide realizar un programa java que tenga los siguientes elementos en la ventana principal:
- Una etiqueta con el texto que quiera. Esta etiqueta se llamará etiTexto. - Un botón con el texto “Azul”. Este botón se llamará btnAzul. - Un botón con el texto “Rojo”. Este botón se llamará btnRojo. - Un botón con el texto “Verde”. Este botón se llamará btnVerde. - Un botón con el texto “Fondo Azul”. Este botón se llamará btnFondoAzul. - Un botón con el texto “Fondo Rojo”. Este botón se llamará btnFondoRojo. - Un botón con el texto “Fondo Verde”. Este botón se llamará btnFondoVerde. - Un botón con el texto “Transparente”. Este botón se llamará btnTransparente. - Un botón con el texto “Opaca”. Este botón se llamará btnOpaca.
El programa debe funcionar de la siguiente forma:
- Cuando se pulse el botón “Azul”, el texto de la etiqueta se pondrá de color azul. - Cuando se pulse el botón “Rojo”, el texto de la etiqueta se pondrá de color rojo. - Cuando se pulse el botón “Verde”, el texto de la etiqueta se pondrá de color verde. - Cuando se pulse el botón “Fondo Azul”, el fondo de la etiqueta se pondrá de color azul. - Cuando se pulse el botón “Fondo Rojo”, el fondo de la etiqueta se pondrá de color rojo. - Cuando se pulse el botón “Fondo Verde”, el fondo de la etiqueta se pondrá de color verde. - Cuando se pulse el botón “Transparente”, la etiqueta dejará de ser opaca. - Cuando se pulse el botón “Opaca”, se activará la propiedad opaca de la etiqueta.
Debe programar los eventos actionPerformed de cada botón. Para cambiar el color de fondo de una etiqueta, usará el método setBackground. Para cambiar el color del texto de una etiqueta, usará el método setForeground. Para indicar el color azul usará Color.BLUE. Para indicar el color rojo, usará Color.RED. Y para indicar el color verde usará Color.GREEN. Para hacer que una etiqueta sea opaca o no, usará el método setOpaque.
10. PROGRAMAS CON CÁLCULOS
Ejercicio 1: Realice un programa para calcular el total de una venta. El programa tendrá una ventana con al menos los siguientes elementos: Un cuadro de texto llamado txtUnidades donde el usuario introducirá las unidades vendidas. Un cuadro de texto llamado txtPrecio donde el usuario introducirá el precio unidad.
Curso: BSI-03 Programación I Universidad Latina
40
Una etiqueta llamada etiTotalSinIva. Una etiqueta llamda etiIva. Una etiqueta llamada etiTotalMasIva. Un botón llamado btnCalcular. El programa funcionará de la siguiente forma: El usuario introducirá las unidades y el precio y luego pulsará el botón Calcular. El programa entonces calculará el total de la venta, el iva y el total más iva y presentará dichos resultados en cada etiqueta.
Ejercicio 2: Realice un programa para calcular la nota final de un alumno. El programa tendrá una ventana con al menos los siguientes elementos: Un cuadro de texto llamado txtPrimerTrimestre. Un cuadro de texto llamado txtSegundoTrimestre. Un cuadro de texto llamado txtTercerTrimestre.
Una etiqueta llamada etiNotaFinal. Una etiqueta llamada etiResultado. Un botón llamado btnCalcular
El programa funcionará de la siguiente forma: El usuario introducirá las notas de los tres trimestres en los cuadros de texto correspondientes. Cuando se pulse el botón Calcular, el programa calculará la nota media y la mostrará en la etiqueta llamada etiNotaFinal. Si la nota final es menor de 70, entonces en la etiqueta etiResultado aparecerá la palabra SUSPENSO. Si la nota final es 70 o más, entonces en la etiqueta etiResultado aparecerá la palabra APROBADO. Si la nota final fuera un suspenso, entonces el fondo de las etiquetas etiNotaFinal y etiResultado deben aparecer de color rojo. En caso contrario aparecerán de color negro.
Ejercicio 3: Realizar un programa para calcular el área y el perímetro de un círculo. El programa debe tener una ventana con al menos los siguientes elementos: Un cuadro de texto llamado txtRadio, donde el usuario introducirá el radio. Una etiqueta llamada etiArea, donde se mostrará el área del círculo. Una etiqueta llamada etiPerimetro, donde se mostrará el perímetro del círculo. El programa funcionará de la siguiente forma: El usuario introducirá un radio dentro del cuadro de texto llamado radio. Al pulsar la tecla Enter sobre dicho cuadro de texto, el programa calculará el área y el perímetro y los mostrará en las etiquetas correspondientes. Si el usuario introduce un radio negativo, en las etiquetas debe aparecer la palabra “Error” en color rojo. Use el elemento PI de la clase Math para hacer este ejercicio.
Ejercicio 4: Realizar un programa para calcular potencias de un número. El programa le permitirá al usuario introducir una base y un exponente. Luego el programa podrá calcular la potencia de la base elevada al exponente. El programa deberá usar la clase Math. El diseño de la ventana queda a su elección.
Ejercicio 5: Realizar un programa que calcule la raíz cuadrada de un número. El programa tendrá los siguientes elementos en la ventana únicamente: Un cuadro de texto llamado txtNumero. Una etiqueta llamada etiRaiz.
Curso: BSI-03 Programación I Universidad Latina
41
El programa funcionará de la siguiente forma: cuando el usuario escriba un número en el cuadro de texto txtNumero, inmediatamente aparecerá su raíz cuadrada en la etiqueta. Para ello, tendrá que programar el evento keyReleased del cuadro de texto. Use la clase Math para realizar el cálculo de la raíz cuadrada.
Ejercicio 6: Realice un programa que contenga dos cuadros de texto: txtPalabra1, y txtPalabra2. La ventana tendrá también un botón llamado btnConcatena y una etiqueta llamada etiTexto. El usuario introducirá las dos palabras dentro de los cuadros de texto y luego pulsará el botón Concatena. El resultado será que en la etiqueta etiTexto aparecerán las dos palabras escritas concatenadas. Por ejemplo, si el usuario escribe en el primer cuadro de texto “Lunes” y en el segundo “Martes”, en la etiqueta aparecerá: “LunesMartes”.
Ejercicio 7: Realizar un programa que muestre 10 etiquetas llamadas respectivamente: etiUna, etiDos, etiTres, etc... Estas etiquetas contendrán los números del 0 al 9. Aparte, la ventana tendrá un cuadro de texto llamado txtNumero. Se pide que cuando el usuario lleve el ratón sobre una de las etiquetas, aparezca en el cuadro de texto el número correspondiente. Los números se van añadiendo al cuadro de texto. Por ejemplo, si el usuario lleva el puntero sobre la etiqueta Uno, luego sobre la etiqueta Tres y luego sobre la etiqueta Uno, en el cuadro de texto debería haber aparecido lo siguiente: 131. Añada un botón llamado btnBorrar, que al ser pulsado borre el contenido del cuadro de texto.
Ejercicio 8: Se pide realizar un programa para resolver las ecuaciones de segundo grado. Las ecuaciones de segundo grado tienen la siguiente forma: ax2+bx+c=0 Dados unos valores para a, b y c, se debe calcular cuánto vale x. Una ecuación de segundo grado puede tener 0, 1 o 2 soluciones. Para saber el número de soluciones de una ecuación de segundo grado se debe realizar el siguiente cálculo: R = b2 – 4ac Si R es menor de cero, la ecuación no tiene solución. Si R da 0, la ecuación tiene una solución. Si R es mayor de cero, la ecuación tiene dos soluciones. Cuando existe una solución, esta se calcula de la siguiente forma: x = -b / (2a) Cuando existen dos soluciones, estas se calculan de la siguiente forma: x = (-b + raiz(R) ) / (2a) x = (-b – raiz(R) ) / (2a) Realice el programa para resolver las ecuaciones de segundo grado. El diseño de la ventana queda a su elección. Procure que el programa indique cuando hay o no soluciones, y que las muestre de forma adecuada.
Curso: BSI-03 Programación I Universidad Latina
42
11. CUADROS DE MENSAJE, CONFIRMACIÓN E INTRODUCCIÓN DE DATOS
Ejercicio 1: Realice un programa para calcular la división de un número A entre un número B. El programa tendrá los siguientes elementos en la ventana: Dos cuadros de texto llamados txtA y txtB donde se introducirán los dos números. Un botón “Calcular División” llamado btnDivision. Una etiqueta llamada etiResultado donde aparecerá el resultado. El programa debe funcionar de la siguiente forma: Cuando se pulse el botón “Calcular División” se calculará la división del número A entre el B y el resultado aparecerá en la etiqueta etiResultado. Si el usuario introduce un valor 0 dentro del cuadro de texto del número B, entonces el programa mostrará un mensaje de error (Use un JOptionPane.showMessage) Si el usuario introduce un valor menor que cero en cualquiera de los dos cuadros de texto, entonces también se mostrará un error.
Ejercicio 2: Realice un programa que permita calcular el sueldo total de un empleado. Para ello, el programa tendrá los siguientes elementos en la ventana: Un cuadro de texto llamado txtSueldoBase. Un cuadro de texto llamado txtMeses. Un botón llamado btnCalcular. Una etiqueta llamada etiResultado. El programa funcionará de la siguiente forma: El usuario introducirá en el cuadro de texto txtSueldoBase la cantidad bruta que cobra el trabajador al mes. En el cuadro de texto txtMeses introducirá el número de meses trabajados. Al pulsar el botón calcular se calculará el sueldo a percibir por el empleado. Se calculará así: Total a percibir = (SueldoBase – 10% del SueldoBase) * Meses Cuando se pulse el botón calcular, antes de que aparezca el sueldo en la etiqueta de resultado, el programa debe pedirle al usuario que introduzca una contraseña. Solo si la contraseña es correcta el programa mostrará el sueldo total. Para introducir la contraseña use un JOptionPane.showInputDialog. Si el usuario introduce una contraseña incorrecta, el programa mostrará un aviso (JOptionPane.showMessage) y el resultado no se mostrará. Invente el valor de la contraseña
Ejercicico 3: Realizar un programa para calcular el índice de masa corporal de una persona. Para ello, creará una ventana con los siguientes elementos: Un cuadro de texto llamado txtPeso, donde se introducirá el peso de la persona. Un cuadro de texto llamado txtTalla, donde se introducirá la talla. Una etiqueta llamada etiIMC donde aparecerá el Indice de masa corporal calculado. Un botón llamado btnCalcular y otro llamado btnLimpiar. El programa funcionará de la siguiente forma: El usuario introducirá un peso y una talla en los cuadros de texto. Luego pulsará el botón calcular para calcular el índice de masa corporal, el cual se calcula así: IMC = Peso / Talla2
IMC CONCLUSIÓN
<18 Anorexia
>=18 y <20 Delgadez
>=20 y <27 Normalidad
Curso: BSI-03 Programación I Universidad Latina
43
El IMC calculado aparecerá en la etiqueta, y además, aparecerá un mensaje indicando la conclusión a la que se llega, la cual puede ser una de las siguientes según el IMC: El mensaje puede ser algo así: “Su IMC indica que tiene anorexia”, por ejemplo. Este mensaje aparecerá en un JOptionPane.showMessage.
Cuando pulse el botón Limpiar, se borrarán los cuadros de texto Peso y Talla. Antes de que esto ocurra, el programa debe pedir confirmación, con un cuadro de diálogo de confirmación (JOptionPane.showConfirmDialog). El cuadro de confirmación tendrá el siguiente aspecto:
Según lo elegido por el usuario se borrarán los cuadros de texto o no.
12. CADENAS
Ejercicio 1: Realice un programa cuya ventana tenga los siguientes elementos: Un cuadro de texto llamado txtFrase. Varias etiquetas. (Llámelas como quiera) Un botón “Analizar” llamado btnAnalizar. El programa funcionará de la siguiente forma: El usuario introducirá una frase en el cuadro de texto, y luego pulsará el botón Analizar. Al pulsar Analizar, el programa mostrará la siguiente información en las etiquetas: La frase en mayúsculas. La frase en minúsculas. Número de caracteres de la frase. Número de caracteres de la frase sin contar los espacios. Si el usuario pulsa Analizar cuando no hay ninguna frase introducida en el cuadro de texto, el programa debe mostrar un error emergente (JOptionPane)
Ejercicio 2: Realice un programa cuya ventana tenga los siguientes elementos: Un cuadro de texto llamado txtFrase y otro llamado txtSubcadena. Varias etiquetas. Un botón “Analizar” llamado btnAnalizar. El programa funcionará de la siguiente forma: El usuario introducirá una frase en el cuadro de texto txtFrase, y luego introducirá una palabra en el cuadro de texto txtSubcadena, y luego pulsará el botón Analizar.
>=27 y <30 Obesidad (grado 1)
>=30 y <35 Obesidad (grado 2)
>=35 y <40 Obesidad (grado 3)
>=40 y Obesidad mórbida
Curso: BSI-03 Programación I Universidad Latina
44
Al pulsar el botón, el programa debe mostrar la siguiente información: La posición en la que se encuentra la primera aparición de la palabra en la frase. La posición en la que se encuentra la última aparición de la palabra en la frase. Mostrará el texto que hay en la frase antes de la primera palabra. Mostrará el texto que hay en la frase después de la última palabra. Por ejemplo, si la frase fuera: Un globo, dos globos, tres globos. La luna es un globo que se me escapó. Y la palabra fuera globo, entonces la información a mostrar sería: Posición inicial: 3 Posición final: 49 Texto anterior: Un Texto posterior: que se me escapó Si la palabra no se encuentra en la frase, el programa mostrará un mensaje indicando un errorJ y no se presentará nada en las etiquetas.
Ejercicio 3: Realice un programa que tenga los siguientes elementos: Un cuadro de texto llamado txtFrase. Un cuadro de texto llamado txtPalabra1. Un cuadro de texto llamado txtPalabra2. Un cuadro de texto llamado txtPalabra3.
Un cuadro de texto llamado txtPalabra4. Varias etiquetas. Un botón “Analizar” llamado btnAnalizar.
El programa funcionará de la siguiente forma: El usuario introducirá una frase en el cuadro de texto txtFrase, y tres palabras en los cuadros de texto de las palabras. Al pulsar el botón Analizar, el programa debe indicar la siguiente información en las etiquetas: Indicará si la frase es igual a la palabra 1. Indicará si la frase empieza por la palabra 2. Indicará si la frase termina por la palabra 3. Indicará si la palabra 4 está contenida en la frase, y en el caso de que esté contenida, se indicará la posición inicial en la que se encuentra.
Ejercicio 4: Realizar un programa cuya ventana tenga los siguientes elementos: Un cuadro de texto llamado txtFrase. Varias etiquetas. Un botón “Analizar” llamado btnAnalizar. El programa debe contar cuantas vocales tiene la frase. El funcionamiento será el siguiente: El usuario escribirá una frase en el cuadro de texto txtFrase. Luego se pulsará el botón Analizar. El programa mostrará en las etiquetas el número de a, de e, de i de o y de u que se encuentran en la frase. Tenga en cuenta que puede haber vocales en mayúsculas y en minúsculas. Si el usuario no introduce nada en el cuadro de texto txtFrase, entonces el programa debería mostrar un error.
Ejercicio 5: Realizar un programa cuya ventana tenga los siguientes elementos: Un cuadro de texto llamado txtIdentificación. Una etiqueta llamada etiIdentificación. Un botón “Preparar Identificación” llamado btnPrepararIdentificación. El programa funcionará de la siguiente forma: El usuario introducirá un # de cédula en el cuadro de texto llamado txtIdentificacion y luego pulsará el botón Preparar Identificación. El resultado será que la identificación introducida aparecerá “preparada” en la etiqueta etiIdentificacion. A continuación se explica cómo preparara la identificación:
Curso: BSI-03 Programación I Universidad Latina
45
El usuario puede introducir una identificación con uno de estos formatos: 1-123-890 1 – 0123 – 0890 etc. Sin embargo, cuando el usuario pulse el botón Preparar Identificación, en la etiqueta etiIdentificacion debe aparecer la identificación con el siguiente formato: 1123890. Es decir, sin ningún espacio y sin puntos ni guiones. Si el usuario no introduce nada en el cuadro de texto del DNI y pulsa el botón, entonces debe aparecer un error emergente (JOptionPane).
13. LA CLASE JFRAME
Ejercicio 1: Realizar un programa cuya ventana contanga los siguientes elementos: Un cuadro de texto llamado txtTitulo.
Un botón “Cambiar Título” llamado
btnCambiarTitulo.
Un botón “Maximizar” llamado btnMaximizar.
Un botón “Minimizar” llamado btnMinimizar.
Un botón “Restaurar” llamado btnRestaurar.
Un cuadro de texto llamado txtPosicionX.
Un cuadro de texto llamado txtPosicionY.
Un botón “Mover” llamado btnMover.
Un botón “Centrar” llamado btnCentrar.
Un botón “Estilo Java” llamado btnEstiloJava.
Un botón “Estilo Windows” llamado
btnEstiloWindows.
Un botón “Rojo” llamado btnRojo.
Un botón “Verde” llamado btnVerde.
Un botón “Azul” llamado btnAzul.
El funcionamiento del programa será el siguiente: Si el usuario pulsa el botón “Cambiar Titulo”, el título de la ventana cambiará, colocándose como título lo que el usuario haya escrito en el cuadro de texto txtTitulo. Si el usuario pulsa el botón “Maximizar”, la ventana se maximizará. Si el usuario pulsa el botón “Minimizar”, la ventana se minimizará. Si el usuario pulsa el botón “Restaurar”, la ventana se restaurará. Si el usuario pulsa el botón “Mover”, la ventana se colocará en la posición de la pantalla que venga indicada por los valores x, y, introducidos respectivamente en los cuadros de texto txtPosicionX y txtPosicionY. Si el usuario pulsa el botón “Centrar”, la ventana se colocará en el centro de la pantalla. Si el usuario pulsa el botón “Estilo Java”, entonces toda la ventana cambiará a la visualización Java. Si el usuario pulsa el botón “Estilo Windows”, entonces toda la ventana cambiará a la visualización Windows. Si el usuario pulsa uno de los botones de color, entonces el fondo de la ventana se cambiará al color indicado. Además, el programa contará con las siguientes características: Al iniciarse el programa, este debe pedir una contraseña al usuario. Si el usuario introduce la contraseña correcta, entonces el usuario entrará en el programa. En caso contrario el programa se cerrará. Al finalizar el programa, este debe pedir una confirmación al usuario: ¿Desea salir del programa? Si el usuario responde Sí, entonces el programa finalizará. En caso contrario, el programa seguirá funcionando.
14. VARIABLES GLOBALES
Ejercicio 1: Realizar un programa cuya ventana contenga los siguientes elementos:
- Un cuadro de texto llamado txtNumero. - Un botón “Acumular” llamado btnAcumular. - Un botón “Resultados” llamado
btnResultados. - Un botón “Reiniciar” llamado btnReiniciar.
- Una etiqueta con borde llamada etiMayor. - Una etiqueta con borde llamada etiSuma. - Una etiqueta con borde llamada etiMedia. - Una etiqueta con borde llamada etiCuenta.
El programa funcionará de la siguiente forma:
Curso: BSI-03 Programación I Universidad Latina
46
- El usuario introducirá un número en el cuadro de texto txtNumero y luego pulsará el botón “Acumular”. En ese momento se borrará el número introducido en el cuadro de texto.
- Este proceso lo repetirá el usuario varias veces. - Cuando el usuario pulse el botón “Resultados”, deben aparecer en las etiquetas los siguientes datos:
o El número mayor introducido hasta el momento. o La suma de los números introducidos hasta el momento. o La media de los números introducidos hasta el momento. o Cuantos números ha introducido el usuario hasta el momento.
- El botón “Reiniciar” reinicia el proceso borrando todo lo que hubiera en las etiquetas de resultados y reiniciando las variables globales.
Variables globales a usar Para que sirva de ayuda, se recomienda que use las siguientes variables globales:
- Una variable double llamada mayor. Contendrá en todo momento el número mayor introducido. - Una variable double llamada suma. Contendrá en todo momento la suma de los números
introducidos. - Una variable int llamada cuenta. Contendrá en todo momento la cuenta de todos los números
introducidos hasta ahora. Al comenzar el programa, y al pulsar el botón “Reiniciar”, será necesario que estas tres variables se inicien a 0. Nota. Se supondrá que todos los números introducidos serán mayores o iguales a 0.
Ejercicio 2: Realizar un programa que contenga los siguientes elementos en su ventana: - Un cuadro de texto llamado txtNumero. - Un cuadro de texto llamado txtApuesta - Un botón “Jugar” llamado btnJugar. - Una etiqueta llamada etiNumero. - Una etiqueta llamada etiResultado que contendrá inicialmente un “100”.
El programa funcionará de la siguiente forma: - Se trata de un juego de adivinación. El usuario introducirá un número entre 1 y 10 en el cuadro de
texto txtNumero. - Luego introducirá una apuesta en el cuadro de texto txtApuesta. - Y a continuación pulsará el botón “Jugar”. - El programa calculará entonces un número al azar entre 1 y 10 y lo mostrará en la etiqueta
etiNumero. - Si el número introducido por el usuario coincide con el número elegido al azar por la máquina,
entonces el usuario gana y se le debe sumar lo apostado a la cantidad que tenía en dicho momento. Si el usuario pierde entonces se le debe restar lo apostado a la cantidad que tenía. El total que le quede debe aparecer en la etiqueta resultado.
- Al empezar el programa el usuario tiene $100. Las variables globales a usar son las siguientes:
- Solo se necesita una variable global de tipo double a la que puedes llamar ganancias. Esta variable estará inicializada al comienzo del programa a 100.
Para hacer que el ordenador calcule un número aleatorio entre 1 y 10 debes usar el siguiente código: int numeroMaquina=(int) ((Math.random() * 10) + 1);
Curso: BSI-03 Programación I Universidad Latina
47
15. CUADROS DE DIÁLOGO
Ejercicio 1: Se pide realizar un programa que facilite el cálculo del precio de implantación de un determinado software en una empresa. Se pretende calcular el coste de instalación, el coste de formación y el coste de mantenimiento. Para ello, debe realizar un proyecto con una ventana como la que sigue: Esta ventana tiene tres cuadros de textos, para cada uno de los costes. Si se desea, se puede introducir directamente cada uno de los costes en estos cuadros de textos y al pulsar el botón Calcular aparecerá la suma de los tres en la etiqueta Total. Por otro lado, cada cuadro de texto tiene asignado un botón con tres puntos que permitirá facilitar el cálculo de cada coste a través de un cuadro de diálogo. El objeto Dialog o Ventana la selecciona de la Paleta Swing categoría ventanas…
Cuadro de diálogo Coste de Instalación En el caso de que se pulse el botón correspondiente al Coste de Instalación, el cuadro de diálogo que debe aparecer tiene que ser el siguiente (haz que sea modal): Aquí se indicará el número de copias de la versión simplificada del programa a instalar, y el número de copias de la versión completa. Al pulsar el botón Aceptar, se mostrará el coste total por instalación en el cuadro de texto correspondiente de la ventana principal y luego se cerrará el cuadro de diálogo. Para calcular el coste de instalación, ten en cuenta lo siguiente: Cada copia de la versión simplificada cuesta $250, y cada copia de la versión completa cuesta $500. Si por ejemplo, el usuario introduce 1 copia simplificada y 2 de la versión completa, el coste total será: Coste por instalación = 250 * 1 + 500 * 2 = 1250
Curso: BSI-03 Programación I Universidad Latina
48
Si se pulsa el botón Cancelar, el cuadro de diálogo se cierra y no se muestra nada en el cuadro de texto del coste de instalación de la ventana principal. Cuadro de diálogo Coste de Formación En el caso de que se pulse el botón correspondiente al Coste de Formación, el cuadro de diálogo que debe aparecer tiene que ser el siguiente (haz que sea modal): El coste de formación se calculará multiplicando el número de alumnos por el número de horas por $10. Por ejemplo, si el usuario introduce 3 alumnos y 12 horas, el coste por formación será: Coste por formación = 2 * 12 * 10 = 240. Al pulsar el botón Aceptar, se calculará dicho coste y se introducirá en el cuadro de texto del coste de formación de la ventana principal (luego el cuadro de texto se cerrará). Si se pulsa el botón Cancelar, el cuadro de diálogo simplemente se cerrará, sin que ocurra nada más. Cuadro de diálogo Coste de Mantenimiento En el caso de que se pulse el botón correspondiente al Coste de Mantenimiento, el cuadro de diálogo que debe aparecer tiene que ser el siguiente (haz que sea modal): Al pulsar Aceptar, el programa calculará el coste de mantenimiento y lo presentará en el cuadro de texto correspondiente de la ventana principal (y luego se cerrará el cuadro de diálogo) La forma de calcular el coste de mantenimiento es la siguiente: Si se elige un mantenimiento Anual, entonces el coste será de $600. Si se elige un mantenimiento Semestral, entonces el coste será de $350. Si se elige un mantenimiento del tipo Puesta en funcionamiento entonces el coste será de $200. Si se pulsa el botón Cancelar, el cuadro de diálogo se cierra sin más. MEJORAS Ayuda
Añade un botón a la ventana principal con esta forma: Al pulsar este botón, aparecerá un cuadro de diálogo de ayuda con este aspecto. Al pulsar el botón Cerrar, el cuadro de diálogo simplemente se cerrará.
Curso: BSI-03 Programación I Universidad Latina
49
Para hacer el texto, usa el objeto JTextArea, y su propiedad text. Este objeto permite crear cuadros con gran cantidad de texto. Ten en cuenta que cuando añadas un JTextArea este aparecerá dentro de un JScrollPane.
Pantalla de Splash (Presentación) Se añadirá un nuevo cuadro de diálogo al proyecto que servirá como pantalla de presentación (a estos cuadros de diálogo se les suele denominar Splash) Diseñe este cuadro de diálogo como quiera. Puede añadir varias imágenes, colocar el texto donde quiera, etc. Debe mostrar este cuadro de diálogo al comenzar el programa (en el evento windowOpened del formulario) Si quiere mostrar el cuadro de diálogo de la presentación en el centro de la pantalla, puede usar este código (se supone que el cuadro de diálogo se llama winSplash): int x=(int) (Toolkit.getDefaultToolkit().getScreenSize().getWidth()/2 - winSplash.getWidth()/2); int y=(int) (Toolkit.getDefaultToolkit().getScreenSize().getHeight()/2 - winSplash.getHeight()/2); winSplash.setLocation(x,y); El cuadro de diálogo debe tener un botón Cerrar, o bien, debe tener la posibilidad de cerrarse cuando el usuario haga clic sobre él en cualquier parte. Para mejorar su cuadro de diálogo de presentación, se recomienda que active la propiedad del cuadro de diálogo llamada: Undecorated winSplash.setUndecorated(true);. Esta propiedad oculta la barra de título del cuadro de diálogo.
Curso: BSI-03 Programación I Universidad Latina
50
16. EJERCICIOS PROPUESTOS 16.1. Sentencias de control repetitivas 1. Escriba un programa que lea un número entero por teclado y escriba la tabla de multiplicar de ese
número.
2. Escriba un programa que muestre por pantalla la tabla de multiplicar de los 10 primeros números (1,2,3....9,10.).
3. Calcular la suma de las siguientes series:
a)
b)
4. Realice un programa que lea números enteros positivos hasta que se introduzca un 0. El programa
deberá mostrar por pantalla la cantidad de números leídos, el promedio, así como el valor máximo introducido.
5. Realice un programa que calcule y visualice el más grade, el más pequeño y el promedio de n
números (n>0). El valor de n se solicitará al principio del programa y los números serán introducidos por el usuario.
6. Realizar un programa que pida dos números enteros por teclado y muestre por pantalla el siguiente menú:
El usuario deberá elegir una opción y el programa deberá mostrar el resultado por pantalla y
después volver al menú. El programa deberá ejecutarse hasta que se elija la opción 5. Salir.
Modificar el ejercicio anterior para que al elegir la opción 5, en vez de salir del programa directamente, nos muestre el siguiente mensaje de confirmación:
De modo que si elegimos sí salgamos del programa, pero si pulsamos el botón no, volvamos al menú.
7. Realice un programa que calcule el factorial de un número dado por teclado. Realice este ejercicio utilizando primero un bucle for y posteriormente repita el ejercicio utilizando un bucle while.
8. Realice un programa que determine si un número leído del teclado es primo o no.
Curso: BSI-03 Programación I Universidad Latina
51
9. Un número perfecto es un entero positivo, que es igual a la suma de todos los enteros positivos
(excluido él mismo) que son divisores del número. El primer número perfecto es 6, ya que los divisores de 6 son 1, 2, 3 y 1 + 2 + 3 = 6. Escriba un programa que lea un número entero positivo n y muestre por pantalla si ese número es o no perfecto.
10. Realice un programa que lea un número entero por teclado y devuelva por pantalla el número de dígitos que componen ese número. Por ejemplo, si introducimos el número 12334, el programa deberá devolver 5. (Pista: utilice el operador %, averigüe para qué sirve y piense cómo utilizarlo).
11. Realice un programa que lea un número entero por teclado y devuelva por pantalla las que forman ese número. Por ejemplo, si se introduce el número 2345, el programa deberá mostrar por pantalla 5 – 4 – 3 – 2. (Pista: utilice el ejercicio anterior como base para realizar este ejercicio).
Ejercicios que usan números aleatorios para realizar juegos y simulaciones
12. Realizar un programa que simule un juego de adivinar un número. El programa pedirá al usuario dos números que representan el rango de valores entre los que se encuentra el número a adivinar, así como el número de intentos para adivinar el número. A continuación el programa generará un número aleatorio entre esos dos números y el usuario deberá adivinarlo en el número máximo de intentos antes indicado. Cada vez que el jugador introduce un número el programa le dice si es mayor o menor y le indica cuantos intentos le quedan.
13. Realice un programa que pregunte
aleatoriamente cualquier multiplicación. El programa debe indicar si la respuesta ha sido correcta o no (en caso que la respuesta sea incorrecta el programa debe indicar cuál es la correcta). Una vez preguntado por una multiplicación el programa debe preguntar si desea realizar otra. En caso afirmativo preguntará aleatoriamente otra multiplicación. En caso negativo el programa finalizará.
14. Modificar el ejercicio anterior de modo que el programa pregunta aleatoriamente un total de n multiplicaciones siendo n un número dado por teclado. En cada multiplicación el programa debe indicar si se ha acertado o no. Al final del programa, éste deberá mostrar un resumen indicando el número de respuestas correctas y erróneas, así como el porcentaje de aciertos y de fallos.
15. Realice un programa que genere aleatoriamente 7 operaciones aritméticas consecutivas a las que el usuario deberá ir respondiendo correctamente para ir avanzando. Los números (aleatorios) sobre los que se realizan las operaciones deben estar comprendidos entre 2 y 9 y las operaciones aritméticas (también aleatorias) permitidas serán la suma, resta, multiplicación y división (en el caso de la división se realizará siempre una división entera).
Ejemplo:
1. 5 x 4 = 20 2. 20 – 4 = 16 3. 16 / 8 = 2 4. 2 x 6 = 10 Incorrecto 5. 3 x 3 = 9 6. 12 – 7 = 2 Incorrecto 7. 12 – 7 = 5
Curso: BSI-03 Programación I Universidad Latina
52
16.2. Ejercicios propuestos funciones
1. Escribir un programa que pida un número por teclado y nos diga si ese número es primo. El
programa deberá utilizar una función definida por el usuario, a la que se le pase un número y nos devuelva un 0 en el caso de que el número que le pasemos no sea primo, y un 1 en caso contrario.
2. Escribir un programa que pida un número natural por teclado y nos diga si ese número es perfecto (un número natural es perfecto si es igual a la suma de sus divisores, excluido él mismo). El programa deberá utilizar una función definida por el usuario, a la que se le pase un número y nos devuelva un 0 en el caso de que el número que le pasemos no sea perfecto, y un 1 en caso contrario.
3. Realizar un programa que pida dos números enteros por teclado y muestre por pantalla el siguiente menú:
El usuario deberá elegir una opción, introducir dos valores y el programa deberá mostrar el resultado por pantalla. Todas las opciones (1 a 6) deben realizarse utilizando funciones.
4. Utilizando la función primo realizada en el Ejercicio 1, realizar un programa que muestre por pantalla todos los números primos comprendidos entre 1 y un número n introducido por teclado por el usuario.
5. Escriba una función que lea tres números enteros del teclado y nos devuelva el mayor.
6. Escriba una función que calcule la suma de los divisores de un número entero positivo.
7. Escriba una función que determine si un carácter es uno de los dígitos 0,1,2.....9.
8. Escriba una función que convierta grados a fahrenheit (fahrenheit = grados * 9.0/5.0 + 32.0)
9. Escriba las funciones necesarias para poder calcular la equivalencia entre centímetros, pies y pulgadas. (1 Pulgada = 2.54 cm, 1 Pie = 30.48 cm, 1 Pie = 12 Pulgadas)
10. Escribir una función que lea un número entero y un número real por teclado, en función del número entero se aplicará una de las funciones de conversión anteriores, tal y como muestra la siguiente tabla:
Curso: BSI-03 Programación I Universidad Latina
53
Ejercicios propuestos de un nivel de dificultad mayor.
11. Escriba una función que decida si un número entero es capicúa. La palabra capicúa (en matemáticas, número palíndromo) se refiere a cualquier número que se lee igual de izquierda a derecha y de derecha a izquierda (Ejemplos: 101, 111, 121,..., 181, 191, 202, 212,..., 292, 303, 313,..., 898, 909, 919, 929,..., 979, 989, 999, etc)
12. Escriba una función que calcule la suma de los divisores de un número entero positivo, pudiendo excluir de dicha suma el propio número (será un parámetro adicional (valor 1 o 0) quien determinará si se suma o no).
13. Construya una función, llamada amigos, que apoyándose en la función anterior, permita ver si dos números son o no amigos (dos números A y B son amigos si la suma de los divisores de A (excluido él mismo) coincide con B y viceversa)
14. Realizar un programa que pida dos números enteros por teclado y muestre por pantalla el siguiente menú:
El usuario deberá elegir introducir dos valores y a continuación elegir una opción (pulsando el
carácter correspondiente), el programa deberá mostrar el resultado por pantalla.
Cada una de las opciones a realizarse en el menú la debe realizar una función específica, sumar(num1, num2); restar(num1,num2) etc…
15. Realizar una función que reciba como entrada una frase acabada en punto, y devuelva el número
de vocales y el número total de caracteres leídos sin incluir los espacios en blanco.
16. Realizar una función que reciba un array de caracteres y devuelva en una variable el número de palabras que hay en el array.
17. Realizar una función que recibe una cadena de caracteres, y cambia todas las vocales por punto.
18. Realizar un programa que lea un nombre con apellidos por teclado y a continuación muestre el siguiente menú: