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 .......................................... 41
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

1
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):

2
 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.

3
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:
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

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.

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

5
 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.

6
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

7
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.

8
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.

9
 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.

10
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.
Barra de herramientas Standard Barra Build
Panel Workspace

Página de inicio

Panel Output

11
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.

Figura 2
Menú para activar y desactivar 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.

12
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 >.

13
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 B Es aquí esta línea donde se
proyecto llama al primer formulario
inicial de su programa.

14
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.

15
 txtNombre

btnProcesar

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.

16
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

17
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.

18
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:

El icono de
taza de café Es aquí esta línea donde se
identifica el llama al primer formulario
proyecto inicial de su programa.

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.

19
  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
, esta opción permite poner un

20
 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.
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

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.

21
 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

El JPanel tomará este

aspecto

Agrega los objetos sobre el JPanel: cuatro JLabel, tres JTextField y un JButton de la paleta Swing.

22
(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 )

23
  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.

 Desde la barra Generar de NetBeans se

24
 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.

25
 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. Al presionar con el mouse este
botón se cargue el formulario
frmCalculoInteres

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.

Si al cerrar el formulario frmInteresGanado, se

cierra también el formulario frmMenu. Debes
7.6.
cambiar la propiedad defaultCloseOperation (del
frmInteresGando) por Dispose para que el menú
se mantenga visible.

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

26
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.

27
//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

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

29
 double ganancia=0;
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) {
Declara las variables para guardar el monto invertido por
double monto1=0,monto2=0,monto3=0, total=0;
cada persona, y los porcentajes que corresponden a cada
double porc1=0,porc2=0,porc3=0;
monto.

30
monto1=Double.parseDouble(txtMonto1.getText());
monto2=Double.parseDouble(txtMonto2.getText()); Captura los montos que fueron digitados para cada
monto3=Double.parseDouble(txtMonto3.getText()); uno de los inversionistas.

total=monto1+monto2+monto3; Calcula el total de lo invertido por las tres personas

Monto1 X%
porc1=monto1*100/total; Calcula el porcentaje que invierte cada persona, con Total  100%
porc2=monto2*100/total; las sencilla regla de tres. X%=Monto1*100/total
porc3=monto3*100/total;

txtTotal.setText(String.valueOf(total));
txtPorc1.setText(String.valueOf(Math.rint(porc1))); Pone el texto .setText en las cajitas. Los resultados
txtPorc2.setText(String.valueOf(Math.rint(porc2))); de los cálculos. Math.rint redondea los decimales.
txtPorc3.setText(String.valueOf(Math.rint(porc3)));

private void btnLimpiarActionPerformed(java.awt.event.ActionEvent evt) {

txtMonto1.setText("");
txtMonto2.setText("");
txtMonto3.setText("");

txtPorc1.setText(""); Limpia las cajitas de texto para realizar nuevo

txtPorc2.setText(""); cálculos.
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.

Objeto Text Name

JTextField1 txtOperación
JTextField2 txtResultado
JButton1 Calcular btnCalcular
Controles utilizados en el formulario: 1 JButton2 Limpiar btnLimpiar JPanel, 2 JLabel, 2 JTextField y 2
JButton.
Código fuente

31
if(num1 = = num2)
{
resultado=num1*num2;
txtOperacion.setText("Multiplicación"); Si el valor de num1 es igual al valor de num2
} Multiplique los dos números y guarda el
else if(num1 > num2) resultado en la variable resultado.
{ Sino preguntar si el valor de num1 es menor que num2
resultado=num1-num2; Reste los dos números y guarda el resultado
txtOperacion.setText("Resta"); en la variable resultado.
} Sino
else{ Sume los dos números y guarda el resultado
resultado=num1+num2; en la variable resultado.
txtOperacion.setText("Suma");
}
txtResultado.setText(String.valueOf(resultado));
}

private void btnLimpiarActionPerformed(java.awt.event.ActionEvent evt) {

txtOperacion.setText("");
txtResultado.setText(""); Limpia las cajitas de texto para realizar nuevo cálculos.
}

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 .

Objeto Text Name

JTextField1 txtEdad
JTextField2 txtAntiguedad
JTextField3 txtTipo
JButton1 Calcular btnProcesar
Código fuente JButton2 Limpiar btnLimpiar
private void
btnProcesarActionPerformed(java.awt.event.ActionEvent evt) {
int edad=0, antiguedad=0; Declara las variables necesarias

edad=Integer.parseInt(txtEdad.getText());
Captura los datos de entrada de las cajitas de texto
antiguedad=Integer.parseInt(txtAntiguedad.getText());

if((edad >= 60) && (antiguedad < 25)) Utiliza un Y lógico

txtTipo.setText("La jubilación es por: EDAD."); Si la edad es mayor o igual a 60 y los años
else if((edad >= 60) && (antiguedad > 25)) trabajados son menor a 25 años, Imprime la
txtTipo.setText("La jubilación es por: EDAD ADULTA."); jubilación es por EDAD.
else if((edad < 60) && (antiguedad > 25)) Sino
txtTipo.setText("La jubilación es por: ANTUGÜEDAD JOVÉN."); …
else
txtTipo.setText("No tiene derecho a jubilarse");
}

32
 private void btnLimpiarActionPerformed(java.awt.event.ActionEvent evt) {
txtEdad.setText("");
txtAntiguedad.setText(""); Limpia las cajitas de texto para volver a usarlas
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

Venta de Manzanas
JTextField1 txtKilos
JTextField2 txtPrecio
JTextField3 txtDescuento
JTextField4 txtTotal
JButton1 Calcular btnProcesar
JButton2 Limpiar btnLimpiar

33
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.

Objeto Text Name

JTextField1 txtCompra
JTextField2 txtColor
JTextField3 txtDescuento
JTextField4 txtTotal
JButton1 Calcular btnProcesar

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{ Color adquiere un valor aleatorio,
compra=Double.parseDouble(txtCompra.getText()); es decir al azar escogido por la
color= (int)(rnd.nextDouble() * 5.0); PC, entre el rango 0 y 5 que serán
switch(color) sustituidos por los colores del
{ case 0: //el cero será usuado para el color blanco enunciado.
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");
break;

34
 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;.

35
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.

36
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. Un botón con el texto “Visualizar Nombre”.
Nombre de la etiqueta: etiNombre Nombre del botón: btnVisuNombre
Una etiqueta que contenga su ciudad. Un botón con el texto “Ocultar Ciudad”.
Nombre de la etiqueta: etiCiudad Nombre del botón: btnOcultarNombre
Un botón con el texto “Ocultar Nombre”. Un botón con el texto “Visualizar Ciudad”.
Nombre del botón: btnOcultarNombre 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.

37
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.

38
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.

39
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. Una etiqueta llamada etiNotaFinal.
Un cuadro de texto llamado txtSegundoTrimestre. Una etiqueta llamada etiResultado.
Un cuadro de texto llamado txtTercerTrimestre. 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.

40
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.

11. CUADROS DE MENSAJE, CONFIRMACIÓN E INTRODUCCIÓN DE DATOS

41
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
>=27 y <30 Obesidad (grado 1)

42
El IMC calculado aparecerá en la etiqueta, y además, aparecerá un >=30 y <35 Obesidad (grado 2)
mensaje indicando la conclusión a la que se llega, la cual puede ser una >=35 y <40 Obesidad (grado 3)
de las siguientes según el IMC: >=40 y Obesidad mórbida

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.

43
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 txtPalabra4.
Un cuadro de texto llamado txtPalabra1. Varias etiquetas.
Un cuadro de texto llamado txtPalabra2. Un botón “Analizar” llamado btnAnalizar.
Un cuadro de texto llamado txtPalabra3.
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:

44
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 “Mover” llamado btnMover.

Un botón “Cambiar Título” llamado Un botón “Centrar” llamado btnCentrar.
btnCambiarTitulo. Un botón “Estilo Java” llamado btnEstiloJava.
Un botón “Maximizar” llamado btnMaximizar. Un botón “Estilo Windows” llamado
Un botón “Minimizar” llamado btnMinimizar. btnEstiloWindows.
Un botón “Restaurar” llamado btnRestaurar. Un botón “Rojo” llamado btnRojo.
Un cuadro de texto llamado txtPosicionX. Un botón “Verde” llamado btnVerde.
Un cuadro de texto llamado txtPosicionY. 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. - Una etiqueta con borde llamada etiMayor.
- Un botón “Acumular” llamado btnAcumular. - Una etiqueta con borde llamada etiSuma.
- Un botón “Resultados” llamado - Una etiqueta con borde llamada etiMedia.
btnResultados. - Una etiqueta con borde llamada etiCuenta.
- Un botón “Reiniciar” llamado btnReiniciar.
El programa funcionará de la siguiente forma:

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

46
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

47
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á.

48
 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.

49
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:

1 1 1 1
a) 1 + 2 + 3 + ⋯ 𝑛

1 2 3 4 𝑛
b) 2
+ 22 + 23 + 24 … 2𝑛

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.

50
 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

51
 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:

52
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ú:

53