Lectura 4
Lectura 4
CAPITULO 7
Objetivos
• Establecer cómo pasar del modelo de Objetos al lenguaje de
programación.
• Identificar los componentes de un programa en Java.
• Representar en código Java las principales relaciones de
asociación de clases
• Identificar y definir los diferentes tipos de datos primitivos.
• Identificar, definir y realizar operaciones con los operadores
disponibles en Java.
• Definir y manejar arreglos unidimensionales y
bidimensionales.
• Identificar, definir y caracterizar las instrucciones de control de
flujo en Java.
• Aplicar las instrucciones selección y de ciclos o repeticiones
en la solución de problemas.
• Aplicar las instrucciones de selección múltiple en la solución
de problemas.
• Aplicar las instrucciones para manejo de saltos.
• Uso de los componentes JOPtionPane, ScrollPane y JTextArea
para la entrada y salida.
Programación Java básica: Programación Java básica 7 - 2
Introducción
En los capítulos anteriores se han presentado ejemplos y ejercicios que
involucran la utilización de variables que almacenan tipos específicos de datos,
así como constantes y operadores para realizar operaciones tanto aritméticas
como relacionales.
Para tal efecto se han diseñado aplicaciones que le dan forma a las clases
asociadas con cada uno de los problemas a resolver. Aunque no se ha dado la
estructura formal de las clases, tanto las aplicaciones como las applets ilustradas
le dan al lector estudioso una idea de la estructura general que tienen estos tipos
de programas en Java.
En este capítulo se tratará en detalle el tema de los tipos de datos, así como sus
rangos(valores que puede tomar un dato un tipo dado) y operaciones para su
manipulación.
Se plantea una serie de ejercicios que el lector debe realizar a fin de desarrollar
las habilidades necesarias para incursionar con propiedad en el desarrollo de
aplicaciones en Java.
En Java todo son objetos, con lo cual, un programa es un objeto, que se crea a
partir de la clase que lo representa cuando esta se ejecuta en un computador.
Nótese que al ser compilado un programa en lenguaje fuente, se genera un
archivo .class con el nombre de la respectiva clase. El objeto de la clase de
un programa compilado, se crea a partir de la ejecución de esa clase, lo cual
hace que, cada vez que se ejecute el archivo .class se crea en la memoria del
computador una instancia de esta clase, o sea un objeto. Los datos o mensajes
que se suministren a este objeto en tiempo de ejecución, harán que éste arroje
los resultados esperados.
AreaVolCilindro
entero radio,altura;
real area, volumen;
metodo1();
1.import javax.swing.JOptionPane;
2.public class AreaVolCilindro{
3.static int radio, altura;
4.static float area, volumen;
5. public static void main(String args[]){
6. String dato1, dato2;
7. dato1 = JOptionPane.showInputDialog("Digite valor
radio de la base:");
8. radio = Integer.parseInt(dato1);
9. dato2 = JOptionPane.showInputDialog("Digite valor
altura:");
10. altura = Integer.parseInt(dato2);
11. area = (float)((2*3.1416*radio)*altura +
2*3.1416*radio*radio);
12. volumen = (float)(3.1416*radio*radio)*altura;
13. JOptionPane.showMessageDialog(null, "El area es =
"+ area +"\nEl volumen es = "+volumen );
14. }
15. }
Lineas 9-10: hacen lo mismo que las anteriores, pero esta vez para la altura:
S = 1 - 2! + 3! +4! - 5! + 6! + 7! ...
SumaFactorial
int suma, n;
void main();
Para este caso, el método main() contiene el desarrollo en Java del algoritmo
respectivo para el cálculo de la sumatoria solicitada y la entrada y salida de
valores por medio del componente JoptionPane, como en el problema
Programación Java básica: De la representación de objetos a Java 7 - 10
anterior.
Figura 5 Entrada de n
SumaFactorial
int n;
int sumatoria();
void main();
Programación Java básica: De la representación de objetos a Java 7 - 11
PruebaSumaFac SumaFactorial
int n;
14. }
15. }
Un programa se puede conformar de más de una clase, en cuyo caso las demás
clases diferentes a la clase principal se deben compilar por separado y
almacenarse en el mismo directorio donde se ha compilado la clase principal.
Cada clase está formada por atributos, los cuales pueden ser variables de algún
tipo u objetos, así como de métodos, los cuales están formados por
instrucciones tanto aritméticas, lógicas y relacionales, de instrucciones de
control de flujo como son los ciclos y las repeticiones. Dentro del cuerpo de los
métodos se encuentran además las variables, que pueden ser de tipo entero,
lógico, carácter, booleano, la invocación de métodos y objetos y el manejo de
funciones.
Identificadores en Java
Por identificadores se entiende los nombres dados a variables, métodos, clases,
paquetes e interfaces (que se definirán más adelante). Los identificadores no son
Programación Java básica: De la representación de objetos a Java 7 - 17
El espacio en blanco
El espacio en blanco corresponde al carácter que se produce cuando se presiona
la barra de espaciamiento en el teclado del computador y que se utiliza para
separar palabras. Existen en Java otros cuatro espacios en blanco: la tabulación
horizontal (horizontal tab), la alimentación de formas (form feed), el retorno de
carro o enter (carriage return) y la alimentación de una línea (line feed). Cuando
se presiona la tecla de enter o de retorno, se produce la inserción de una línea o
un retorno de carro, lo cual se refleja en el código fuente como una nueva línea.
Aparte del uso de espacios en blanco en las literales de caracteres (String), Java
sin importar cuantos espacios se utilicen los toma como uno. Se usa también
para separar operandos, símbolos, palabras. El número de espacios que utilice
es solamente para una mejor presentación visual a quien lee el programa en
lenguaje fuente.
Dentro del cuerpo de una literal tipo carácter de los caracteres mencionados que
Java toma como un solo espacio en blanco, sólo se permite escribir
directamente el carácter espacio en blanco. Retornos de carro, tabulaciones,
lineas y formas de alimentación, pueden ser insertadas utilizando las secuencias
de escape:
Tipos de datos
Los tipos de datos hacen referencia tanto al tipo de contenido, como a la forma
como es almacenado en la memoria del computador. Accesar al contenido de un
tipo de datos en particular se hace mediante nombres o identificadores.
Veamos algunos aspectos generales sobre los tipos de datos, comparando C++ y
Java:
Programación Java básica: Tipos de datos 7 - 20
En Java cada variable, cada expresión, tienen un tipo de dato. Así mismo cada
tipo está definido estrictamente. El compilador Java comprueba todas las
asignaciones, bien explícitas o mediante paso de parámetros en llamadas de
métodos, todas las conversiones, expresiones y parámetros, para asegurar la
compatibilidad de los tipos de datos.
En esa lista se observa que fabricante, puede ser a su vez una clase y
contendría entonces la información sobre su dirección, nombre, teléfono,
Programación Java básica: Tipos de datos 7 - 21
página web, métodos para vender, financiar, hacer mantenimiento y otros. Los
demás atributos hacen referencia a tipos simples que pueden contener
información numérica o alfanumérica.
Se puede identificar que entre sus atributos hay uno con información numérica
con decimales como es el caso del precio y de contenido alfabético como es el
color y alfanumérico como la serie. Todos ellos son tipos de datos
primitivos, como se explica a continuación.
Enteros
Los enteros representan las cantidades que no tienen parte decimal o
fraccionara. Gran parte del trabajo computacional se fundamenta en la
manipulación de cantidades enteras con signo, es decir que pueden tomar
valores positivos o negativos.
cantidad numérica tiene signo, para el caso de los enteros uno de los bits se deja
para el signo. De esta manera, la capacidad de almacenamiento de valores
enteros en 8 bits (de los cuales toma uno para el signo, el de la izquierda por
ejemplo) será uno para el signo y en los siete restantes 1111111 binario que
corresponde al decimal 127. Igual calculo se puede hacer para el
almacenamiento en tamaño de 16, 32 o 64 bits.
byte contador;
Los índices de arreglos, como por ejemplo el arreglo arg[] usado como
argumento en el método main(String arg[]) puede ser de tipo int , ya que
su rango difícilmente superaría los 128 elementos. Pero si se requiere un arreglo
con mayor numero de indices, se utilizaría el tipo short.
Para el caso de tres variables cuyos valores están dentro del rango del tipo int
su declaración se puede hacer con
short numeroVehiculos, numeroEstudiantes, cantidadPedida;
Valores reales
Los valores reales o de punto flotante se utilizan para cálculos que requieran
mayor precisión, la cual se define como la cantidad de dígitos significativos que
maneja el computador exactamente para un tipo de datos dado. Por ejemplo, la
raíz cuadrada y las funciones trigonométricas como el seno y el coseno. Estos
tipos de datos almacenan los bits mas significativos, o sea la mantisa, aparte
del exponente. Todas las funciones matemáticas trascendentes como sin(),
cos(), sqrt() devuelven valores de doble precisión.
Programación Java básica: Tipos de datos 7 - 24
Los valores en precisión float o simple, requieren la mitad del espacio que
la precisión doble, siendo más rápida, sin embargo es imprecisa cuando los
valores son muy grandes o muy pequeños. Las variables float son útiles
cuando no se requiere mucha precisión.
En ambos casos, float y double, una parte del tamaño en bits se toma para el
signo de la mantisa, otro para la mantisa, otro para el signo del exponente y otra
parte para el exponente. Dando así los rangos de valores indicados. Nótese que
aunque el rango cubierto es muy grande, la precisión se limita al número de
dígitos significativos de cada tipo.
Valores char
El tipo de datos para almacenar caracteres es el char. Java utiliza el código
Unicode para representar caracteres. Este sistema define un conjunto de
caracteres completamente internacional, que puede representar todos los
caracteres encontrados en todos los idiomas y lenguas. Es la unificación de
docenas de conjuntos de caracteres como latino, griego, arábigo y muchos mas.
Para lograr esto el tipo de dato char utiliza 16 bits, por tanto el rango de
caracteres es de 0 a 65.536 (1111111111111111 en binario). Tiene sentido la
utilización del sistema unicode ya que Java esta diseñado apara permitir que los
applets se puedan utilizar en todo el mundo. Información sobre unicode está
disponible en
http://www.unicode.org y en http://www.stonehand.com/unicode.html
Valores Booleanos
Por definición, los valores booleanos tienen un bit de almacenamiento, solo
pueden tomar uno de dos valores, true (verdadero) o false (falso). Este es el
tipo que devuelven los operadores de comparación relacionales, como en la
expresión area1 < area2 , o el requerido en las expresiones condicionales que
controlan el flujo como if , for , do, while. Una variable de este tipo, al ser
creada toma como valor predeterminado false.
Literales en Java
Literales son código fuente de Java que significan justamente lo que ellas dicen
en su asignación literalmente. Una literal es una constante, por ejemplo, “Soy
una Applet”, es una literal tipo String y significa que tiene almacenado el
mensaje o cadena Soy una Applet. Para el compilador aunque tiene mas de un
carácter, representa una sola cosa: una literal tipo String. Así mismo 9.86
aunque tiene mas de un dígito o carácter, es considerado como una literal
numérica. Cada tipo de datos permite la manipulación del mismo tipo de
literales según el tipo.
Los valores octales en Java van precedidos por un 0 (cero), por lo cual el valor
06 representa una literal entera en base octal. El rango de los dígitos octales van
del 0 al 7.
La base hexadecimal es una base común para los números utilizados por los
Programación Java básica: Tipos de datos 7 - 28
Los literales enteros crean por defecto un valor tipo int, que en Java tiene un
tamaño de 32 bits. Cuando se asigna un valor literal a una variable entera
byte o short, no se genera error alguno si el literal esta dentro del rango del
tipo destino. Para las literales o constantes enteras a especificar como long es
necesario decirle de forma explícita al compilador que el valor literal es de tipo
long, mediante la adición de la letra L (mayúscula o minúscula) al final de la
literal. Los siguientes son algunos ejemplos de asignación de constantes enteras
a variables:
Constante1 = 9456748378L; // entero decimal en 64 bits
Constante2 = 0X6785ABL; // hexadecimal entero en 64 bits
Constante3 = 30567; // entero decimal en 32 bits
Constante4 = 067543; // entero octal en 32 bits
Constante5 = 0786545678L; // entero octal en 64 bits
Las literales de coma flotante son almacenadas por defecto en doble precisión
(double) o sea en 64 bits. Si se desea especificar una literal tipo float en 32
bits, se le debe añadir a la constante una F, o f al final. Los siguientes son
algunos ejemplos de literales de coma flotante:
Constante1 = 7.98768 E 23;
Constante2 = 3.3657 E-21;
Constante3 = 4.6543F;
Constante4 = 56878.4328;
Programación Java básica: Tipos de datos 7 - 29
Literales Booleanos
Un valor booleano se expresa solamente con uno de los dos valores lógicos,
true (verdadero) y false (falso). Los valores true y false, no son
equivalentes a representación o expresión numérica alguna, es decir no
equivalen a 1 y 0 respectivamente como en C o C++ . Las siguientes son
asignaciones literales booleanos a dos variables, obviamente del tipo de datos
booleano.
Respuesta1 = true;
Respuesta2 = false;
Literales Char
Estas literales se almacenan en 16 bits sin signo, y corresponden a índices del
conjunto de caracteres Unicode. Estos literales se pueden convertir a enteros y
ser manipulados con los operadores de los enteros. Un carácter literal tipo
char se representa dentro de un par de comillas simples ( ´ ´ ). Los
caracteres visibles en ASCII se introducen directamente entre el par de
comillas. Aquellos que no se los puede representar directamente se utilizan
secuencias de escape, como por ejemplo ´\n´ , para el carácter cuyo función es
crear una nueva línea, o ´\r´ para el retorno de carro. Las siguientes son algunas
secuencias de escape:
\ddd carácter octal
\uxxxx caracter UNICODE hexadecimal (xxxx)
\´ comilla simple
\´´ comilla doble
\\barra invertida
\rretorno de carro
\nnueva linea
\falimentar página
\ttabulador
\bretroceso
Operadores en Java
Un operador es un símbolo que representa una operación que toma uno o mas
argumentos u operandos y opera sobre ellos a fin de generar un resultado.
Típicamente los operadores en un programa están entre identificadores y
literales de tipo numérico. Algunos están antes del operando y se denominan
prefijos, otros después y se denominan posfijos, algunos toman un solo
operando y se denominan operadores unitarios unarios, los que requieren dos
operandos se denominan binarios.
Operadores aritméticos
Los operadores aritméticos se utilizan para realizar operaciones matemáticas,
exactamente como están definidas en el Álgebra. La siguiente tabla ilustra la
lista de los operadores aritméticos:
import javax.swing.JOptionPane;
class CuatroOperaciones{
Programación Java básica: Operadores en Java 7 - 31
Operador módulo
Este operador permite calcular el residuo de una división tanto para tipos
enteros o de coma flotante.
class CalculoModulo{
public static void main(String args[]){
int z = 53;
double w = 52.150;
JOptionPane.showMessageDialog(null,z+" modulo 10 = "+z %
10+
"\n"+ w + " modulo 10 = " + w % 10);
}
}
Operador Descripción
= Es el operador de asignación sencilla; coloca el valor de la
expresión del lado derecho en la variable de la parte izquierda del
signo igual.
variable1
variable2 = variable2 - 1; //decrementa en la unidad a
variable2
variable1= 65;
variable2 =variable1++;
import javax.swing.JOptionPane;
class ContCreceDecrece{
public static void main (String args[]) {
String salida1 ="Valores crecientes de i:";
String salida2 ="Valores decrecientes de i:";
// el siguiente segmento es creciente
for (int i = 0; i < 7; i++) {
salida1 = salida1+"\nvalor de i = " + i;
}
JOptionPane.showMessageDialog(null,salida1);
// el siguiente segmento es decreciente
for (int i = 7; i > 0; i--) {
salida2=salida2+"\nvalor de i = " + i;
}
JOptionPane.showMessageDialog(null,salida2);
}
}
Operadores Relacionales
Los operadores relacionales permiten establecer la relación de un operando
respecto de otro. Cualquier tipo de operandos, integer, float, char y
boolean, pueden ser comparados mediante el operador de igualdad lógica ==
y el de desigualdad lógica !=. Los operandos de tipo integer, float, char
Programación Java básica: Operadores en Java 7 - 36
pueden ser usados para efectos de comparación mayor que o menor que. El
resultado de una operación relacional es de tipo booleano.
Línea 4: se crea un objeto areaSalida del tipo JtextArea que es una clase
a partir de la cual se crean componentes para generar áreas de texto editable, es
decir, que se puede modificar en la pantalla. Al área de texto se le asigna 17
columnas, por 20 filas medidas en caracteres.
Linea 5: se crea un objeto scroller del tipo JScrollPane, que es una clase
a partir de la cual se crean componentes desplazables. Su desplazamiento es en
el sentido horizontal ( en la parte inferior del área) y en el sentido vertical (en la
parte derecha del área). Dentro de este componente se coloca como argumento
el componente areaSalida.
Linea 38: para terminar la ejecución del programa se invoca el método exit
(0) de la clase System.
Las formas de los operadores en cortocircuito && y ||, en lugar de las formas &
y | hará que Java no se preocupe en evaluar el operando o expresión del lado
derecho cuando el resultado de la operación ya este decidido a partir del
operando o expresión del lado izquierdo. En algunos casos esto puede no ser
deseable, refiérase a la discusión anterior sobre pre y post-incremento y
operadores de asignación.
Programación Java básica: Operadores en Java 7 - 41
Instrucción if - else
Tal como se vio en el Capítulo 2, esta instrucción permite, con base a la
evaluación de un predicado o condición de tipo lógico, direccionar el flujo de
la ejecución de un programa hacia uno de dos caminos diferentes. La forma
general de esta instrucción en Java es como sigue:
if (expresión booleana) instrucción1;
else instrucción2;
if (expresión booleana) {
instrucción11;
instrucción12;
....
}
else {
Programación Java básica: Instrucciones de control de flujo: selección 7 -
42
instrucción21;
instrucción22;
...
}
if (expresión booleana){
instrucción1;
....
}
instrucción3;
Instrucciónes if anidadas
Es muy común que en los programas sea necesario que la evaluación del
predicado de una instrucción if o if-else sea el destino de otra instrucción if o
if-else, en cuyo caso se denominan if anidados. Cuando se utilizan if anidados,
es importante tener en cuenta que, una cláusula else se refiere a la instrucción if
mas cercana que esté dentro del mismo bloque y que no tenga asociación con
otro else. El siguiente segmento de programa ilustra esta situación:
1.int i, j, k, c, d, b;
2.if(i == 20){
3. if(j<i)
4. a=34;
5. if(k>200)
6. c=40;
7. else
8. d= 90;
9. }
10.else
11. b=c;
Programación Java básica: Instrucciones de control de flujo: selección 7 -
44
if(expresión booleana1)instrucción1;
else if(expresión booleana2) instrucción2;
else if(expresión booleana3) instrucción3;
else instrucción4;
En esta forma las instrucciones if se ejecutan de arriba hacia abajo, hasta que
alguna de las expresiones booleanas sea verdadera, en cuyo caso se ejecuta la
instrucción asociada y no se ejecuta ninguna de las siguientes. Ahora, si
ninguna de las expresiones booleanas es verdadera, se ejecutará la instrucción
asociada con el ultimo else. Recuerdese que, cada una de las instrucciones
puede ser formada a su vez por bloques encerrados entre corchetes, y estos a su
vez pueden contener otras instrucciones if como en la forma siguiente:
if(expresión booleana1){
instrucción1;
....
}
else if(expresión booleana2){
instrucción2;
....
}
else if(expresión booleana3){
Programación Java básica: Instrucciones de control de flujo: selección 7 -
45
instrucción3;
....
}
else {
instrucción4;
....
}
Ejemplo 11: Desarrollar un programa que permita leer dos valores enteros y
determinar sus relaciones entre ellos:
import javax.swing.JOptionPane;
public class ComparaEnteros{
public static void main( String args[] ) {
String primerValor, segundoValor,resultado;
int valor1, valor2;
primerValor =
JOptionPane.showInputDialog( "Digite el primer valor
entero:" );
segundoValor =
JOptionPane.showInputDialog( "Digite el segundo
valor entero:" );
valor1 = Integer.parseInt( primerValor );
valor2 = Integer.parseInt( segundoValor );
resultado = "";
if ( valor1 == valor2 )
resultado = valor1 + " == " + valor2;
if ( valor1 != valor2 )
resultado = valor1 + " != " + valor2;
if ( valor1 < valor2 )
Programación Java básica: Instrucciones de control de flujo: selección 7 -
48
switch(expresion) {
case valor1:
instruccion1;
break;
case valor2:
instruccion2;
break;
.
.
.
case valorN:
instruccionN;
break;
default:
instruccionM;
}
switch(expresion) {
case valor1:{
instruccion1;
....
}
break;
case valor2:{
instruccion2;
....
}
break;
.
.
.
case valorN:{
instruccionN;
....
}
break;
default:{
instruccionM;
....
}
}
Nótese que la instrucción break se utiliza aquí para “saltar fuera” del switch,
a la primera línea de código o instrucción que sigue después de la instrucción
Programación Java básica: Instrucciones de control de flujo: selección 7 -
51
switch.
Ejemplo 12: El siguiente ejemplo para el calculo del valor a pagar por una
camisa dependiendo de su talla, ustra la utilización de la instrucción switch :
import javax.swing.JOptionPane;
class ValorAPagar{
public static void main(String args[]) {
int talla;
float precio=0;
String entrada;
do{
entrada=JOptionPane.showInputDialog("Digite una talla
de camisa \n34 a 40:");
talla = Integer.parseInt(entrada);}
while(!(talla>= 34 && talla <=40));
switch(talla)
{
case 34:
precio=(float)30000.00;
break;
case 36:
precio=(float)32000.00;
break;
case 38:
precio=(float)33000.00;
break;
case 40:
precio=(float)34000.00;
break;
}
JOptionPane.showMessageDialog(null,"El precio de la
talla "+talla+" es $"+precio);
}
}
precio=(float)34000.00;
break;
}
JOptionPane.showMessageDialog(null,"El precio de la
talla "+talla+" es $"+precio);
}
}
Ejemplo 14: En el siguiente caso se utiliza la cláusula default para indicar que
una calificación no es aprobatoria:
import javax.swing.*;
class ApruebaNoAprueba{
public static void main(String args[]) {
String entrada,resultado;
Programación Java básica: Instrucciones de control de flujo: selección 7 -
54
int nota;
do{
entrada=JOptionPane.showInputDialog("Digite una
calificacion de 1 a 10:");
nota = Integer.parseInt(entrada);}
while(!(nota>= 1 && nota <=10));
switch(nota)
{
case 10:
case 9:
case 8:
case 7:
case 6:
resultado = "Aprobado";
break;
default:
resultado = "Reprobado";
break;
}
JOptionPane.showMessageDialog(null,"Su calificación es
"+resultado);
System.exit(0);
}
}
resultados:
asociadas con estructuras de datos del tipo arreglos, para realizar operaciones
sobre cada elemento de la estructura, por ejemplo en un problema de
multiplicación de matrices.
Instrucción while
Es la instrucción básica para el manejo de los ciclos o iteraciones, ya que
permite ejecutar repetidamente una o mas instrucciones, mientras una condición
o predicado lógico de terminación sea verdadera. Lo cual significa que, evalúa
la condición antes de iniciar un ciclo, el cual puede no realizarse si la condición
no es verdadera. Su forma general es la siguiente:
[inicialización;]
while (condición de terminación) {
cuerpo;
Programación Java básica: Instrucciones control de flujo: ciclos 7 - 58
[iteración;]
}
15. dx = Double.parseDouble(input);
16. outputTextArea.append( " valor x\tvalor f(x)
\n" );
17. x=a;
18. while(x<=b){
19. fx = x*x - 2*x;
20. outputTextArea.append(" "+precision.format(fx)
+ "\t"+ precision.format(x)+ "\n");
21. x = x+dx;
22. }
23. JOptionPane.showMessageDialog( null, scroller,
"Evalua Funcion f(x) = x*x
-2*x",JOptionPane.INFORMATION_MESSAGE );
24. System.exit( 0 );
25. }
26.}
Linea 11: se convierte la cadena leida input, la cual puede contener cifras
decimales en un valor real de tipo Double, elc ual se almacena en a, mediante el
método parseDouble(input), de la clase Double.
Linea 18: inicio del ciclo, el cual es controlado por el predicado o condición
(a<=b), es decir que, mientras esa condición sea verdadera, se ejecutarán las
instrucciones del cuerpo del ciclo while denotadas por el par de llaves {}.
Linea 23: se escriben los resultados del objeto scroller. Se coloca un título
“Evalua Funcion f(x) = x*x – 2*x” en la parte superior de la ventana del
componente JOptionPane y se utiliza la constante
INFORMATION_MESSAGE, para que aparezca un ícono alusivo a
información.
promedioEnteros;
String entrada;
while ( contador < 5 ) {
entrada = JOptionPane.showInputDialog(
"Digite un valor entero > 0: " );
valorEntero = Integer.parseInt( entrada );
total = total + valorEntero;
contador = contador + 1;
}
promedioEnteros = total / 5;
JOptionPane.showMessageDialog(
null, "El promedio de los valores leidos es: " +
promedioEnteros, "Calculo Promedios",
JOptionPane.INFORMATION_MESSAGE );
System.exit( 0 );
}
}
Los resultados obtenidos al digitar los valores enteros 10, 11, 12, 13, 14 enteros
son los siguientes:
Ejemplo 19: Desarrollar el problema anterior pero esta vez el ciclo se hace
con un registro centinela. Se debe escribir también el numero de valores leídos.
import javax.swing.JOptionPane;
public class PromedioEnteros1 {
public static void main( String args[] ) {
int total= 0, contador= 0, valorEntero,
promedioEnteros;
String entrada;
entrada = JOptionPane.showInputDialog(
"Digite un valor entero.\nSi digita -9
termina el programa" );
valorEntero =Integer.parseInt( entrada );
while ( valorEntero != -9 ) {
total = total + valorEntero;
Programación Java básica: Instrucciones control de flujo: ciclos 7 - 64
contador = contador + 1;
entrada = JOptionPane.showInputDialog(
"Digite un valor entero > 0: " );
valorEntero = Integer.parseInt( entrada );
}
promedioEnteros = total / contador;
JOptionPane.showMessageDialog(
null, "El promedio de los "+contador+" valores
leidos es: " + promedioEnteros, "Calculo Promedios",
JOptionPane.INFORMATION_MESSAGE );
System.exit( 0 );
}
}
Los resultados obtenidos al ejecutar el programa anterior con los datos, 10, 20,
30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, -9, es el siguiente:
Ejemplo 20: Desarrollar un programa Java tipo Applet que permita dibujar 15
rectángulos.
import java.awt.Graphics;
import javax.swing.JApplet;
public class ContadorWhile1 extends JApplet {
public void paint( Graphics g ){
int contador = 1;
while ( contador <= 15 ) {
g.drawRect(contador*20, contador*5, 15, 15 );
++contador;
}
}
}
<html>
<applet code="ContadorWhile1.class" width=350 height=105>
</applet>
</html>
Instrucción do-while
En esta instrucción de ciclo, la evaluación de la condición de terminación se
hace al final del ciclo y no antes del ciclo como en la instrucción while vista
antes. Esto significa que, aunque la condición de terminación sea falsa, se
realiza al menos una sola vez el ciclo. La forma general de esta instrucción es:
[inicializacion;]
do {
cuerpo;
[iteración;]
}
while(condición de terminación);
Ejemplo 21:
1.class CicloDoWhile{
Programación Java básica: Instrucciones control de flujo: ciclos 7 - 66
Como se puede observar, el control de terminación del ciclo se realiza una vez
ha hecho la iteración, con lo cual, aunque el valor de la variable en su
inicialización fuera 15 por ejemplo, se realizará el primer ciclo, en cuyo caso se
dará el siguiente resultado:
Numero = 15
Ciclo terminado, valor de entero= 16
String input;
DecimalFormat precision = new DecimalFormat
( "0.00" );
JTextArea areaDeSalida = new JTextArea(10,20);
JScrollPane scroller = new JScrollPane(areaDeSalida);
input= JOptionPane.showInputDialog("Digite el valor
para a ");
a = Double.parseDouble(input);
input = JOptionPane.showInputDialog("Digite el valor
para b ");
b = Double.parseDouble(input);
input = JOptionPane.showInputDialog("Digite el valor
para dx ");
dx = Double.parseDouble(input);
areaDeSalida.append( " valor x\tvalor f(x)\n" );
x=a;
do {
fx = x*x - 2*x;
areaDeSalida.append(" "+precision.format(fx) +
"\t"+ precision.format(x)+ "\n");
x = x+dx;
}while(x<=b);
JOptionPane.showMessageDialog(null, scroller,
"Evalua Funcion f(x) = x*x -2*x",
JOptionPane.INFORMATION_MESSAGE );
System.exit( 0 );
}
}
Los resultados obtenidos por el anterior programa para los mismos valores de a,
b, y dx son los siguientes:
Programación Java básica: Instrucciones control de flujo: ciclos 7 - 68
Instrucción for
Esta instrucción presenta una forma compacta para realizar los ciclos, su
utilización radica en que se conoce de antemano el número de veces que se debe
realizar el ciclo, su forma general es la siguiente:
Ejemplo 24:
1.class CicloFor{
2. public static void main(String args[]){
3. int entero;
4. for(entero=1; entero <= 10; entero++;)
5. System.out.println(“Numero = “+entero);
6. System.out.println(“Ciclo terminado, valor de
entero= “+entero);
7. }
8.}
Los resultados obtenidos una vez se ejecute el programa son los siguientes:
Numero = 1
Numero = 2
Numero = 3
Numero = 4
Numero = 5
Numero = 6
Numero = 7
Numero = 8
Numero = 9
Numero = 10
Ciclo terminado, valor de entero= 11
<html>
<applet code="ContadorFor1.class" width=350 height=105>
</applet>
</html>
En este caso se utilizará el ciclo while para la repetición del ciclo de lectura de
valores para cada vehículo y una instrucción switch anidada para llevar los
acumulados según el color y la marca del vehículo leido. A continuación el
programa en Java:
1.import javax.swing.*;
2.import java.text.*;
3.public class CuentaCarros1{
4.public static void main(String arg[]){
5. String entrada;
6. int codigoMarca, codigoColor, n, contVehiculos=0;
7. int contRenault=0, contFord=0, contMazda=0,
renaultRojo=0, renaultBlanco=0, renaultAzul=0;
8. int fordRojo=0, fordBlanco=0, fordAzul=0, mazdaRojo=0,
mazdaBlanco = 0, mazdaAzul =0;
9. int contRojo=0, contBlanco = 0, contAzul=0;
10. JTextArea areaDeSalida = new JTextArea(10,37);
11. JScrollPane scroller = new JScrollPane(areaDeSalida);
12. entrada=JOptionPane.showInputDialog("Digite el número
de vehiculos a leer:");
13. n = Integer.parseInt(entrada);
14. for(contVehiculos = 1; contVehiculos <=n;contVehiculos
++){
15. do{
16. entrada=JOptionPane.showInputDialog("Digite una
marca de vehiculo:\n1 Renault\n2 Ford\n3 Mazda");
17. codigoMarca = Integer.parseInt(entrada);}
18. while(!(codigoMarca>= 1 && codigoMarca <=3));
19. do{
20. entrada=JOptionPane.showInputDialog("Digite un
color de vehiculo:\n1 Rojo\n2 Blanco\n3 Azul");
21. codigoColor = Integer.parseInt(entrada);}
22. while(!(codigoColor>= 1 && codigoColor <=3));
23. switch(codigoMarca) {
Programación Java básica: Instrucciones control de flujo: ciclos 7 - 73
24. case 1:
25. contRenault=contRenault+1;
26. switch(codigoColor) {
27. case 1:
28. contRojo=contRojo+1;
29. renaultRojo=renaultRojo+1;
30. break;
31. case 2:
32. contBlanco=contBlanco+1;
33. renaultBlanco=renaultBlanco+1;
34. break;
35. case 3:
36. contAzul=contAzul+1;
37. renaultAzul=renaultAzul+1;
38. break;
39. }
40. break;
41. case 2:
42. contFord=contFord+1;
43. switch(codigoColor) {
44. case 1:
45. contRojo=contRojo+1;
46. fordRojo=fordRojo+1;
47. break;
48. case 2:
49. contBlanco=contBlanco+1;
50. fordBlanco=fordBlanco+1;
51. break;
52. case 3:
53. contAzul=contAzul+1;
54. fordAzul=fordAzul+1;
55. break;
56. }
57. break;
58. case 3:
59. contMazda=contMazda+1;
60. switch(codigoColor) {
61. case 1:
62. contRojo=contRojo+1;
63. mazdaRojo=mazdaRojo+1;
64. break;
65. case 2:
66. contBlanco=contBlanco+1;
67. mazdaBlanco=mazdaBlanco+1;
68. break;
69. case 3:
70. contAzul=contAzul+1;
71. mazdaAzul=mazdaAzul+1;
72. break;
Programación Java básica: Instrucciones control de flujo: ciclos 7 - 74
73. }
74. break;
75. }
76. }
77. areaDeSalida.append(" \tDistribucion de vehiculos
segun marca y color\n\n"+
78. "\tBlanco \tRojo \tAzul \t Total \n"+"Renault\t"+
79.
renaultRojo+"\t"+renaultBlanco+"\t"+renaultAzul+"\t"+con
tRenault+"\n"+
80. "Ford\t"+fordRojo+"\t"+fordBlanco+"\t"+fordAzul+"\t
"+contFord+"\n"+
81. "Mazda\t"+mazdaRojo+"\t"+mazdaBlanco+"\t"+mazdaAzul
+"\t"+contMazda+"\n"+
82. "Total\t"+contRojo+"\t"+contBlanco+"\t"+contAzul+"\
t"+n+"\n");
83. JOptionPane.showMessageDialog(null,scroller,
"Encuesta",JOptionPane.INFORMATION_MESSAGE);
84. System.exit(0);}
85.}
Ejemplo 28:
import javax.swing.*;
class MasDeUno{
public static void main(String args[]){
JTextArea areaDeSalida = new JTextArea(10,10);
int val1, val2;
for(val1=1, val2=15; val1<=val2; val1++, val2--)
areaDeSalida.append(" val1= "+val1+ "\tval2=
"+val2+"\n");
JOptionPane.showMessageDialog(null,areaDeSalida);
System.exit(0);
}
}
break
Ya se ha visto la utilización de break en la instrucción switch para interrumpir
la acción del case y darle control a la siguiente instrucción después de switch.
También se la puede utilizar para interrumpir el bloque de código de un ciclo y
salir de este, dándole control a la siguiente instrucción. La interrupción del ciclo
o bloque que se esté desarrollando puede hacerse mediante la instrucción break
con etiqueta, a fin de darle el control a otra parte del programa denominado con
es etiqueta. De esta manera la instrucción break tiene tres usos:
• Para salir desde el interior de un ciclo for, do-while o while, sin pasar por la
condición de terminación, y sin ejecutar el resto de instrucciones dentro del
cuerpo del ciclo, continuando con la siguiente instrucción despues del ciclo
donde se encuentre.
Ejemplo 29:
import javax.swing.JOptionPane;
public class ChequeoBreak {
public static void main( String args[] ) {
String salida = "Valores generados en el ciclo";
int contador;
for ( contador = 1; contador <= 10; contador++ ) {
if ( contador == 5 )
break;
salida += contador + " ";
}
salida += "\nInterrumpe el ciclo con contador = " +
contador;
JOptionPane.showMessageDialog( null, salida );
System.exit( 0 );
}
}
Da el siguiente resultado:
Programación Java básica: Instrucciones para salto 7 - 77
Ejemplo 30:
1.class RompeFor{
2. public static void main(String args[]){
3. for(int i=0; i<100;i++){
4. if(i==5) break;
5. System.out.println(“Valor de i= “+i);
6. }
7. System.out.println(“Instruccion despues del
ciclo”);
8. }
9.}
Valor de i= 0
Valor de i= 1
Valor de i= 2
Valor de i= 3
Valor de i= 4
Instrucción despues del ciclo
Ejemplo 31:
1.class RompeDoWhile{
2. public static void main(String args[]){
3. int i = 1;
4. do{
5. if(i==5) break;
6. System.out.println(“Valor de i= “+i);
Programación Java básica: Instrucciones para salto 7 - 78
7. i++;
8. }while(i <100);
9. System.out.println(“Instruccion despues del
ciclo”);
10. }
11.}
12.
Ejemplo 32:
1.class RompeCicloInterno{
2. public static void main(String args[]){
3. for(int i=1; i<=5; i++){
4. System.out.println(“valor de i= ”+i+” valor de
j= “);
5. for(int j=0;j<=10; j++){
6. if(i==j)break;
7. System.out.print(j+” “);
8. }
9. System.out.println();
10. }
11. System.out.println(“Ciclos terminados”);
12. }
13.}
La ultima forma de la instrucción break tiene que ver con su utilización como
equivalencia de un goto. Esta forma no es la mas aconsejable puesto que daría
lugar a los denominados programas “espagettis”, dificultando su entendimiento
y mantenimiento. Por ejemplo, para salir desde el ciclo mas interno de un
conjunto de ciclos anidados, la forma del break con etiqueta es una alternativa,
puesto que salta directamente al lugar del programa que se desea continuar su
ejecución. Obviamente esta práctica no es la mas aconsejable y debe restringirse
al máximo. La forma general de la instrucción break con etiqueta es:
break etiqueta;
Ejemplo 33:
1.class BreakConEtiqueta{
2. public static void main(String args[]){
3. aquí: for(int i=1; i<=10; i++){
4. System.out.print(“valor de i= ”+i+” valor de j=
“);
5. for(int j=0;j<=10; j++){
6. if(i==j)break;
7. if(i==5)break aqui;
8. System.out.print(j+” “);
9. }
10. System.out.println();
11. }
12. System.out.println(“Ciclos terminados con break
aqui:”);
13. }
14.}
Ejemplo 34:
import javax.swing.JOptionPane;
public class ChequeoBreakLabel{
public static void main( String args[] ) {
String salida = "";
int numero=10;
pare: {
for ( int fila = 1; fila <= 10; fila++ ) {
for ( int columna = 1; columna <= 5 ;
columna++ ) {
if ( fila == 5 )
break pare;
numero++;
salida += " "+numero;
}
salida += "\n";
}
salida += "\nPor aqui nunca pasa";
}
JOptionPane.showMessageDialog(
null, salida,"Chequeo del break con etiqueta",
JOptionPane.INFORMATION_MESSAGE );
System.exit( 0 );
}
}
Instrucción continue
A diferencia de la instrucción break que interrumpe la ejecución de un ciclo, la
instrucción continue permite interrumpir la iteración actual, no continuando
con el resto del código del ciclo, pero continuando con la siguiente iteración del
mismo ciclo. En los ciclos while y do-while, el control se transfiere desde la
instrucción continue hasta despues del cuerpo del ciclo, para verificar la
condición de terminación. Para el caso del ciclo for, el control se
transfiere primero a la parte de iteración y luego a la condición de
terminación. En los tres casos, el código después de la instrucción
continue no se ejecuta. El siguiente ejemplo ilustra la utilización de esta
instrucción:
Ejemplo 35:
1.class UsoContinue{
2. public static void main(String args[]){
3. for(int i=1; i<=4; i++){
4. for(int j=1;j<=4; j++){
5. if(!(j<=i))continue;
6. System.out.print("("+i+" , "+j+") ");
7. }System.out.println();
8. }
9. System.out.println("Ciclos terminados ");
10. }
11.}
continue etiqueta;
Ejemplo 37:
import javax.swing.JOptionPane;
class ChequeoContinueEtiqueta{
public static void main(String args[]){
String salida="Uso del CONTINUE con etiqueta:\n";
aqui: for(int i=1; i<=7; i++){
for(int j=1;j<=7; j++){
if(!(j<=i)){
salida+="\n";
continue aqui;}
salida+="("+i+" , "+j+") ";
}
salida+= "\nEsto lo agrega al final";
}
JOptionPane.showMessageDialog(null,salida );
System.exit(0);
}
}
Programación Java básica: Instrucciones para salto 7 - 83
El resultado es el siguiente:
Arreglos
En Java como en los demás lenguajes de programación, se permite el manejo de
conjuntos de datos del mismo tipo, a los cuales se hace referencia mediante un
mismo nombre o identificador. Es el caso de los denominados vectores o
arreglos de una dimensión, matrices o arreglos de dos dimensiones y los de
múltiples dimensiones. Los arreglos son entonces agrupamientos de valores del
mismo tipo de dato.
El nombre o identificador de los arreglos sigue las mismas reglas que para las
variables sencillas, solo que se agrega un par de paréntesis [] para indicar que
es un arreglo en su declaración de tipo.
Arreglos uni-dimensionales
Sea el caso de un arreglo unidimensional para representar el siguiente vector:
A = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
que representa los días de cada uno de los meses del año (para un año no
bisiesto). Su definición en Java como arreglo se dará con la siguiente forma:
int diasDeMeses[];
Programación Java básica: Arreglos 7 - 84
Ejemplo 38:
import javax.swing.*;
public class DiasMeses{
public static void main(String args[]){
int DiasDeMeses[];
String salida="";
DiasDeMeses = new int[13];
DiasDeMeses[1]=31;
DiasDeMeses[2]=28;
DiasDeMeses[3]=31;
DiasDeMeses[4]=30;
DiasDeMeses[5]=31;
DiasDeMeses[6]=30;
DiasDeMeses[7]=31;
DiasDeMeses[8]=31;
DiasDeMeses[9]=30;
DiasDeMeses[10]=31;
DiasDeMeses[11]=30;
DiasDeMeses[12]=31;
salida+="Enero tiene "+DiasDeMeses[1]+" dias\n";
salida+="Julio tiene "+DiasDeMeses[7]+" dias";
JOptionPane.showMessageDialog(null,salida);
}
}
Programación Java básica: Arreglos 7 - 85
Ejemplo 39:
import javax.swing.*;
class DiasMeses2{
public static void main(String args[]){
String salida="";
int DiasDeMeses[]={31, 28, 31, 30, 31, 30, 31, 31, 30,
31, 30, 31};
salida+="Enero tiene "+DiasDeMeses[1]+" dias\n";
salida+="Julio tiene "+DiasDeMeses[7]+" dias";
JOptionPane.showMessageDialog(null,salida);
}
}
Los resultados son los siguientes para la lectura de un arreglo con los siguientes
valores: 12, 13, 14, 15, 29, 21, 45, 34, 32, 61, 26:
frecuencia\nvalor \tfrecuencia\n\n";
for ( int indice2 = 1;indice2 < frecuencia.length;
indice2++ )
salida += indice2 + "\t" + frecuencia[ indice2 ]
+ "\n";
JTextArea areaSalida = new JTextArea( 11, 10 );
areaSalida.setText( salida );
JOptionPane.showMessageDialog( null, areaSalida,
"Calculo de frecuencias",
JOptionPane.INFORMATION_MESSAGE );
System.exit( 0 );
}
}
Programación Java básica: Arreglos 7 - 90
El resultado es el siguiente:
Arreglos bi-dimensionales
En Java los arreglos de más de una dimensión, o multidimensionales, son en
realidad matrices de matrices. Para declarar una variable del tipo arreglo
multidimensional, se requiere especificar cada índice adicional utilizando una
pareja de corchetes [ ]. Por ejemplo, para definir un arreglo o matriz de dos
dimensiones de tamaño 5x4, es decir de 5 filas por cuatro columnas, tendremos
la siguiente codificación:
int MatBidi[][]= new int[3][4];
Programación Java básica: Arreglos 7 - 92
Los índices del lado izquierdo representan las filas y los índices del lado
derecho representan las columnas del arreglo MatBidi[][] declarado en la
instrucción anterior. Obsérvese que los subindices empiezan desde [0][0], con
lo cual debe tenerse cuidado al manejar los arreglos.
Ejemplo 44:
import javax.swing.*;
class SumaArregloBi{
public static void main(String args[]){
int matriz[][] = new int[3][3];
int i, j, suma = 0;
matriz[0][0]= 1;
matriz[0][1]= 2;
matriz[0][2]= 3;
matriz[1][0]= 4;
matriz[1][1]= 5;
matriz[1][2]= 6;
matriz[2][0]= 7;
matriz[2][1]= 8;
matriz[2][2]= 9;
for (i=0; i<=2; i++)
for (j=0;j<=2;j++)
suma = suma + matriz[i][j];
JOptionPane.showMessageDialog(null,"La suma de
los elementos es "+suma);
System.exit(0); }
}
Ahora el mismo programa anterior pero esta vez leyendo los valores para el
arreglo.
Ejemplo 45:
import javax.swing.*;
class SumaArregloBi1{
public static void main(String args[]){
int matriz[][] = new int[3][3];
int i, j, suma = 0;
String entrada;
for (i=0; i<=2; i++)
for (j=0;j<=2;j++){
entrada= JOptionPane.showInputDialog("Digite el
término [ "+i+" ][ "+j+" ]");
matriz[i][j]=Integer.parseInt(entrada);
suma = suma + matriz[i][j];}
JOptionPane.showMessageDialog(null,"La suma de
los elementos es "+suma);
System.exit(0); }
}
Las marcas y los colores a tener en cuenta con sus respectivos códigos son:
[3]+"\t"+tabla[3][4]+"\n"+
"Total\t"+tabla[4][1]+"\t"+tabla[4][2]+"\t"+tabla[4]
[3]+"\t"+tabla[4][4]+"\n");
JOptionPane.showMessageDialog(null,areaDeSalida,
"Encuesta",JOptionPane.INFORMATION_MESSAGE);
System.exit(0);}
}
String entrada;
int i, j ,k, filasA, columnasA, filasB, columnasB;
JTextArea areaSalida = new JTextArea(20,30);
do{
entrada= JOptionPane.showInputDialog("Digite el numero
de filas de la matriz A ");
filasA = Integer.parseInt(entrada);
entrada= JOptionPane.showInputDialog("Digite el numero
de columnas de la matriz A ");
columnasA = Integer.parseInt(entrada);
entrada= JOptionPane.showInputDialog("Digite el numero
de filas de la matriz B ");
filasB = Integer.parseInt(entrada);
entrada= JOptionPane.showInputDialog("Digite el numero
de columnas de la matriz B ");
columnasB = Integer.parseInt(entrada);}
while(columnasA != filasB);
areaSalida.append("\n Datos matriz a \n");
for(i=1; i<=filasA; i++){
for(j=1; j<=columnasA; j++){
entrada= JOptionPane.showInputDialog("Digite el
termino a["+i+"]["+j+"]= ");
a[i][j]= Integer.parseInt(entrada);
areaSalida.append(" " +a[i][j]+"\t");
}areaSalida.append("\n");
}
areaSalida.append("\n Datos matriz b \n");
for(i=1; i<=filasB; i++){
for(j=1; j<=columnasB; j++){
entrada= JOptionPane.showInputDialog("Digite el
termino b["+i+"]["+j+"]= ");
b[i][j]= Integer.parseInt(entrada);
areaSalida.append(" "+b[i][j]+"\t");
}
areaSalida.append("\n");}
areaSalida.append("\nResultado del producto \n");
for(i = 1; i<=filasA;i++){
for(j =1; j<=columnasB; j++){
c[i][j]=0;
for (k=1; k<=columnasA; k++)
c[i][j]=c[i][j]+ a[i][k]*b[k][j];
areaSalida.append(" "+c[i][j]+"\t");
}areaSalida.append("\n");
}
JOptionPane.showMessageDialog(null,areaSalida,
"Producto Matrices",JOptionPane.INFORMATION_MESSAGE);
System.exit(0);
}
}
Programación Java básica: Arreglos 7 - 99
Recapitulación
Se ha presentado el paso del modelo de objetos a la programación en Java,
indicando cómo el programa al ser un objeto, se forma en su estructura de las
mismas partes de una clase. Se vio a través de ejemplos cómo las relaciones de
es-un, tiene-un y utiliza-un entre clases, se pueden convertir a códigos en Java.