70041149 02 introduccion a la programacion con java

Curso: BSI-03 Programación I Universidad Latina

1

CONTENIDO

1. VARIABLES Y TIPOS DE DATOS ............................................................................................................. 2

1.1 Variables ...................................................................................................................................... 2

1.2 Tipos de datos .............................................................................................................................. 2

1.3 Conversión explícita de tipos (Casting) .......................................................................................... 3

2. OPERADORES ...................................................................................................................................... 4

2.1 Introducción ................................................................................................................................. 4

2.2 Operadores Aritméticos ............................................................................................................... 4

2.3 Operadores Relacionales y Condicionales ..................................................................................... 4

2.4 Operadores Relacionales And y Or ................................................................................................ 4

2.5 Operadores de Asignación ............................................................................................................ 5

2.6 Precedencia de Operadores en Java ............................................................................................. 5

3. SENTENCIAS DE CONTROL DE FLUJO.................................................................................................... 5

3.1. Toma de decisiones ...................................................................................................................... 5

3.1.1. If ........................................................................................................................................... 5

3.1.2. If/else ................................................................................................................................... 6

3.1.3. Switch ................................................................................................................................... 7

3.2. Bucles o ciclos .............................................................................................................................. 8

3.2.1. For ........................................................................................................................................ 8

3.2.2. While / Do While .................................................................................................................. 9

4. EL ENTORNO DE DESARROLLO DE NETBEANS .....................................................................................11

5. PRIMER PROYECTO EN JAVA ..............................................................................................................13

6. ABREVIATURA DE LOS NOMBRE DE LOS CONTROLES BÁSICOS DE JAVA ............................................17

7. EJERCICIOS EN NETBEANS 6.9.1 EN ESPAÑOL .....................................................................................18

8. UTILIZACIÓN DE LAS CAJAS DE TEXTO PARA CAPTURA DE DATOS......................................................36

10. PROGRAMAS CON CÁLCULOS .............................................................................................................39

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

12. CADENAS ............................................................................................................................................43

13. LA CLASE JFRAME ...............................................................................................................................45

14. VARIABLES GLOBALES ........................................................................................................................45

15. CUADROS DE DIÁLOGO ......................................................................................................................47

16. EJERCICIOS PROPUESTOS....................................................................................................................50

16.1. Sentencias de control repetitivas .................................................................................................50

16.2. Ejercicios propuestos funciones ...................................................................................................52


2

1. VARIABLES Y TIPOS DE DATOS

1.1 Variables

Las variables se utilizan para almacenar datos asociados a nombres. Cada variable tiene un nombre que sirve de referencia para introducir datos o acceder a los mismos. Un ejemplo de utilización de variable es: Edad = 23; en este caso, introducimos el valor numérico 23 en la variable Edad. A partir de ahora podemos utilizar la variable a través de su nombre (Edad) para referirnos a su valor (23). Los nombre de las variables, en Java, pueden tener cualquier longitud y deben comenzar con una letra, el símbolo de subrayado “_” o el dólar “$”. El resto de los caracteres del nombre pueden ser cualquiera, salvo los que puden dar lugar a confusión. Los nombre de variables no deben tener espacios en blanco, puesto que el compilador identifacaría más de una variable; por ejemplo, NumeroDeAciertos es un nombre de variable correcto, sin embargo Numero De Aciertos no lo es, porque el compilador identificaría tres variables diferentes: Numero, De y Aciertos.

Los nombre de variables no deben coincidir con palabras reservadas (tales como public, static, class, final, main, etc.). Existe una serie de palabras reservadas las cuales tienen un significado especial para Java y por lo tanto no se pueden utilizar como nombres de variables. Dichas palabras son:

(*) Son palabras reservadas, pero no se utilizan en la actual implementación del lenguaje Java. En Java, los identificadores de variables suelen definirse empezando por un carácter en minúscula, por ejemplo contador. Si en el identificador existe más de una palabra, los comienzos del resto de las palabras se ponen con mayúsculas, ejemplo: contadorDeAciertos. Los identificadores deben ser representativos de los datos que almacenan, de esta manera valorAcumulado, numeroAlumnos, cantidadEuros, edad, potencia son variables que determinan de forma adecuada el significado de sus contenidos, mientras que los nombres de variable: valor V1, V2, X, Y, Z no son representativos de sus contenidos. La longitud de los identificadores no debe ser excesivamente larga, para no dificultar la legibilidad de las instrucciones. Los identificadores en mayúscula se suelen reservar para nombres (normalmente cortos) de constantes, de esta manera las instrucciones son más legibles, al utilizarse minúsculas. Ejemplo: PI, STOCK, PRECIOHORA, IVA, etc. 1.2 Tipos de datos

Las variables almacenan datos de diferentes tipos (numérico decimal, numérico entero, caracteres, etc.). Para indicar el tipo de dato que contendrá las variables debemos “declarar” las mismas, indicando sus tipos. Este mecanismo permite que el traductor (compilador) realice las comprobaciones estáticas de validez, como por ejemplo que no empleamos en el programa una variable que no ha sido declarada, que no asignemos un carácter a una variable de tipo numérico, que no sumemos un carácter a un valor numérico, etc. A continuación se establece una relación de los tipos de datos primitivos (los que proporciona el lenguaje):


3

TIPOS PRIMITIVOS

NOMBRE DEL TIPO TAMAÑO EN BYTES RANGO

TIPOS NUMÉRICOS ENTEROS

Byte 1 -128 a 127

Short 2 -32768 a 32767

Int 4 -231 a 231

Long 8 -263 a 263

TIPOS NUMÉRICOS DECIMALES

Float 4 -3.4x1038 a 3.4x1038

double 8 -1.7x10308 a 1.7x10308

tipo carácter

Char 2 Almacena un solo carácter

String Almacena un conjunto de caracteres

TIPO LÓGICO (BOOLEANO)

boolean 1 true, false

Para declara una variable se emplea la sintaxis: tipo identificador; //declara una variable

tipo identificador [= valor]; //declara e inicializa una variable

tipo identificador1, identificador2, identificador3, etc.; //declara varias

variables del mismo tipo

tipo identificador1=valor1, identificador2=valor2, etc.; // declara e inicializa

varias variables del mismo tipo

Por ejemplo: byte edad = 60;

short sueldoMensual;

float PrecioEuros, cateto1, cateto2, hipotenusa;

boolean adquirido=false, finalizado=true;

1.3 Conversión explícita de tipos (Casting)

Resulta muy habitual que en los programas nos encontremos con la necesidad de mezclar tipos de datos, por ejemplo al trabajar con un biblioteca matemática que obliga a utiizar tipos de datos double, cuando nosotros las variables las tenemos de tipo float, o mas sencillo todavía, al intentar sumar un 1 (por defecto int) a una variable tipo short. Java en algunos casos, realiza una conversión implícita de datos, sin embargo, por regla general, nos veremos obligados a programar conversiones explícitas de tipos. Para modificar el tipo de un valor, basta con indicar el nuevo tipo entre paréntesis antes del valor, por ejemplo: (byte) 1 convierte el 1 (int) a byte (double) MiVariableDelTipoFloat convierte a doublé una variable de tipo float (short) (VariableDeTipoByte + VariableDeTipoByte) convierte a short el resultado de sumar dos variables de tipo byte.


4

2. OPERADORES

2.1 Introducción

Los operadores nos permiten realizar operaciones sobre los operandos. Existen operandos unuarios y binarios; un ejemplo de operador unuario es la negación lógica (!). Los operadores tienen unas reglas de precedencia que resulta importante tener en cuenta.

2.2 Operadores Aritméticos

Esta tabla resume todas las operaciones aritméticas binarias en Java:

Operador Uso Descripción

+ op1 + op2 Suma op1 y op2

- op1 - op2 Resta op2 de op1

* op1 * op2 Multiplica op1 y op2

/ op1 / op2 Divide op1 por op2

% op1 % op2 Obtiene el resto de dividir op1 por op2

Nota: El lenguaje Java extiende la definición del operador + para incluir la concatenación de cadenas. Además, existen dos operadores de atajos aritméticos, ++ que incrementa en uno su operando, y -- que decrementa en uno el valor de su operando.

Operador Uso Descripción

++ op ++ Incrementa op en 1; evalúa el valor antes de incrementar

++ ++op Incrementa op en 1; evalúa el valor después de incrementar

-- op -- Decrementa op en 1; evalúa el valor antes de decrementar

-- -- op Decrementa op en 1; evalúa el valor después de decrementar

2.3 Operadores Relacionales y Condicionales

Los valores relacionales comparan dos valores y determinan la relación entre ellos. Por ejemplo, != devuelve true si los dos operandos son distintos. Esta tabla resume los operadores relacionales de Java:

2.4 Operadores Relacionales And y Or

Operador Uso Devuelve true si

&& op1 && op2 op1 y op2 son verdaderos

|| op1 || op2 uno de los dos es verdadero

! ! op op es falso

El operador & se puede utilizar como un sinónimo de && si ambos operadores son booleanos. Similarmente, | es un sinónimo de || si ambos operandos son booleanos.

Operador Uso Devuelve true si

> op1 > op2 op1 es mayor que op2

>= op1 >= op2 op1 es mayor o igual que op2

< op1 < op2 op1 es menor que op2

<= op1 <= op2 op1 es menor o igual que op2

== op1 == op2 op1 y op2 son iguales

!= op1 != op2 op1 y op2 son distintos


5

2.5 Operadores de Asignación

Puedes utilizar el operador de asignación =, para asignar un valor a otro. Además del operador de asignación básico, Java proporciona varios operadores de asignación que permiten realizar operaciones aritméticas, lógicas o de bits y una operación de asignación al mismo tiempo. Específicamente, suponga que quieres añadir un número a una variable y asignar el resultado dentro de la misma variable, como esto: i = i + 2; Puedes ordenar esta sentencia utilizando el operador +=. i += 2; Las dos líneas de código anteriores son equivalentes. Esta tabla lista los operadores de asignación y sus equivalentes: Operador Uso Equivale a += op1 += op2 op1 = op1 + op2 -= op1 -= op2 op1 = op1 - op2 *= op1 *= op2 op1 = op1 * op2 /= op1 /= op2 op1 = op1 / op2 %= op1 %= op2 op1 = op1 % op2

2.6 Precedencia de Operadores en Java

operadores sufijo [] . (params) expr++ expr--

operadores unarios ++expr --expr +expr -expr ~ !

creación o tipo new (type)expr

multiplicadores * / %

suma/resta + -

relacionales < > <= >= instanceof

igualdad == !=

AND lógico &&

OR lógico ||

condicional ? :

asignación = += -= *= /= %= ^= &= |= <<=

3. SENTENCIAS DE CONTROL DE FLUJO

Las sentencias de control de flujo determinan el orden en que se ejecutarán las otras sentencias dentro del programa. El lenguaje Java soporta varias sentencias de control de flujo, incluyendo:

Sentencias Palabra clave

Toma de decisiones if-else, switch-case

Bucles ó ciclos for, while, do-while

Excepciones try-catch-finally, throw

Misceláneas break, continue, return

3.1. Toma de decisiones

3.1.1. If

La sentencia if (o si condicional), le permite a un programa decidir, mediante la evaluación de una condición o varias condiciones, ejecutar una u otra acción o acciones. La sintaxis General es La siguiente:

if(condicion1) Accion1;


6

En donde:

Condición 1: Representa una expresión que puede ser del tipo booleana.

Acción 1: es la acción que, al evaluar la condición como verdadera, se ejecutará.

Si son varias acciones, van entre llaves. Ejemplo if Programa en java que solicita al usuario su edad, y si este es mayor se lo indica al usuario.

Explicación: En la línea 18 se declara y se inicializa la variable entera edad. En la línea 20 se declara una variable con el nombre lectura de tipo Scanner que se utiliza para lectura de datos. En la línea 23 se le asigna a la variable edad el valor digitado por el usuario, que es introducido gracias a la variable lectura (esta debe ser convertida a integer). En la línea 24 se utiliza la sentencia if para evaluar el valor de edad y si esta es mayor o igual a 18 se informa al usuario. 3.1.2. If/else

En las sentencias if, podemos agregar la sentencia else, la cual indica que, si al evaluar la condición, ésta es falsa, entonces, realizará las acciones, que estén después del else. La sintaxis es la siguiente: if(condición1) { Acciones; } else { Condiciones; }

Ejemplo if/else Al ingresar la nota de un alumno, se desea saber si éste aprobó o no, una materia en el colegio. Se sabe que para aprobar, se necesita una nota mayor o igual a 70.0. Diseñe una aplicación en Java que, al ingresar la nota, muestre con un mensaje, si el alumno, aprobó o no.


7

Explicación: En la línea 24, colocamos una condición, si el alumno alcanza una nota mayor o igual a 70, aprobó el examen caso contrario lo reprobó. Sentencia else/if Anidadas Esta estructura, es una consecuencia de las estructuras if anidadas, su formato es el siguiente: if(condicion1) Sentencia 1; elseif(condicion2) Sentencia 2; ... else Sentencia n; Funciona de la siguiente manera: Se evalúa la primera condición, si resulta verdadera se ejecuta la sentencia 1, y se continúa con la ejecución del programa; de lo contrario, de evalúa la condición 2, si resulta verdadera, se ejecuta la sentencia 2, de lo contrario se evalúa la condición 3 y así sucesivamente. Si al evaluar todas las condiciones, ninguna resulta verdadera, se ejecuta el bloque del else.

3.1.3. Switch

Cuando en una condición existen diversas posibilidades, nos vemos obligados a programar usando if anidados, lo que complica la realización y depuración de código. Para facilitar la programación en estas situaciones, se proporciona la instrucción condicional switch, que permite definir un número ilimitado de ramos basadas en la misma condición. Sintaxis switch(expresión) {case valor1: Instrucciones; break; case valor2: instrucciones; break; ……………… default: instrucciones; break; } Cuando el flujo de control del programa llega a la instrucción switch, lo primero que se hace es evaluar la expresión, después se va comparando el valor de cada clausula case con el resultado de la evaluación de la expresión. Cuando en una instrucción case coinciden los valores, se ejecutan las instrucciones asociadas


8

hasta alcanzar la sentencia break. Si no se incluyen break en un case, se ejecutan todas las instrucciones siguientes (correspondientes a los siguientes grupos case) hasta que se encuentra un break o se termina la instrucción switch. Es importante tener en cuenta que la expresión asociada a la instrucción switch solo debe generar valores de tipo: char, byte, short o int. Ejemplo switch public static void main(String[] args) {

Scanner lectura = new Scanner(System.in);

int numero1 = 0, numero2, resultado = 0, operacion = 0;

System.out.print("Digite el número 1: ");

numero1 = lectura.nextInt();

System.out.print("Digite el número 2: ");

numero2 = lectura.nextInt();

System.out.print("Digite la operación a realizar (1. Sumar/ 2. Restar) ?:");

operacion = lectura.nextInt();

switch (operacion) {

case 1:

System.out.println("Elegió realizar una suma");

resultado = numero1 + numero2;

break;

case 2:

System.out.println("Elegió realizar una resta");

resultado = numero1 - numero2;

break;

default:

System.out.println("No eligió el número 1 ó 2");

System.out.println("Las opciones son 1 ó 2. Por favor intente de

nuevo");

break;

}

System.out.println("El resultado es: "+resultado);

}

3.2. Bucles o ciclos

3.2.1. For

En algunas ocasiones, sabemos a ciencia cierta el número de veces que se tiene que repetir una misma acción o bloque de acciones. Y para ello es que nos sirve, esta estructura. Su sintaxis es la siguiente: for( valor inicial; condición; incremento) accion; Donde:

Valor inicial: es el valor con el cual inicializamos nuestra variable de control.

Condición: si la cumple, ejecuta la acción o acciones e incrementa o decrementa la variable de

control, sino la cumple la condición, se sale del ciclo.

Incremento: que puede ser positivo o negativo (decremento).

La semántica (significado) de la instrucción es la siguiente: se inicializa una variable (inicialización), se evalúa la condición de continuidad y, sí se cumple, se ejecutan las instrucciones situadas entre las llaves, finalmente se ejecuta la expresión de variación y se repite el ciclo hasta que la condición de continuidad se evalúa como false.


9

Ejemplo:

Salida del programa

En el ejemplo anterior se declara una variable de tipo int en la línea 4 (for). El bucle for contiene sus tres secciones obligatorias, separadas por ;

Declaración e inicialización; int índice =1

Condición de continuidad: índice <=10

Expresión de incremento: índice++ que es igual a índice=índice+1

3.2.2. While / Do While

El bucle while nos permite repetir la ejecución de una serie de instrucciones mientras que se cumpla una condición de continuidad. Su uso resulta recomendable cuando no conocemos a priori el número de iteraciones que debemos realizar. El bucle while tiene dos posibles sintaxis: while (condición de continuidad){

Instrucciones a ejecutar en forma repetitiva } do{ instrucciones a ejecutar en forma repetitiva }while(condición de continuidad); En ambos casos se itera o repite mientras que la “condición de continuidad” se cumpla, abandonándose el bucle cuando la condición se evalúa como false. En el primer caso puede ocurrir que las instrucciones interiores del bucle nunca se ejecuten (si la primera vez que se evalúa la condición resulta como false); en el segundo caso las instrucciones interiores al bucle se ejecutan al menos una vez.


10

Ejemplos: En el siguiente ejemplo se muestra una implementación muy sencilla del bucle while en la que se pretende imprimir los números 1, 2, 3, y 4. Puesto que conocemos a priori el número de iteraciones sería más adecuado utilizar un bucle for, pero se ha escogido este ejemplo sencillo para mostrar una primera implementación del bucle while.

En el ejemplo se declara una variable de tipo int en la línea 6 y se inicializa a 1; esta variable actuará como contador de iteraciones en el bucle. En la línea 7 se establece la condición de continuidad del bucle (se itera mientras que i<=4). La línea 9 se encarga de imprimir el valor de í y la línea 10 de incrementarlo. Un error muy frecuente cuando se codifica un bucle while es olvidar incrementar al contador (línea 10), generando un bucle infinito. En nuestro ejemplo también crearíamos un bucle infinito si olvidáramos las llaves delimitadoras del ámbito del bucle.

A continuación se muestra la forma alternativa de utilizar un bucle while : do{}while(condición); la semántica en este ejemplo es la misma que en el anterior (se imprimen los valores de 1 a 4). El detalle de la ejecución varía respecto a que la condición de continuidad se evalúa al final en lugar al comienzo del bucle.


11

4. EL ENTORNO DE DESARROLLO DE NETBEANS

Construcción de su primera aplicación con NetBeans. Inicialmente nos enfocaremos en aprender acerca del entorno de desarrollo de NetBeans y de algunas de las herramientas que proporciona para la construcción de aplicaciones. Aunque NetBeans cuenta con más herramientas de las que usted probablemente utilizaría en cualquier otro trabajo de desarrollo de aplicaciones (incluso más de las que aprendería a utilizar en todo este manual), limitó el enfoque a las principales herramientas que utilizara a lo largo de este manual, así como las aplicaciones que construirá con NetBeans. El entorno de desarrollo de NetBeans: Deberá iniciar el programa de NetBeans IDE 6.7.1 en Español en su computadora, con el fin de observar directamente como se organizan cada una de las áreas y como puede modificarlas y alterar la organización. Después que inicie el entorno de desarrollo, vera una ventana similar a la que se muestra en la figura 1. Cada una de las áreas tiene un propósito específico en el entorno. Puede volver a organizar estas áreas para personalizar el entorno de Desarrollo de NetBeans con el fin de que se ajuste a sus necesidades particulares de desarrollo. El panel de Workspace Cuando inicie por primera vez NetBeans, el área que se ubica en el extremo izquierdo del Entorno, Esta área se conoce como workspace y será su clave para navegar a través de los diversos componentes y partes de sus proyectos de desarrollo. El workspace muestra las partes de su aplicación en dos formas distintas:

Proyectos: Permite navegar y manipular su código fuente.

Archivos: Permite encontrar y editar cada uno de los diferentes recursos de su aplicación,

incluyendo los diseños, iconos y menús de la ventana.

Figura 1. Ventana de Apertura de NetBeans IDE.

Panel Workspace Barra de herramientas Standard Barra Build

Panel Output

Página de inicio


12

El panel Output El panel Output tal vez no esté visible al iniciar NetBeans por primera vez. Una vez compilada su primera aplicación, dicho panel aparecerá en la parte inferior del entorno y permanecerá abierto hasta que usted decida cerrarlo. El panel Output es el lugar donde presenta cualquier información que deba proporcionarle el programa. Además es donde usted podrá observar las instrucciones de progreso del compilador, las advertencias y los mensajes de error. Después de que cierre el panel output, este se abrirá automáticamente cuando NetBeans necesite desplegar un mensaje. El área de edición La parte del extremo derecho del entorno de desarrollo es el área de edición. Ahí es donde usted realizara toda su edición cuando utilice NetBeans; también es el lugar donde se desplegaran las ventanas necesarias para editar el código fuente, así como el lugar donde se desplegará la ventana necesaria para diseñar su aplicación. Las Barras de Menús Al ejecutar NetBeans por primera vez se desplegaran dos barras de herramientas debajo de la barra de menús. Hay muchas otras barras de herramientas disponibles, a demás puede personalizar y crear las suyas propias para adecuarlas a su mejor forma de trabajar. Las dos barras de herramientas que se abren inicialmente son las siguientes:

La barra de herramientas Standard contiene la mayoría de las herramientas estándar para abrir y

guardar archivos, cortar, copiar, pegar y para una gran variedad de comandos que son sumamente

útiles.

La barra Build le ofrece los comandos de construcción y de ejecución que seguramente utilizara

cuando desarrolle y pruebe sus aplicaciones.

Como reorganizar el entorno de NetBeans El programa ofrece una forma sencilla de reorganizar su entorno de desarrollo. La primera es el hacer clic con el botón derecho en el área de las barras de herramientas. Esta acción abre el menú contextual que se muestra en la figura 1.2, el cual permite activar y desactivar las diversas barras de herramientas.

Como volver a abrir alguna de las ventanas de NetBeans que ya no estén visibles. En el menú Ventana podrá activar cualquiera de las ventanas o paneles que no estén visibles en la pantalla de NetBeans.

Figura 2 Menú para activar y desactivar barras de herramientas


13

5. PRIMER PROYECTO EN JAVA

PASOS

Abra el programa NetBeans IDE 6.8 en Español

Elija en el menú Archivo la opción Proyecto Nuevo…

Elija la lista de Categorías: Java y de la lista de tipos de Proyectos Aplicación Java. Haga clic en

Siguiente >.


14

Elija el nombre y la ruta donde desea guardar el proyecto. Recuerde que si lo desea lo puede guardar en su llave maya, dando clic en el botón Examinar…, para buscar la ruta o dirección. Ponga el nombre HolaMundoJava. Presione el botón Terminar. Terminado el paso anterior, ha construido la función principal o programa principal que se ejecuta inicialmente al correr su programa. La pantalla que se mostrada será la siguiente:

El icono de taza de café identifica el proyecto

Es aquí esta línea donde se llama al primer formulario inicial de su programa.

A

B

C


15

El proyecto se habrá creado y se abrirá el IDE. Deberías de ver los siguientes componentes: La ventana de Proyectos, la cual contiene una vista de árbol de los componentes del proyecto, incluyendo los archivos fuente, las librerías de las que depende tú código y así sucesivamente. La ventana de Edición de Código, con un archivo llamado holamundojava abierto. La ventana del Navegador, la cual puedes utilizar para navegar rápidamente entre los elementos de la clase seleccionada. CREACIÓN DE FORMULARIO Posteriormente vamos a crear un formulario (pantalla) que sirva como interfaz gráfico del proyecto.

Presiona el botón derecho sobre el paquete holamundojava . Elije la opción Nuevo y

posteriormente la opción Formulario Form…

Aparecerá la siguiente ventana donde le solicita el nombre del formulario, el cuál será frmHolaMundoJava, el texto frm indica que es un formulario y HolaMundoJava que nos servirá para nombrar el formulario. Presiona el botón Terminar.

El programa guarda el formulario en forma automática dentro del proyecto. Aparecerá la siguiente ventana. Coloque de la paleta Swing un objeto Etiqueta, un Objeto Campo de Texto y un Botón.


16

Cambia la propiedad text y el nombre de los objetos colocados según la siguiente tabla.

Objeto Text Name

JLabel1 Nombre etiNombre

JTextField1 Dejar blanco txtNombre

JButton1 Procesar btnProcesar

Para incluir el código fuente al programa debemos presionar doble clic sobre el botón Procesar, esta acción

nos llevará al editor de código fuente, donde digitaremos la siguientes instrucciones en java.

btnProcesar

txtNombre


17

Presione un clic sobre el bombillo, de la lista desplegable elija Añadir “import” a javax.swing.JOptionPane.

EJECUTAR “CORRER” EL FORMULARIO Presione el botón derecho sobre cualquier parte del área de código, de la lista desplegable elija la opción Run File. La salida será la siguiente

6. ABREVIATURA DE LOS NOMBRE DE LOS CONTROLES BÁSICOS DE JAVA

Existe una convención para los nombres de los controles: Se utiliza siempre

tres letras minúsculas que indican el tipo de control, seguidas por otras

letras (La primera mayúscula, a modo de separación) libremente escogidas

por el usuario, que tienen que hacer referencia al uso que se va a dar a ese

control.

Control Abreviatura

Formulario JFrame frm

Etiqueta eti

Botón btn

Botón de 2 posiciones btn

Casilla de activación chk

Botón de opción opc

Grupo de botones gropc

Lista desplegable cbo

Campo de texto txt

Área de texto txt

Tabla Tbl

Lista de la AWT lst


18

7. EJERCICIOS EN NETBEANS 6.9.1 EN ESPAÑOL

OBJETIVO:

Elaborar la interfaz gráfica de los ejercicios realizados en las prácticas de Diagramas de Flujos (D-F)

realizados en las primeras semanas de programación I.

7.1. Creación del proyecto

Abra el programa NetBeans IDE 6.8 en Español

Elija en el menú Archivo la opción Proyecto Nuevo…

Elija la lista de Categorías: Java y de la lista de tipos de Proyectos Aplicación Java. Haga clic en

Siguiente >.

Elija el nombre y la ruta donde desea guardar el proyecto. Recuerde que si lo desea lo puede

guardar en su llave maya, dando clic en el botón Examinar…, para buscar la ruta o dirección.

Ponga el nombre ProyectoI. Presione el botón Terminar.


19

Al presionar el botón Terminar, ha construido la función principal o programa principal que se ejecuta

inicialmente al correr su programa. La pantalla que se mostrada será la siguiente:

7.2. Creación de formulario principal (menú para acceder a los diferentes formularios)

Vamos a crear un formulario que sirva como menú para acceder a todas las pantallas o formularios

de los ejercicios realizados con Diagramas de Flujo pero realizados en Java. Para ello haz clic en el

botón derecho sobre el paquete proyectoi, elije la opción New y posteriormente la opción JFrame

Form…

Aparecerá la ventana donde le solicita el nombre del formulario, el cuál será frmMenu, el texto frm

indica que es un formulario y menú que nos servirá como el menú para acceder a los demás

formularios ó pantallas de cada ejercicio.

Nota: Este formulario es guardado en forma automática dentro del ProyectoI creado.

El icono de taza de café identifica el proyecto

Es aquí esta línea donde se llama al primer formulario inicial de su programa.


20

Aparecerá la siguiente ventana

Coloque sobre el frmMenu un objeto jPanel que seleccionará de la Paleta Contenedores.

Ajuste el tamaño del JPanel al tamaño del frmMenu. (Como las formas de Word)

Seleccione el objeto JPanel

En la venta de propiedades de este objeto haz clic

sobre la propiedad border y cambia los siguiente:

Al elegir la propiedad border donde están los tres

puntitos *…+, se abrirá la siguiente ventana, elige

de los bordes disponibles la opción TitleBorder


21

, esta opción permite poner un titulo y un borde al JPanel. Escribe en el espacio Title lo

siguiente: Menú de Opciones

Coloca 10 controles JButton sobre el JPanel. Estos se encuentran en la paleta Swing

Cambia el nombre de los botones por un nombre significativo. Recuerda las abreviaturas dadas para cada tipo de

control la del JButton es: btn, luego escribe nombre de significativo de cada botón sin dejar espacios y respetando

la mayúscula a manera de separación.

Para cambiar el nombre del primer botón presiona el botón derecho del Mouse sobre el botón y se desplegará un

menú elige la opción change variable name y sustituye JButton1 por btnInteresGanado.

7.3. Creación del formulario para el ejercicio cálculo de interese ganado

Suponga que un individuo desea invertir su capital en un banco y desea saber cuánto dinero

ganara después de un mes si el banco paga a razón de 2% mensual la tasa de interés. Cree un

programa en NetBeans que resuelva este enunciado.

Para crear un nuevo formulario del tipo formulario JFrame, presiona el botón derecho sobre el paquete

proyectoi . Elije la opción Nuevo y posteriormente la opción Formulario Form…

Escribe el nombre al formulario (frmInteresGanado). Luego presiona el botón Terminar.

Propiedad Text Propiedad Name

Calcular interés ganado btnInteresGanado

Calculo Total del Salario btnCalcularSalario

Presupuesto Hospital btnPresupuestoHospital

Ganancia Articulo btnGananciaArticulo

Inversión Dinero btnInversionDinero

Leer dos números btnLeer

Tipo de Jubilación btnJubilación

Llantera “Ponchadas” btnLlantera

Venta de Naranjas btnNaranjas

Color bolita btnBolitas


22

En el paquete proyectoi se agrego el archivo del formulario: frmInteresGanado.

Ya hay dos formularios en el proyecto frmMenu y frmInteresGanado.

Coloque sobre el frmInteresGanado un objeto JPanel que escogerá en la Paleta Contenedores Swing

Ajuste el tamaño del JPanel.

Seleccione el objeto JPanel, en la venta de propiedades de este objeto haz clic sobre la propiedad

border y cambia lo siguiente:

Al elegir la propiedad border…, se abrirá la siguiente ventana, elige de los bordes disponibles la opción

TitleBorder , esta opción permite poner un titulo y un borde al JPanel. Escribe en el

espacio Title lo siguiente Cálculo de interés ganado

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

El JPanel tomará este

aspecto


23

(Dentro del CD de programación I hay una carpeta con el nombre Imágenes, el Jlabel4 en la propiedad icono… Importar puede asignarle la imagen que muestra la siguiente figura del formulario terminado.)

Cambia los text y el nombre según la siguiente tabla.

Objeto Text Name Editable

JLabel1 Capital invertido etiCapital

JLabel2 Interés ganado etiInteres

JLabel3 Total en el banco etiTotal

JLabel4 etiImagen

JTextField1 txtCapital

JTextField2 txtInteres False

JTextField3 txtTotal False

JButton1 Calcular btnCalcular

JFrame La propiedad Title: Interés ganado

Hasta el momento hemos creado la Interfaz Gráfica de Usuario (IGU) que es la pantalla con que el

usuario interactúa, nos falta agregar el código o instrucciones en el lenguaje java que serán las

encargadas de realizar las peticiones del usuario. Para ello utilizaremos el botón etiquetado Calcular.

Para incluir el código fuente al programa debemos presionar clic derecho sobre el botón Calcular, esta

acción desplegará un menú de opciones como se muestra en la figura. Debe elegir la opción

Events\Action\actionPerformed lo que nos llevará al editor donde digitaremos la instrucciones en

java. (Ó podemos darle doble clic encima del botón calcular)


24

Luego de realizado el paso anterior, se presenta la siguiente pantalla

NetBeans se encargó de incluir el código inicial para nuestro objetivo (el texto que se encuentra en las líneas

sombreadas de celeste), borramos la línea //TODO add your handling code here: añadir su código aquí. Y digitamos el

siguiente código:

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

//Declaración e Inicialización de variables double capital=0.0; //declara e inicializa en 0 la variable capital double interes=0.0; //declara e inicializa en 0 la variable interes double total=0.0; //declara e inicializa en 0 la variable total //Lectura de datos de entrada //Captura la información del la caja de texto capital y se la asigna a //la variable capital convertida en dobule capital=Double.parseDouble(txtCapital.getText()); //Procesos interes=capital*0.02; total=capital+interes; //Salida de resultados txtInteres.setText(String.valueOf(interes)); txtTotal.setText(String.valueOf(total)); }

Para utilizar la instrucción que muestra el

mensaje, antes se debe utilizar la librería

correspondiente.

Para “correr” el programa y utilizarlo como

“usuario” presionamos clic derecho en

cualquier parte del código para que se

despliegue un menú emergente del cual

escogeremos la opción “Run File”. Esta

acción desplegará la siguiente pantalla en la

cual introducimos una cantidad en el capital

y luego presionamos el botón calcular para

que muestre el resultado del cálculo del

interés y el monto total en el banco.


25

Desde la barra Generar de NetBeans se puede correr el programa o función principal con los iconos

Pero para ello se debe incluir el código necesario para que despliegue el formulario del menú que accede a los

programas.

7.4. Pasos para cargar una ventana desde la función principal Main:

1. Ubicarse en el archivo frmMenu del panel izquierdo. En la ventana del código fuente.

2. Buscar el código fuente donde se ubica la función que “carga” el formulario

3. Seleccionar y copiar (Ctrl + C) la instrucción que es la encargada de cargar el formulario

4. Ubiarse en el archivo Main del panel izquierdo

5. Sustituir la instrucción //TODO code application logic here por la instrucción que se encuentra en el

portapapeles (new frmMenu().setVisible(true);). Utilizar Ctrl + V.

6. Corra el programa, desde la barra Generar de NetBeans.


26

7.5. Acceder desde el Menú Principal al Formulario Interés Ganado

Pasos para cargar desde el botón Calcular interés ganado del formulario Menú al formulario

frmInteresGanado.

1. Ubicarse en la ventana del código fuente del frmInteresGanado.

2. Copiar en el portapapeles la instrucción que “carga el formulario”

new frmInteresGanado().setVisible(true);

3. Ubicarse en la ventana diseño del formulario frmMenu

4. Presionar doble clic sobre el botón Calcular interés ganado

5. Pegar el código previamente copiado en el portapapeles de Windows

6. Correr el programa.

7.6.

7.7. Creación del formulario para el ejercicio calculo de salario.

Un vendedor recibe un sueldo base más un 10% extra por comisión de sus ventas, el vendedor desea saber cuánto dinero obtendrá por concepto de comisiones por las tres ventas que realiza en el mes y el total que recibirá en el mes tomando en cuenta su sueldo base y comisiones.

Cree un nuevo formulario JFrame con nombre: frmCalculoSalario.

Coloque sobre el frmCalculoSalario un objeto JPanel que escogerá en la Paleta Contenedores Swing .

Ajuste el tamaño del JPanel al tamaño del frmCalculoSalario.

Agregue los controles necesarios y cambie las propiedades Text y Name de cada control.

Objeto Propiedad Text Propiedad Name JLabel1 Monto salario base

JLabel2 Monto venta 1



JLabel5 Comisión obtenida de ventas

JLabel6 Salario total obtenido

Al presionar con el mouse este

botón se cargue el formulario

frmCalculoInteres

Si al cerrar el formulario frmInteresGanado, se

cierra también el formulario frmMenu. Debes

cambiar la propiedad defaultCloseOperation (del

frmInteresGando) por Dispose para que el menú

se mantenga visible.


27

JTextField1 txtSalarioBase

JTextField2 txtVenta1



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.


28

//Salida de datos txtComision.setText(String.valueOf(comision)); txtSalarioTotal.setText(String.valueOf(salarioTotal));

Las dos instrucciones anteriores muestran el valor de la comisión y el valor del salario total en las cajas correspondiente, pero como las variables comisión y salarioTotal son double y las cajas solo pueden mostrar String “cadena” las convierte primero en cada, antes de mostrarlas utilizando: String.valueOf().

Para “correr” el programa y utilizarlo como “usuarios” presionamos clic derecho en cualquier parte del código para que se despliegue un menú del cual escogeremos la opción “Run File”. Esta acción desplegará la ventana en la cual introducimos un salario base en la caja de texto salario base y luego introducir los valores de cada una de las ventas realizadas en el mes y por último presionamos el botón calcular para que muestre el resultado de la comisión y del salario total.

Agregue al botón Cálculo total del salario del formulario frmMenú el código necesario para que permita mostrar el formulario frmCalculoSalario al presionar el botón.

7.8. Formulario presupuesto hospital

En un hospital existen tres áreas. Ginecología, Pediatría, Traumatología. El presupuesto anual del hospital se reparte conforme a la siguiente tabla:

ÁREA PORCENTAJE DE PRESUPUESTO

Ginecología 40%

Traumatología 35%

Pediatría 25%

Cree un programa que permita obtener la cantidad de dinero que recibirá cada área, para cualquier monto presupuestal.

Cambia la propiedad Text y el Name de cada control según la siguiente tabla.

Objeto Text Name

JLabel1 Monto del presupuesto etiPresupuesto

JLabel2 Ginecología 40% etiGinecologia

JLabel3 Pediatría 25% etiPediatria

JLabel4 Traumatología 35% etiTraumatologia

JTextField1 txtPresupuesto

JTextField2 txtGinecologia

JTextField3 txtPediatria

JTextField4 txtTraumatologia



29

Controles utilizados en el formulario: 1 JPanel, 4 JLabel, 4 JTextField y un 1 JButton

Código fuente

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

double presupuesto=0, ginecologia=0, pediatria=0, traumatologia=0;

presupuesto=Double.parseDouble(txtPresupuesto.getText());

ginecologia=presupuesto*0.40;

pediatria=presupuesto*0.25;

traumatologia=presupuesto*0.35;

txtGinecologia.setText(String.valueOf(ginecologia));

txtPediatria.setText(String.valueOf(pediatria));

txtTraumatologia.setText(String.valueOf(traumatologia));

}

Descripción de sentencias o instrucciones: double presupuesto=0, ginecologia=0, pediatria=0, traumatologia=0; //Declara tres variables de tipo double y las inicializa con valor 0 presupuesto=Double.parseDouble(txtPresupuesto.getText()); Captura de la cajita de texto txtPresupuesto el valor, lo convierte en doublé y se lo asigna a la variable presupuesto. ginecologia=presupuesto*0.40; pediatria=presupuesto*0.25; traumatologia=presupuesto*0.35; Calcula el % correspondiente a cada área según lo establecido por el enunciado del problema txtGinecologia.setText(String.valueOf(ginecologia)); txtPediatria.setText(String.valueOf(pediatria)); txtTraumatologia.setText(String.valueOf(traumatologia)); Muestra en las cajitas de texto los valores calculados de los porcentajes, pero antes los convierte en Strings.

7.9. Formulario ganancia artículo.

Ejercicio #7 del folleto Introducción al desarrollo de los Algoritmos

El dueño de una tienda compra un artículo a un precio determinado. Obtener el precio en que lo debe vender para obtener una ganancia del 30%. Cambia la propiedad Text y el Name de cada control según la siguiente tabla.

Objeto Text Name

JLabel1 Precio Compra: etiPrecioCompra

JLabel2 Ganancia30%: etiGanancia

JLabel3 Precio Venta: etiPrecioVenta

JTextField1 txtPreciCompra

JTextField2 txtGanancia

JTextField3 txtPrecioVenta


JButton2 Limpiar btnLimpiar

Controles utilizados en el formulario: 1 JPanel, 3 JLabel, 3 JTextField y 2 JButton.

Código fuente

private void btnCalcularActionPerformed(java.awt.event.ActionEvent evt) { double precioCompra=0; double precioVenta=0; double ganancia=0;


30

precioCompra = Double.parseDouble(txtPrecioCompra.getText()); ganancia = precioCompra*0.30; precioVenta = precioCompra + ganancia; txtGanancia.setText(String.valueOf(ganancia)); txtPrecioVenta.setText(String.valueOf(precioVenta)); } Descripción de sentencias o instrucciones: double precioCompra=0; double precioVenta=0; double ganancia=0; Declara tres variables de tipo double y las inicializa con valor 0 precioCompra=Double.parseDouble(txtPrecioCompra.getText()); Captura de la cajita de texto txtPrecioCompra el valor ingresado por el usuario, lo convierte en double y se lo asigna a la variable precioCompra. ganancia = precioCompra*0.30; precioVenta = precioCompra + ganancia; Calcula el % correspondiente a la ganancia y calcula el valor al que debe vender el artículo a los clientes. txtGanancia.setText(String.valueOf(ganancia)); txtPrecioVenta.setText(String.valueOf(precioVenta)); Muestra en las cajitas de texto los valores calculados: la ganancia y el precio de venta. private void btnLimpiarActionPerformed(java.awt.event.ActionEvent evt) { txtPrecioCompra.setText(""); txtGanancia.setText(""); txtPrecioVenta.setText(""); } Limpia el contenido de las tres cajitas de texto, para hace la prueba con otro artículo

7.10. Formulario inversión de dinero

Ejercicio #8 del folleto Introducción al desarrollo de los Algoritmos.

Tres personas deciden invertir su dinero para fundar una empresa. Cada una de ellas invierte una

cantidad distinta. Obtener el porcentaje que cada quien invierte con respecto a la cantidad total

invertida. Cambia la propiedad Text y el Name de cada control según la siguiente tabla.

Objeto Text Name

JTextField1 txtMonto1



JTextField4 txtPorc1



JTextField7 txtTotal



private void btnCalcularActionPerformed(java.awt.event.ActionEvent evt) { double monto1=0,monto2=0,monto3=0, total=0; double porc1=0,porc2=0,porc3=0;

Declara las variables para guardar el monto invertido por cada persona, y los porcentajes que corresponden a cada monto.


31

monto1=Double.parseDouble(txtMonto1.getText()); monto2=Double.parseDouble(txtMonto2.getText()); monto3=Double.parseDouble(txtMonto3.getText()); total=monto1+monto2+monto3; porc1=monto1*100/total; porc2=monto2*100/total; porc3=monto3*100/total; txtTotal.setText(String.valueOf(total)); txtPorc1.setText(String.valueOf(Math.rint(porc1))); txtPorc2.setText(String.valueOf(Math.rint(porc2))); txtPorc3.setText(String.valueOf(Math.rint(porc3))); } private void btnLimpiarActionPerformed(java.awt.event.ActionEvent evt) { txtMonto1.setText(""); txtMonto2.setText(""); txtMonto3.setText(""); txtPorc1.setText(""); txtPorc2.setText(""); txtPorc3.setText(""); txtTotal.setText(""); }

7.11. Formulario comparar dos números

Leer 2 números, si son iguales que los multiplique, sí el primero es mayor que el segundo que los

reste y si no que los sume.

Cambia la propiedad Text y el Name de cada control según la siguiente tabla.

Controles utilizados en el formulario: 1 JPanel, 2 JLabel, 2 JTextField y 2

JButton.

Código fuente

Objeto Text Name

JTextField1 txtOperación

JTextField2 txtResultado



Captura los montos que fueron digitados para cada uno de los inversionistas.

Calcula el total de lo invertido por las tres personas

Calcula el porcentaje que invierte cada persona, con las sencilla regla de tres.

Monto1 X% Total 100%

X%=Monto1*100/total

Pone el texto .setText en las cajitas. Los resultados de los cálculos. Math.rint redondea los decimales.

Limpia las cajitas de texto para realizar nuevo

cálculos.


32

if(num1 = = num2) { resultado=num1*num2; txtOperacion.setText("Multiplicación"); } else if(num1 > num2) { resultado=num1-num2; txtOperacion.setText("Resta"); } else{ resultado=num1+num2; txtOperacion.setText("Suma"); } txtResultado.setText(String.valueOf(resultado)); } private void btnLimpiarActionPerformed(java.awt.event.ActionEvent evt) { txtOperacion.setText(""); txtResultado.setText(""); }

7.12. Formulario jubilación

El IMSS requiere clasificar a las personas que se jubilaran en el año de 1997. Existen tres tipos de jubilaciones: por

edad, por antigüedad joven y por antigüedad adulta. Las personas adscritas a la jubilación por edad deben tener 60

años o más y una antigüedad en su empleo de menos de 25 años. Las personas adscritas a la jubilación por antigüedad

joven deben tener menos de 60 años y una antigüedad en su empleo de 25 años o más. Las personas adscritas a la

jubilación por antigüedad adulta deben tener 60 años o más y una antigüedad en su empleo de 25 años o más.

Determinar por medio de un programa en java en qué tipo de jubilación quedara adscrita una persona.

Código fuente private void btnProcesarActionPerformed(java.awt.event.ActionEvent evt) { int edad=0, antiguedad=0; edad=Integer.parseInt(txtEdad.getText()); antiguedad=Integer.parseInt(txtAntiguedad.getText()); if((edad >= 60) && (antiguedad < 25)) txtTipo.setText("La jubilación es por: EDAD."); else if((edad >= 60) && (antiguedad > 25)) txtTipo.setText("La jubilación es por: EDAD ADULTA."); else if((edad < 60) && (antiguedad > 25)) txtTipo.setText("La jubilación es por: ANTUGÜEDAD JOVÉN."); else txtTipo.setText("No tiene derecho a jubilarse"); }

Objeto Text Name

JTextField1 txtEdad

JTextField2 txtAntiguedad

JTextField3 txtTipo

JButton1 Calcular btnProcesar


Si el valor de num1 es igual al valor de num2 Multiplique los dos números y guarda el resultado en la variable resultado.

Sino preguntar si el valor de num1 es menor que num2 Reste los dos números y guarda el resultado en la variable resultado.

Sino Sume los dos números y guarda el resultado en la variable resultado.

Limpia las cajitas de texto para realizar nuevo cálculos.

Declara las variables necesarias

Captura los datos de entrada de las cajitas de texto

Utiliza un Y lógico Si la edad es mayor o igual a 60 y los años trabajados son menor a 25 años, Imprime la jubilación es por EDAD. Sino …


33

private void btnLimpiarActionPerformed(java.awt.event.ActionEvent evt) { txtEdad.setText(""); txtAntiguedad.setText(""); txtTipo.setText(""); }

7.13. Formulario llantera

En una llantera se ha establecido una promoción de las llantas marca "Ponchadas", dicha promoción consiste en lo siguiente

Si se compran menos de cinco llantas el precio es de ¢ 3 000 cada una,

¢ 2 500 si se compran de cinco a 10 y de

¢ 2 000 si se compran más de 10

Obtener la cantidad de dinero por cada una de las llantas que compra y el total de la compra.

Objeto Text Name

JTextField1 txtCantidad

JTextField2 txtPrecio




Código fuente private void btnProcesarActionPerformed(java.awt.event.ActionEvent evt) { int cantidad=0, precio=0, total=0; cantidad=Integer.parseInt(txtCantidad.getText()); if(cantidad<5) precio=3000; else if((cantidad>=5)&&(cantidad<=10)) precio=2500; else precio=2000; total=precio*cantidad; txtPrecio.setText(String.valueOf(precio)); txtTotal.setText(String.valueOf(total)); }

7.14. Formulario venta de manzanas

Objeto Text Name

JTextField1 txtKilos JTextField2 txtPrecio

JTextField3 txtDescuento




Limpia las cajitas de texto para volver a usarlas

Venta de Manzanas


34

Código fuente private void btnProcesarActionPerformed(java.awt.event.ActionEvent evt) { double kilos=0, precio=0, descuento=0, total=0; kilos=Integer.parseInt(txtKilos.getText()); precio=Integer.parseInt(txtPrecio.getText()); total=kilos*precio; if((kilos>0)&&(kilos<=2)) descuento=0; else if((kilos>=3)&&(kilos<=5)) descuento=total*0.10; else if((kilos>=6)&&(kilos<=10)) descuento=total*0.15; else descuento=total*0.20; total=total-descuento; txtDescuento.setText(String.valueOf(descuento)); txtTotal.setText(String.valueOf(total)); }

7.15. Formulario color de bolita

Ejercicio #25 del folleto Introducción al desarrollo de los Algoritmos.

Código fuente private void btnProcesarActionPerformed(java.awt.event.ActionEvent evt) { Random rnd = new Random(); double compra=0,descuento=0, total=0; int color=0; if(txtCompra.getText().equals("")) JOptionPane.showMessageDialog(null,"Digite el monto de compra."); else{ compra=Double.parseDouble(txtCompra.getText()); color= (int)(rnd.nextDouble() * 5.0); switch(color) { case 0: //el cero será usuado para el color blanco descuento=0; txtColor.setText("Blanco"); break; case 1: //el uno será usuado para el color verde descuento=compra*0.10; txtColor.setText("Verde"); break; case 2: //el dos será usuado para el color amarillo descuento=compra*0.25; txtColor.setText("Amarillo");

Objeto Text Name

JTextField1 txtCompra JTextField2 txtColor

JTextField3 txtDescuento



Color adquiere un valor aleatorio, es decir al azar escogido por la

PC, entre el rango 0 y 5 que serán

sustituidos por los colores del

enunciado.


35

break; case 3: //el tres será usuado para el color azul descuento=compra*0.50; txtColor.setText("Azul"); break; case 4: //el cero será usuado para el color rojo descuento=compra; txtColor.setText("Rojo"); break; } total=compra-descuento; txtDescuento.setText(String.valueOf(descuento)); txtTotal.setText(String.valueOf(total)) ; } } Para corregir los errores que presenta el código, es decir donde presenta las x rojas deben incluir las libreras necesarias. Es decir para poder utilizar las ventanas de mensajes incluye la librería import javax.swing.JOptionPane;.

Para utilizar los números aleatorios incluye la librería import java.until.Random;.


36

8. UTILIZACIÓN DE LAS CAJAS DE TEXTO PARA CAPTURA DE DATOS

Los controles campos de texto se utilizan frecuentemente en los programas para obtener los datos del usuario necesarios para procesar la información. Estos controles tienen gran cantidad de métodos entre algunos de los más usados getText() y setText(). Estos métodos se utilizan para obtener y poner los datos que contienen respectivamente, pero al ser controles campos de texto solo se obtiene de ellos datos tipo texto o se pone en ellos datos tipo texto, aunque la información sea numérica NetBeans la trata como texto. Por lo tanto debemos utilizar las funciones que nos permiten convertir los datos que debemos obtener o poner en las cajas de texto. Ejemplo:

Este formulario nos permite obtener el nombre y salario actual de un trabajador, calcula el 30% de aumento en el salario y mostrar cual es su nuevo salario.

El código para realizar este enunciado es el siguiente:

También tenemos la función Integer.parseInt(); para convertir a un tipo int.


37

9. PRIMEROS PROGRAMAS

Ejercicio 1: Realice un programa en java con las siguientes características: La ventana principal tendrá los siguientes elementos: Una etiqueta que contenga su nombre. Nombre de la etiqueta: etiNombre Una etiqueta que contenga su ciudad. Nombre de la etiqueta: etiCiudad Un botón con el texto “Ocultar Nombre”. Nombre del botón: btnOcultarNombre

Un botón con el texto “Visualizar Nombre”. Nombre del botón: btnVisuNombre Un botón con el texto “Ocultar Ciudad”. Nombre del botón: btnOcultarNombre Un botón con el texto “Visualizar Ciudad”. Nombre del botón: btnVisuCiudad

El funcionamiento del programa será el siguiente: Cuando se pulse el botón btnOcultarNombre, se debe ocultar la etiqueta etiNombre. Cuando se pulse el botón btnVisuNombre, se debe visualizar la etiqueta etiNombre. Cuando se pulse el botón btnOcultarCiudad, se debe ocultar la etiqueta etiCiudad. Cuando se pulse el botón btnVisuCiudad, se debe visualizar la etiqueta etiCiudad. Para hacer esto debe programar el evento actionPerformed de cada botón. Usará el método setVisible de cada etiqueta para visualizarlas u ocultarlas.

Ejercicio 2: Creará un programa java cuya ventana principal contenga los siguientes componentes: Un cuadro de texto. El nombre será txtTexto. Una etiqueta vacía (sin texto dentro). El nombre será etiTexto1. Otra etiqueta vacía (sin texto dentro). El nombre será etiTexto2. Un botón con el texto “Traspasa 1”. El nombre será btnTraspasa1. Un botón con el texto “Traspasa 2”. El nombre será btnTraspasa2. El programa funcionará de la siguiente forma: Cuando el usuario pulse el botón “Traspasa 1”, lo que se haya escrito dentro del cuadro de texto se copiará dentro de la etiqueta 1. Cuando el usuario pulse el botón “Traspasa 2”, lo que se haya escrito dentro del cuadro de texto se copiará dentro de la etiqueta 2. Para hacer esto programará el evento actionPerformed de cada botón. Usará el método setText para situar el texto en la etiqueta, y getText para recoger el texto del cuadro de texto.

Ejercicio 3: Se pide que realice un programa en java cuya ventana principal incluya los siguientes componentes: Un cuadro de texto llamado txtTexto. Una etiqueta vacía llamada etiTexto. Un botón con el texto “Vaciar” llamado btnVaciar. El programa funcionará de la siguiente forma: Cuando el usuario escriba en el cuadro de texto txtTexto, lo que escriba pasará inmediatamente a la etiqueta etiTexto. (Tendrá que programar el evento keyPressed del cuadro de texto) Cuando el usuario pulse el botón “Vaciar” el texto contenido en el cuadro de texto y en la etiqueta se borrará. (Tendrá que programar el evento actionPerformed) Tendrá que usar el método setText para colocar texto en la etiqueta y usar el método getText para recoger el texto escrito en el cuadro de texto.


38

Ejercicio 4: Se pide que realice un programa en java cuya ventana principal contenga los siguientes elementos:

- Un cuadro de texto llamado txtNombre. - Un cuadro de texto llamado txtCiudad. - Una etiqueta llamada txtFrase. - Un botón con el texto “Aceptar” llamado btnAceptar. - Un botón con el texto “Desactivar” llamado btnDesactivar. - Un botón con el texto “Activar” llamado btnActivar.

El programa funcionará de la siguiente forma:

- El usuario introducirá un nombre en el cuadro de texto txtNombre. Por ejemplo “Juan”. - El usuario introducirá una ciudad en el cuadro de texto txtCiudad. Por ejemplo “Santa Cruz”. - Cuando el usuario pulse el botón “Aceptar”, entonces aparecerá un mensaje en la etiqueta llamada

txtFrase indicando como se llama y donde vive. Por ejemplo: Usted se llama Juan y vive en Santa Cruz. - Cuando el usuario pulse el botón “Desactivar”, entonces los dos cuadros de texto se desactivarán.

Cuando el usuario pulse el botón “Activar”, los dos cuadros de texto se volverán a activar.

Tendrá que programar el evento actionPerformed de los botones.

Tendrá que usar la concatenación de cadenas. Recuerde que se pueden concatenar cadenas a través del operador +.

Tendrá que usar el método setText para colocar el texto en la etiqueta y el método getText para recoger el texto de cada cuadro de texto.

Tendrá que usar el método setEnabled para activar o desactivar cada cuadro de texto.

Ejercicio 5: Debe realizar un programa java cuya ventana principal contenga los siguientes elementos: - Cuatro etiquetas, conteniendo distintas palabras cada una. Puede llamarlas: etiPal1, etiPal2, etiPal3

y etiPal4. - Otra etiqueta que contenga el texto “Ocultar”. Esta etiqueta se llamará etiOcultar y tendrá un

tamaño más grande que las otras y un color de fondo. El programa debe funcionar de la siguiente forma:

- Cuando el puntero del ratón “sobrevuele” la etiqueta etiOcultar, las etiquetas con las palabras deben desaparecer.

- Cuando el puntero del ratón salga de la superficie de la etiqueta etiOcultar, entonces las etiquetas con las palabras volverán a aparecer.

Tendrá que programar los eventos mouseEntered y mouseExited para que el programa detecte cuando el ratón entra o sale de la etiqueta etiOcultar. Debe usar el método setVisible de las etiquetas para ocultarlas o visualizarlas.

Ejercicio 6: Debe realizar un programa java cuya ventana principal contenga los siguientes elementos: - Una etiqueta que contenga su nombre. Esta etiqueta se llamará etiNombre. Esta etiqueta debe

tener un color de fondo. - Un botón con el texto “Esquina”. Este botón se llamará btnEsquina. - Un botón con el texto “Centro”. Este botón se llamará btnCentro. - Un botón con el texto “Agrandar”. Este botón se llamará btnAgrandar. - Un botón con el texto “Achicar”. Este botón se llamará btnAchicar.


39

El programa debe funcionar de la siguiente forma: - Cuando el usuario pulse el botón “Esquina”, la etiqueta etiNombre se colocará en la esquina de la ventana. - Cuando el usuario pulse el botón “Centro”, la etiqueta etiNombre se colocará en el centro de la ventana. - Cuando el usuario pulse el botón “Agrandar”, la etiqueta etiNombre cambiará de tamaño, agrandándose. - Cuando el usuario pulse el botón “Achicar”, la etiqueta etiNombre cambiará de tamaño, empequeñeciéndose. - Cuando el usuario lleve el puntero sobre uno de los botones, el botón cambiará de tamaño agrandándose.

Cuando el puntero salga del botón, el botón volverá a su tamaño normal.

Debe programar los eventos actionPerformed, mouseEntered y mouseExited para los botones. Tendrá que usar el método setLocation para cambiar la posición de la etiqueta. Este método recibe como parámetro la posición x e y donde situará el componente. Tendrá que usar el método setSize para cambiar el tamaño de la etiqueta y de los botones. Este método recibe como parámetro el ancho y alto del componente. La propiedad preferredSize permite definir un tamaño inicial a cada componente de la ventana.

Ejercicio 7 Se pide realizar un programa java que tenga los siguientes elementos en la ventana principal:

- Una etiqueta con el texto que quiera. Esta etiqueta se llamará etiTexto. - Un botón con el texto “Azul”. Este botón se llamará btnAzul. - Un botón con el texto “Rojo”. Este botón se llamará btnRojo. - Un botón con el texto “Verde”. Este botón se llamará btnVerde. - Un botón con el texto “Fondo Azul”. Este botón se llamará btnFondoAzul. - Un botón con el texto “Fondo Rojo”. Este botón se llamará btnFondoRojo. - Un botón con el texto “Fondo Verde”. Este botón se llamará btnFondoVerde. - Un botón con el texto “Transparente”. Este botón se llamará btnTransparente. - Un botón con el texto “Opaca”. Este botón se llamará btnOpaca.

El programa debe funcionar de la siguiente forma:

- Cuando se pulse el botón “Azul”, el texto de la etiqueta se pondrá de color azul. - Cuando se pulse el botón “Rojo”, el texto de la etiqueta se pondrá de color rojo. - Cuando se pulse el botón “Verde”, el texto de la etiqueta se pondrá de color verde. - Cuando se pulse el botón “Fondo Azul”, el fondo de la etiqueta se pondrá de color azul. - Cuando se pulse el botón “Fondo Rojo”, el fondo de la etiqueta se pondrá de color rojo. - Cuando se pulse el botón “Fondo Verde”, el fondo de la etiqueta se pondrá de color verde. - Cuando se pulse el botón “Transparente”, la etiqueta dejará de ser opaca. - Cuando se pulse el botón “Opaca”, se activará la propiedad opaca de la etiqueta.

Debe programar los eventos actionPerformed de cada botón. Para cambiar el color de fondo de una etiqueta, usará el método setBackground. Para cambiar el color del texto de una etiqueta, usará el método setForeground. Para indicar el color azul usará Color.BLUE. Para indicar el color rojo, usará Color.RED. Y para indicar el color verde usará Color.GREEN. Para hacer que una etiqueta sea opaca o no, usará el método setOpaque.

10. PROGRAMAS CON CÁLCULOS

Ejercicio 1: Realice un programa para calcular el total de una venta. El programa tendrá una ventana con al menos los siguientes elementos: Un cuadro de texto llamado txtUnidades donde el usuario introducirá las unidades vendidas. Un cuadro de texto llamado txtPrecio donde el usuario introducirá el precio unidad.


40

Una etiqueta llamada etiTotalSinIva. Una etiqueta llamda etiIva. Una etiqueta llamada etiTotalMasIva. Un botón llamado btnCalcular. El programa funcionará de la siguiente forma: El usuario introducirá las unidades y el precio y luego pulsará el botón Calcular. El programa entonces calculará el total de la venta, el iva y el total más iva y presentará dichos resultados en cada etiqueta.

Ejercicio 2: Realice un programa para calcular la nota final de un alumno. El programa tendrá una ventana con al menos los siguientes elementos: Un cuadro de texto llamado txtPrimerTrimestre. Un cuadro de texto llamado txtSegundoTrimestre. Un cuadro de texto llamado txtTercerTrimestre.

Una etiqueta llamada etiNotaFinal. Una etiqueta llamada etiResultado. Un botón llamado btnCalcular

El programa funcionará de la siguiente forma: El usuario introducirá las notas de los tres trimestres en los cuadros de texto correspondientes. Cuando se pulse el botón Calcular, el programa calculará la nota media y la mostrará en la etiqueta llamada etiNotaFinal. Si la nota final es menor de 70, entonces en la etiqueta etiResultado aparecerá la palabra SUSPENSO. Si la nota final es 70 o más, entonces en la etiqueta etiResultado aparecerá la palabra APROBADO. Si la nota final fuera un suspenso, entonces el fondo de las etiquetas etiNotaFinal y etiResultado deben aparecer de color rojo. En caso contrario aparecerán de color negro.

Ejercicio 3: Realizar un programa para calcular el área y el perímetro de un círculo. El programa debe tener una ventana con al menos los siguientes elementos: Un cuadro de texto llamado txtRadio, donde el usuario introducirá el radio. Una etiqueta llamada etiArea, donde se mostrará el área del círculo. Una etiqueta llamada etiPerimetro, donde se mostrará el perímetro del círculo. El programa funcionará de la siguiente forma: El usuario introducirá un radio dentro del cuadro de texto llamado radio. Al pulsar la tecla Enter sobre dicho cuadro de texto, el programa calculará el área y el perímetro y los mostrará en las etiquetas correspondientes. Si el usuario introduce un radio negativo, en las etiquetas debe aparecer la palabra “Error” en color rojo. Use el elemento PI de la clase Math para hacer este ejercicio.

Ejercicio 4: Realizar un programa para calcular potencias de un número. El programa le permitirá al usuario introducir una base y un exponente. Luego el programa podrá calcular la potencia de la base elevada al exponente. El programa deberá usar la clase Math. El diseño de la ventana queda a su elección.

Ejercicio 5: Realizar un programa que calcule la raíz cuadrada de un número. El programa tendrá los siguientes elementos en la ventana únicamente: Un cuadro de texto llamado txtNumero. Una etiqueta llamada etiRaiz.


41

El programa funcionará de la siguiente forma: cuando el usuario escriba un número en el cuadro de texto txtNumero, inmediatamente aparecerá su raíz cuadrada en la etiqueta. Para ello, tendrá que programar el evento keyReleased del cuadro de texto. Use la clase Math para realizar el cálculo de la raíz cuadrada.

Ejercicio 6: Realice un programa que contenga dos cuadros de texto: txtPalabra1, y txtPalabra2. La ventana tendrá también un botón llamado btnConcatena y una etiqueta llamada etiTexto. El usuario introducirá las dos palabras dentro de los cuadros de texto y luego pulsará el botón Concatena. El resultado será que en la etiqueta etiTexto aparecerán las dos palabras escritas concatenadas. Por ejemplo, si el usuario escribe en el primer cuadro de texto “Lunes” y en el segundo “Martes”, en la etiqueta aparecerá: “LunesMartes”.

Ejercicio 7: Realizar un programa que muestre 10 etiquetas llamadas respectivamente: etiUna, etiDos, etiTres, etc... Estas etiquetas contendrán los números del 0 al 9. Aparte, la ventana tendrá un cuadro de texto llamado txtNumero. Se pide que cuando el usuario lleve el ratón sobre una de las etiquetas, aparezca en el cuadro de texto el número correspondiente. Los números se van añadiendo al cuadro de texto. Por ejemplo, si el usuario lleva el puntero sobre la etiqueta Uno, luego sobre la etiqueta Tres y luego sobre la etiqueta Uno, en el cuadro de texto debería haber aparecido lo siguiente: 131. Añada un botón llamado btnBorrar, que al ser pulsado borre el contenido del cuadro de texto.

Ejercicio 8: Se pide realizar un programa para resolver las ecuaciones de segundo grado. Las ecuaciones de segundo grado tienen la siguiente forma: ax2+bx+c=0 Dados unos valores para a, b y c, se debe calcular cuánto vale x. Una ecuación de segundo grado puede tener 0, 1 o 2 soluciones. Para saber el número de soluciones de una ecuación de segundo grado se debe realizar el siguiente cálculo: R = b2 – 4ac Si R es menor de cero, la ecuación no tiene solución. Si R da 0, la ecuación tiene una solución. Si R es mayor de cero, la ecuación tiene dos soluciones. Cuando existe una solución, esta se calcula de la siguiente forma: x = -b / (2a) Cuando existen dos soluciones, estas se calculan de la siguiente forma: x = (-b + raiz(R) ) / (2a) x = (-b – raiz(R) ) / (2a) Realice el programa para resolver las ecuaciones de segundo grado. El diseño de la ventana queda a su elección. Procure que el programa indique cuando hay o no soluciones, y que las muestre de forma adecuada.


42

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

Ejercicio 1: Realice un programa para calcular la división de un número A entre un número B. El programa tendrá los siguientes elementos en la ventana: Dos cuadros de texto llamados txtA y txtB donde se introducirán los dos números. Un botón “Calcular División” llamado btnDivision. Una etiqueta llamada etiResultado donde aparecerá el resultado. El programa debe funcionar de la siguiente forma: Cuando se pulse el botón “Calcular División” se calculará la división del número A entre el B y el resultado aparecerá en la etiqueta etiResultado. Si el usuario introduce un valor 0 dentro del cuadro de texto del número B, entonces el programa mostrará un mensaje de error (Use un JOptionPane.showMessage) Si el usuario introduce un valor menor que cero en cualquiera de los dos cuadros de texto, entonces también se mostrará un error.

Ejercicio 2: Realice un programa que permita calcular el sueldo total de un empleado. Para ello, el programa tendrá los siguientes elementos en la ventana: Un cuadro de texto llamado txtSueldoBase. Un cuadro de texto llamado txtMeses. Un botón llamado btnCalcular. Una etiqueta llamada etiResultado. El programa funcionará de la siguiente forma: El usuario introducirá en el cuadro de texto txtSueldoBase la cantidad bruta que cobra el trabajador al mes. En el cuadro de texto txtMeses introducirá el número de meses trabajados. Al pulsar el botón calcular se calculará el sueldo a percibir por el empleado. Se calculará así: Total a percibir = (SueldoBase – 10% del SueldoBase) * Meses Cuando se pulse el botón calcular, antes de que aparezca el sueldo en la etiqueta de resultado, el programa debe pedirle al usuario que introduzca una contraseña. Solo si la contraseña es correcta el programa mostrará el sueldo total. Para introducir la contraseña use un JOptionPane.showInputDialog. Si el usuario introduce una contraseña incorrecta, el programa mostrará un aviso (JOptionPane.showMessage) y el resultado no se mostrará. Invente el valor de la contraseña

Ejercicico 3: Realizar un programa para calcular el índice de masa corporal de una persona. Para ello, creará una ventana con los siguientes elementos: Un cuadro de texto llamado txtPeso, donde se introducirá el peso de la persona. Un cuadro de texto llamado txtTalla, donde se introducirá la talla. Una etiqueta llamada etiIMC donde aparecerá el Indice de masa corporal calculado. Un botón llamado btnCalcular y otro llamado btnLimpiar. El programa funcionará de la siguiente forma: El usuario introducirá un peso y una talla en los cuadros de texto. Luego pulsará el botón calcular para calcular el índice de masa corporal, el cual se calcula así: IMC = Peso / Talla2

IMC CONCLUSIÓN

<18 Anorexia

>=18 y <20 Delgadez

>=20 y <27 Normalidad


43

El IMC calculado aparecerá en la etiqueta, y además, aparecerá un mensaje indicando la conclusión a la que se llega, la cual puede ser una de las siguientes según el IMC: El mensaje puede ser algo así: “Su IMC indica que tiene anorexia”, por ejemplo. Este mensaje aparecerá en un JOptionPane.showMessage.

Cuando pulse el botón Limpiar, se borrarán los cuadros de texto Peso y Talla. Antes de que esto ocurra, el programa debe pedir confirmación, con un cuadro de diálogo de confirmación (JOptionPane.showConfirmDialog). El cuadro de confirmación tendrá el siguiente aspecto:

Según lo elegido por el usuario se borrarán los cuadros de texto o no.

12. CADENAS

Ejercicio 1: Realice un programa cuya ventana tenga los siguientes elementos: Un cuadro de texto llamado txtFrase. Varias etiquetas. (Llámelas como quiera) Un botón “Analizar” llamado btnAnalizar. El programa funcionará de la siguiente forma: El usuario introducirá una frase en el cuadro de texto, y luego pulsará el botón Analizar. Al pulsar Analizar, el programa mostrará la siguiente información en las etiquetas: La frase en mayúsculas. La frase en minúsculas. Número de caracteres de la frase. Número de caracteres de la frase sin contar los espacios. Si el usuario pulsa Analizar cuando no hay ninguna frase introducida en el cuadro de texto, el programa debe mostrar un error emergente (JOptionPane)

Ejercicio 2: Realice un programa cuya ventana tenga los siguientes elementos: Un cuadro de texto llamado txtFrase y otro llamado txtSubcadena. Varias etiquetas. Un botón “Analizar” llamado btnAnalizar. El programa funcionará de la siguiente forma: El usuario introducirá una frase en el cuadro de texto txtFrase, y luego introducirá una palabra en el cuadro de texto txtSubcadena, y luego pulsará el botón Analizar.

>=27 y <30 Obesidad (grado 1)



>=40 y Obesidad mórbida


44

Al pulsar el botón, el programa debe mostrar la siguiente información: La posición en la que se encuentra la primera aparición de la palabra en la frase. La posición en la que se encuentra la última aparición de la palabra en la frase. Mostrará el texto que hay en la frase antes de la primera palabra. Mostrará el texto que hay en la frase después de la última palabra. Por ejemplo, si la frase fuera: Un globo, dos globos, tres globos. La luna es un globo que se me escapó. Y la palabra fuera globo, entonces la información a mostrar sería: Posición inicial: 3 Posición final: 49 Texto anterior: Un Texto posterior: que se me escapó Si la palabra no se encuentra en la frase, el programa mostrará un mensaje indicando un errorJ y no se presentará nada en las etiquetas.

Ejercicio 3: Realice un programa que tenga los siguientes elementos: Un cuadro de texto llamado txtFrase. Un cuadro de texto llamado txtPalabra1. Un cuadro de texto llamado txtPalabra2. Un cuadro de texto llamado txtPalabra3.

Un cuadro de texto llamado txtPalabra4. Varias etiquetas. Un botón “Analizar” llamado btnAnalizar.

El programa funcionará de la siguiente forma: El usuario introducirá una frase en el cuadro de texto txtFrase, y tres palabras en los cuadros de texto de las palabras. Al pulsar el botón Analizar, el programa debe indicar la siguiente información en las etiquetas: Indicará si la frase es igual a la palabra 1. Indicará si la frase empieza por la palabra 2. Indicará si la frase termina por la palabra 3. Indicará si la palabra 4 está contenida en la frase, y en el caso de que esté contenida, se indicará la posición inicial en la que se encuentra.

Ejercicio 4: Realizar un programa cuya ventana tenga los siguientes elementos: Un cuadro de texto llamado txtFrase. Varias etiquetas. Un botón “Analizar” llamado btnAnalizar. El programa debe contar cuantas vocales tiene la frase. El funcionamiento será el siguiente: El usuario escribirá una frase en el cuadro de texto txtFrase. Luego se pulsará el botón Analizar. El programa mostrará en las etiquetas el número de a, de e, de i de o y de u que se encuentran en la frase. Tenga en cuenta que puede haber vocales en mayúsculas y en minúsculas. Si el usuario no introduce nada en el cuadro de texto txtFrase, entonces el programa debería mostrar un error.

Ejercicio 5: Realizar un programa cuya ventana tenga los siguientes elementos: Un cuadro de texto llamado txtIdentificación. Una etiqueta llamada etiIdentificación. Un botón “Preparar Identificación” llamado btnPrepararIdentificación. El programa funcionará de la siguiente forma: El usuario introducirá un # de cédula en el cuadro de texto llamado txtIdentificacion y luego pulsará el botón Preparar Identificación. El resultado será que la identificación introducida aparecerá “preparada” en la etiqueta etiIdentificacion. A continuación se explica cómo preparara la identificación:


45

El usuario puede introducir una identificación con uno de estos formatos: 1-123-890 1 – 0123 – 0890 etc. Sin embargo, cuando el usuario pulse el botón Preparar Identificación, en la etiqueta etiIdentificacion debe aparecer la identificación con el siguiente formato: 1123890. Es decir, sin ningún espacio y sin puntos ni guiones. Si el usuario no introduce nada en el cuadro de texto del DNI y pulsa el botón, entonces debe aparecer un error emergente (JOptionPane).

13. LA CLASE JFRAME

Ejercicio 1: Realizar un programa cuya ventana contanga los siguientes elementos: Un cuadro de texto llamado txtTitulo.

Un botón “Cambiar Título” llamado

btnCambiarTitulo.

Un botón “Maximizar” llamado btnMaximizar.

Un botón “Minimizar” llamado btnMinimizar.

Un botón “Restaurar” llamado btnRestaurar.

Un cuadro de texto llamado txtPosicionX.

Un cuadro de texto llamado txtPosicionY.

Un botón “Mover” llamado btnMover.

Un botón “Centrar” llamado btnCentrar.

Un botón “Estilo Java” llamado btnEstiloJava.

Un botón “Estilo Windows” llamado

btnEstiloWindows.

Un botón “Rojo” llamado btnRojo.

Un botón “Verde” llamado btnVerde.

Un botón “Azul” llamado btnAzul.

El funcionamiento del programa será el siguiente: Si el usuario pulsa el botón “Cambiar Titulo”, el título de la ventana cambiará, colocándose como título lo que el usuario haya escrito en el cuadro de texto txtTitulo. Si el usuario pulsa el botón “Maximizar”, la ventana se maximizará. Si el usuario pulsa el botón “Minimizar”, la ventana se minimizará. Si el usuario pulsa el botón “Restaurar”, la ventana se restaurará. Si el usuario pulsa el botón “Mover”, la ventana se colocará en la posición de la pantalla que venga indicada por los valores x, y, introducidos respectivamente en los cuadros de texto txtPosicionX y txtPosicionY. Si el usuario pulsa el botón “Centrar”, la ventana se colocará en el centro de la pantalla. Si el usuario pulsa el botón “Estilo Java”, entonces toda la ventana cambiará a la visualización Java. Si el usuario pulsa el botón “Estilo Windows”, entonces toda la ventana cambiará a la visualización Windows. Si el usuario pulsa uno de los botones de color, entonces el fondo de la ventana se cambiará al color indicado. Además, el programa contará con las siguientes características: Al iniciarse el programa, este debe pedir una contraseña al usuario. Si el usuario introduce la contraseña correcta, entonces el usuario entrará en el programa. En caso contrario el programa se cerrará. Al finalizar el programa, este debe pedir una confirmación al usuario: ¿Desea salir del programa? Si el usuario responde Sí, entonces el programa finalizará. En caso contrario, el programa seguirá funcionando.

14. VARIABLES GLOBALES

Ejercicio 1: Realizar un programa cuya ventana contenga los siguientes elementos:

- Un cuadro de texto llamado txtNumero. - Un botón “Acumular” llamado btnAcumular. - Un botón “Resultados” llamado

btnResultados. - Un botón “Reiniciar” llamado btnReiniciar.

- Una etiqueta con borde llamada etiMayor. - Una etiqueta con borde llamada etiSuma. - Una etiqueta con borde llamada etiMedia. - Una etiqueta con borde llamada etiCuenta.

El programa funcionará de la siguiente forma:


46

- El usuario introducirá un número en el cuadro de texto txtNumero y luego pulsará el botón “Acumular”. En ese momento se borrará el número introducido en el cuadro de texto.

- Este proceso lo repetirá el usuario varias veces. - Cuando el usuario pulse el botón “Resultados”, deben aparecer en las etiquetas los siguientes datos:

o El número mayor introducido hasta el momento. o La suma de los números introducidos hasta el momento. o La media de los números introducidos hasta el momento. o Cuantos números ha introducido el usuario hasta el momento.

- El botón “Reiniciar” reinicia el proceso borrando todo lo que hubiera en las etiquetas de resultados y reiniciando las variables globales.

Variables globales a usar Para que sirva de ayuda, se recomienda que use las siguientes variables globales:

- Una variable double llamada mayor. Contendrá en todo momento el número mayor introducido. - Una variable double llamada suma. Contendrá en todo momento la suma de los números

introducidos. - Una variable int llamada cuenta. Contendrá en todo momento la cuenta de todos los números

introducidos hasta ahora. Al comenzar el programa, y al pulsar el botón “Reiniciar”, será necesario que estas tres variables se inicien a 0. Nota. Se supondrá que todos los números introducidos serán mayores o iguales a 0.

Ejercicio 2: Realizar un programa que contenga los siguientes elementos en su ventana: - Un cuadro de texto llamado txtNumero. - Un cuadro de texto llamado txtApuesta - Un botón “Jugar” llamado btnJugar. - Una etiqueta llamada etiNumero. - Una etiqueta llamada etiResultado que contendrá inicialmente un “100”.

El programa funcionará de la siguiente forma: - Se trata de un juego de adivinación. El usuario introducirá un número entre 1 y 10 en el cuadro de

texto txtNumero. - Luego introducirá una apuesta en el cuadro de texto txtApuesta. - Y a continuación pulsará el botón “Jugar”. - El programa calculará entonces un número al azar entre 1 y 10 y lo mostrará en la etiqueta

etiNumero. - Si el número introducido por el usuario coincide con el número elegido al azar por la máquina,

entonces el usuario gana y se le debe sumar lo apostado a la cantidad que tenía en dicho momento. Si el usuario pierde entonces se le debe restar lo apostado a la cantidad que tenía. El total que le quede debe aparecer en la etiqueta resultado.

- Al empezar el programa el usuario tiene $100. Las variables globales a usar son las siguientes:

- Solo se necesita una variable global de tipo double a la que puedes llamar ganancias. Esta variable estará inicializada al comienzo del programa a 100.

Para hacer que el ordenador calcule un número aleatorio entre 1 y 10 debes usar el siguiente código: int numeroMaquina=(int) ((Math.random() * 10) + 1);


47

15. CUADROS DE DIÁLOGO

Ejercicio 1: Se pide realizar un programa que facilite el cálculo del precio de implantación de un determinado software en una empresa. Se pretende calcular el coste de instalación, el coste de formación y el coste de mantenimiento. Para ello, debe realizar un proyecto con una ventana como la que sigue: Esta ventana tiene tres cuadros de textos, para cada uno de los costes. Si se desea, se puede introducir directamente cada uno de los costes en estos cuadros de textos y al pulsar el botón Calcular aparecerá la suma de los tres en la etiqueta Total. Por otro lado, cada cuadro de texto tiene asignado un botón con tres puntos que permitirá facilitar el cálculo de cada coste a través de un cuadro de diálogo. El objeto Dialog o Ventana la selecciona de la Paleta Swing categoría ventanas…

Cuadro de diálogo Coste de Instalación En el caso de que se pulse el botón correspondiente al Coste de Instalación, el cuadro de diálogo que debe aparecer tiene que ser el siguiente (haz que sea modal): Aquí se indicará el número de copias de la versión simplificada del programa a instalar, y el número de copias de la versión completa. Al pulsar el botón Aceptar, se mostrará el coste total por instalación en el cuadro de texto correspondiente de la ventana principal y luego se cerrará el cuadro de diálogo. Para calcular el coste de instalación, ten en cuenta lo siguiente: Cada copia de la versión simplificada cuesta $250, y cada copia de la versión completa cuesta $500. Si por ejemplo, el usuario introduce 1 copia simplificada y 2 de la versión completa, el coste total será: Coste por instalación = 250 * 1 + 500 * 2 = 1250


48

Si se pulsa el botón Cancelar, el cuadro de diálogo se cierra y no se muestra nada en el cuadro de texto del coste de instalación de la ventana principal. Cuadro de diálogo Coste de Formación En el caso de que se pulse el botón correspondiente al Coste de Formación, el cuadro de diálogo que debe aparecer tiene que ser el siguiente (haz que sea modal): El coste de formación se calculará multiplicando el número de alumnos por el número de horas por $10. Por ejemplo, si el usuario introduce 3 alumnos y 12 horas, el coste por formación será: Coste por formación = 2 * 12 * 10 = 240. Al pulsar el botón Aceptar, se calculará dicho coste y se introducirá en el cuadro de texto del coste de formación de la ventana principal (luego el cuadro de texto se cerrará). Si se pulsa el botón Cancelar, el cuadro de diálogo simplemente se cerrará, sin que ocurra nada más. Cuadro de diálogo Coste de Mantenimiento En el caso de que se pulse el botón correspondiente al Coste de Mantenimiento, el cuadro de diálogo que debe aparecer tiene que ser el siguiente (haz que sea modal): Al pulsar Aceptar, el programa calculará el coste de mantenimiento y lo presentará en el cuadro de texto correspondiente de la ventana principal (y luego se cerrará el cuadro de diálogo) La forma de calcular el coste de mantenimiento es la siguiente: Si se elige un mantenimiento Anual, entonces el coste será de $600. Si se elige un mantenimiento Semestral, entonces el coste será de $350. Si se elige un mantenimiento del tipo Puesta en funcionamiento entonces el coste será de $200. Si se pulsa el botón Cancelar, el cuadro de diálogo se cierra sin más. MEJORAS Ayuda

Añade un botón a la ventana principal con esta forma: Al pulsar este botón, aparecerá un cuadro de diálogo de ayuda con este aspecto. Al pulsar el botón Cerrar, el cuadro de diálogo simplemente se cerrará.


49

Para hacer el texto, usa el objeto JTextArea, y su propiedad text. Este objeto permite crear cuadros con gran cantidad de texto. Ten en cuenta que cuando añadas un JTextArea este aparecerá dentro de un JScrollPane.

Pantalla de Splash (Presentación) Se añadirá un nuevo cuadro de diálogo al proyecto que servirá como pantalla de presentación (a estos cuadros de diálogo se les suele denominar Splash) Diseñe este cuadro de diálogo como quiera. Puede añadir varias imágenes, colocar el texto donde quiera, etc. Debe mostrar este cuadro de diálogo al comenzar el programa (en el evento windowOpened del formulario) Si quiere mostrar el cuadro de diálogo de la presentación en el centro de la pantalla, puede usar este código (se supone que el cuadro de diálogo se llama winSplash): int x=(int) (Toolkit.getDefaultToolkit().getScreenSize().getWidth()/2 - winSplash.getWidth()/2); int y=(int) (Toolkit.getDefaultToolkit().getScreenSize().getHeight()/2 - winSplash.getHeight()/2); winSplash.setLocation(x,y); El cuadro de diálogo debe tener un botón Cerrar, o bien, debe tener la posibilidad de cerrarse cuando el usuario haga clic sobre él en cualquier parte. Para mejorar su cuadro de diálogo de presentación, se recomienda que active la propiedad del cuadro de diálogo llamada: Undecorated winSplash.setUndecorated(true);. Esta propiedad oculta la barra de título del cuadro de diálogo.


50

16. EJERCICIOS PROPUESTOS 16.1. Sentencias de control repetitivas 1. Escriba un programa que lea un número entero por teclado y escriba la tabla de multiplicar de ese

número.

2. Escriba un programa que muestre por pantalla la tabla de multiplicar de los 10 primeros números (1,2,3....9,10.).

3. Calcular la suma de las siguientes series:

a)

b)

4. Realice un programa que lea números enteros positivos hasta que se introduzca un 0. El programa

deberá mostrar por pantalla la cantidad de números leídos, el promedio, así como el valor máximo introducido.

5. Realice un programa que calcule y visualice el más grade, el más pequeño y el promedio de n

números (n>0). El valor de n se solicitará al principio del programa y los números serán introducidos por el usuario.

6. Realizar un programa que pida dos números enteros por teclado y muestre por pantalla el siguiente menú:

El usuario deberá elegir una opción y el programa deberá mostrar el resultado por pantalla y

después volver al menú. El programa deberá ejecutarse hasta que se elija la opción 5. Salir.

Modificar el ejercicio anterior para que al elegir la opción 5, en vez de salir del programa directamente, nos muestre el siguiente mensaje de confirmación:

De modo que si elegimos sí salgamos del programa, pero si pulsamos el botón no, volvamos al menú.

7. Realice un programa que calcule el factorial de un número dado por teclado. Realice este ejercicio utilizando primero un bucle for y posteriormente repita el ejercicio utilizando un bucle while.

8. Realice un programa que determine si un número leído del teclado es primo o no.


51

9. Un número perfecto es un entero positivo, que es igual a la suma de todos los enteros positivos

(excluido él mismo) que son divisores del número. El primer número perfecto es 6, ya que los divisores de 6 son 1, 2, 3 y 1 + 2 + 3 = 6. Escriba un programa que lea un número entero positivo n y muestre por pantalla si ese número es o no perfecto.

10. Realice un programa que lea un número entero por teclado y devuelva por pantalla el número de dígitos que componen ese número. Por ejemplo, si introducimos el número 12334, el programa deberá devolver 5. (Pista: utilice el operador %, averigüe para qué sirve y piense cómo utilizarlo).

11. Realice un programa que lea un número entero por teclado y devuelva por pantalla las que forman ese número. Por ejemplo, si se introduce el número 2345, el programa deberá mostrar por pantalla 5 – 4 – 3 – 2. (Pista: utilice el ejercicio anterior como base para realizar este ejercicio).

Ejercicios que usan números aleatorios para realizar juegos y simulaciones

12. Realizar un programa que simule un juego de adivinar un número. El programa pedirá al usuario dos números que representan el rango de valores entre los que se encuentra el número a adivinar, así como el número de intentos para adivinar el número. A continuación el programa generará un número aleatorio entre esos dos números y el usuario deberá adivinarlo en el número máximo de intentos antes indicado. Cada vez que el jugador introduce un número el programa le dice si es mayor o menor y le indica cuantos intentos le quedan.

13. Realice un programa que pregunte

aleatoriamente cualquier multiplicación. El programa debe indicar si la respuesta ha sido correcta o no (en caso que la respuesta sea incorrecta el programa debe indicar cuál es la correcta). Una vez preguntado por una multiplicación el programa debe preguntar si desea realizar otra. En caso afirmativo preguntará aleatoriamente otra multiplicación. En caso negativo el programa finalizará.

14. Modificar el ejercicio anterior de modo que el programa pregunta aleatoriamente un total de n multiplicaciones siendo n un número dado por teclado. En cada multiplicación el programa debe indicar si se ha acertado o no. Al final del programa, éste deberá mostrar un resumen indicando el número de respuestas correctas y erróneas, así como el porcentaje de aciertos y de fallos.

15. Realice un programa que genere aleatoriamente 7 operaciones aritméticas consecutivas a las que el usuario deberá ir respondiendo correctamente para ir avanzando. Los números (aleatorios) sobre los que se realizan las operaciones deben estar comprendidos entre 2 y 9 y las operaciones aritméticas (también aleatorias) permitidas serán la suma, resta, multiplicación y división (en el caso de la división se realizará siempre una división entera).

Ejemplo:

1. 5 x 4 = 20 2. 20 – 4 = 16 3. 16 / 8 = 2 4. 2 x 6 = 10 Incorrecto 5. 3 x 3 = 9 6. 12 – 7 = 2 Incorrecto 7. 12 – 7 = 5


52

16.2. Ejercicios propuestos funciones

1. Escribir un programa que pida un número por teclado y nos diga si ese número es primo. El

programa deberá utilizar una función definida por el usuario, a la que se le pase un número y nos devuelva un 0 en el caso de que el número que le pasemos no sea primo, y un 1 en caso contrario.

2. Escribir un programa que pida un número natural por teclado y nos diga si ese número es perfecto (un número natural es perfecto si es igual a la suma de sus divisores, excluido él mismo). El programa deberá utilizar una función definida por el usuario, a la que se le pase un número y nos devuelva un 0 en el caso de que el número que le pasemos no sea perfecto, y un 1 en caso contrario.


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:


53

Ejercicios propuestos de un nivel de dificultad mayor.

11. Escriba una función que decida si un número entero es capicúa. La palabra capicúa (en matemáticas, número palíndromo) se refiere a cualquier número que se lee igual de izquierda a derecha y de derecha a izquierda (Ejemplos: 101, 111, 121,..., 181, 191, 202, 212,..., 292, 303, 313,..., 898, 909, 919, 929,..., 979, 989, 999, etc)

12. Escriba una función que calcule la suma de los divisores de un número entero positivo, pudiendo excluir de dicha suma el propio número (será un parámetro adicional (valor 1 o 0) quien determinará si se suma o no).

13. Construya una función, llamada amigos, que apoyándose en la función anterior, permita ver si dos números son o no amigos (dos números A y B son amigos si la suma de los divisores de A (excluido él mismo) coincide con B y viceversa)


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

70041149 02 introduccion a la programacion con java

Documents