Capitulo 2
CONTROL DE EJECUCIÓN
Objetivos:
|
Java utiliza todas las instrucciones de control de ejecución de C, así es que se verá familiar si se ha programado con C o C++. Muchos lenguajes de programación procesales tienen algún tipo de instrucciones de control, y a menudo de pasan entre lenguajes. En Java, las palabras clave incluyen ifelse, while, do-while, for, y una instrucción de control llamada switch. Java no soporta goto (que todavía puede ser la forma mas conveniente forma de solucionar cierto tipo de problemas).
true y false
todas las instrucciones condicionales usan la verdad o falsedad de una expresión condicional para determinar el camino de ejecución. Un ejemplo de expresión condicional es A == B. Estas utilizan el operador condicional == para ver si el valor de A es equivalente a el valor de B. La expresión retorna true o false, Cualquiera de los operadores relacionales que se han visto antes en este capítulo pueden ser utilizados para producir expresiones condicionales. Debe notarse que Java no permite el uso de un número como tipo boolean, aun cuando esto esta permitido en C y en C++ (donde verdadero en un valor distinto de cero y falso es cero). Si se quiere utilizar un tipo que no sea boolean en una prueba del tipo boolean, como if(a), debemos convertirlo a el valor boolean utilizando una expresión condicional, como es if(a ¡= 0) .
if-else
La instrucción if-else es probablemente la forma mas básica de controlar el flujo de un programa. El else es opcional, así es que se puede utilizar if de dos formas:
Sintaxis :
- Primera Forma
if(exprecondición)
instrucciones1
- Segunda Forma
if(condición)
instrucciones1
else
instrucciones2
La sentencia if permite a un programa tomar una decisión para ejecutar una acción u otra, basándose en el resultado verdadero o falso de una expresión. La sintaxis para utilizar esta sentencia es la siguiente:
Una sentencia if se ejecuta de la forma siguiente:
- Se evalúa la condición.
- Si el resultado de la evaluación de la condición es verdadero (true) se ejecutara lo indicado por las instrucciones1.
- Si el resultado de la evaluación de la condición es falso (fase), se ejecutara lo indicado por la instrucciones2, si la cláusula else se ha especificado.
- Si el resultado de la evaluación de la condición es falso, y la cláusula else se ha omitido, la instrucciones1 se ignora.
- En cualquier caso, la ejecución continua en la siguiente sentencia ejecutable que haya continuación de la sentencia if..
La condición debe producir un resultado del tipo boolean. Las instrucciones terminan con un punto y coma o una instrucción compuesta, que es un grupo de instrucciones encerrado entre llaves. En cualquier momento que la palabra “instrucción” sea utilizada, siempre implica que la instrucción pueda ser simple o compuesta.
A continuación se exponen algunos ejemplos para que vea de una forma sencilla como se utiliza la sentencia if
if(x!= 0)
b= a/x;
b= b+1;
- En este ejemplo, la condición viene impuesta por la expresión x!=0. Entonces b= a/x, que sustituye a la sentencia 1 del formato general, se ejecuta si la expresión es verdadera ( x distinta de 0) y no se ejecutara si la expresión es falsa (x igual a 0). En cualquier caso, se continua la ejecución en la línea siguiente, b=b+1. Veamos otro ejemplo:
- En este otro ejemplo, la condición viene impuesta por una expresión a<b. Si al evaluar la condición se cumple que a es menor que b, entonces se ejecuta la sentencia c=c+1. En otro caso, esto es, si a es mayor o igual que b, se continua en la línea siguiente, ignorándose la sentencia c=c+1.
if( a < b )c = c+1;
// Siguiente línea del programa
- En el ejemplo siguiente, la condición viene impuesta por la expresión a! = 0 && b!= 0.
Si al evaluar la condición se cumple que a y b son distintas de cero, entonces se ejecuta la sentencia x=i. En otro caso, la sentencia x=i se ignora, continuando la ejecución en la línea siguiente.
if( a != 0 && b !=0)
x = i;
//siguiente línea del programa
- En el ejemplo siguiente, si se cumple que a es igual a b*5 , se ejecutan las sentencias x=4 y a=a+x. en otro caso, se ejecuta la sentencia b= 0 . en ambos casos, la ejecución continúa en la siguiente línea de programa.
if(a== b*5)
{
x=4;
a= a+x;
}
else
b=0;
// Siguiente línea del programa
- Un error típico es escribir. En lugar de la condición del ejemplo anterior, la siguiente:
if(a = b*5)
//…
- En este caso, suponiendo por ejemplo que a es de tipo int, el compilador mostrara un mensaje de error indicado que no puede convertir un int a boolean, porque la sentencia anterior es equivalente a escribir:
a = b*5;
if(a)
//…
Donde se observa que a no puede dar un resultado boolean. Si seria correcto lo siguiente:
a = b*5;
if (a != 0 )
//…
Que equivale a:
if (( a = b*5) != 0 )
//…
- En este otro ejemplo que se muestra a continuación, la sentencia return se ejecutara solamente cuando car sea igual al carácter ’s’.
If( car = = ‘s’)
return;
ANIDAMIENTO DE SENTENCIAS if
Como ejemplo se puede observar el siguiente segmento de programa que escribe un mensaje indicando como es un número a con respecto a otro b (mayor, menor o igual):
if(a > b)
flujoS.println(a+ “ves mayor que”+ b);
else if (a < b)
flujoS.println(a+ “es menor que”+b);
else
flujoS.println(a+ “es iguala”+b);
// siguiente línea del programa
Es importante observar que una vez que se ejecuta una acción como resultado de haber evaluado las condiciones impuestas, la ejecución del programa continua en la siguiente linea a la estructura a que dan lugar las sentencias if…else anidadas. En el ejemplo anterior si se cumple que a es mayor que b, se escribe el mensaje correspondiente y se continua en la siguiente línea de programa.
Así mismo, si en el ejemplo siguiente ocurre que a no es igual a 0, la ejecución continua en la siguiente línea del programa.
if( a = = 0)
if (b ¡= 0)
s = s + b;
else
s = s + a;
// siguiente línea del programa
Si en lugar de la solución anterior, lo que deseamos es que se ejecute s = s + a cuando a no es igual a 0, entonces tendremos que incluir entre llaves el segundo if sin la cláusula else; esto es:
if(a = = 0)
{
If(b ¡= 0)
s = s + b;
}
else
s = s + a;
// siguiente línea del programa
Como ejercicio sobre la teoría expuesta, vamos a realizar una aplicación que de como resultado el menor de tres números a, b y c. La forma de proceder es comparar cada número con los otros dos una sola vez. La simple lectura del código que se muestra a continuación es suficiente para entender el proceso seguido.
// La clase Leer debe estar en alguna carpeta de las especificadas
// Por la variable de entorno CLASSPATH.
//
public class CMENOR
{
// Menor de tres números a, b y c
public static void main(String[] args)
{
float a, b, c, menor;
//Leer los valoresde a, b y c
System.out.print (“a : “); a = Leer.datofloat( );
System.out.print (“b : “); b = Leer.datofloat( );
System.out.print (“c : “); c = Leer.datofloat( );
// Obtener el menor
if ( a < b)
if(a < c)
menor = a ;
else
menor = c ;
else
if(b < c)
menor = b ;
else
menor = c ;
System.out.println(“menor = “+ menor) ;
}
}
ESTRUCTURA else if
La estructura presentada a continuación, aparece con bastante frecuencia y es por lo que se le da un tratamiento por separado. Esta estructura es consecuencia de las sentencias if anidadas. Su formato general es:
if (condición 1)
Sentencia 1;
else if (condición 2)
Sentencia 2;
else if (condición 3)
Sentencia 3;
.
.
.
else
Sentencia n;
La evaluación de esta estructura sucede así: si se cumple la condición 1, se ejecuta la sentencia 1 y si no se cumple se examinan secuencialmente las condiciones siguientes hasta el último else, ejecutándose la sentencia correspondiente al primer else if, cuya condición sea cierta. Si todas las condiciones son falsas, se ejecutan la sentencia n correspondiente al último else. En cualquier caso, se continúa en la primera sentencia ejecutable que haya a continuación de la estructura.
Las sentencias 1, 2, …, n pueden ser sentencias simples o compuestas.
Por ejemplo al efectuar una compra en un cierto almacén, si adquirimos mas de 100 unidades de un mismo articulo, nos hacen un descuento de un 40 %; entre 25 y 100 un 20%; entre 10 y 24 un 10%; y no hay descuento para una adquisición de menos de 10 unidades. Se pide calcular el importe a pagar. La solución se presentara de la siguiente forma:
Código articulo……. 111
Cantidad comprada... 100
Precio unitario……... 100
Descuento………….. 20.0%
Total………………... 8000.0
En la solucion presentada como ejemplo, se puede observar que como la cantidad comprada esta entre 25 y 100, el descuento aplicado es de un 20%.
La solución de este problema puede ser de la forma siguiente:
- Primero definimos las variables que vamos a utilizar en los cálculos.
int ar, cc;
float pu, Desc;
- A continuación leemos los datos ar, cc y pu.
System.out.print(“código articulo……”) ;
ar = Leer.datoint() ;
System.out.print(“cantidad comprada...”) ;
cc = Leer.datoint() ;
System.out.print(“precio unitaria...”) ;
pu = Leer.datofloat() ;
- Como los datos, realizados los calculos y escribimos el resultado.
if ( cc > 100)
Desc = 40F ; // descuento 40%
else if ( cc >= 25)
Desc = 20F ; // descuento 20%
else if (cc >= 10)
Desc = 10F ; // descuento 10%
else
desc = 0.0F; // descuento 0%
system.out.println(“descuento.........”+Desc+”%”) ;
system.out.println(“total.............”+cc * pu * (1 – desc / 100));
se puede observar que las condiciones se han establecido según los descuentos de mayor a menor. Como ejercicio, piense p pruebe que ocurriría si establece las condiciones según los descuentos de menor a mayor. La aplicación completa se muestra a continuación.
// la clase leer debe estar en alguna carpeta de las especificadas
// por la variable de entorno CLASSPATH.
//
public class CDescuento
{
public static void main(String[] args)
{
int ar, cc;
float pu, desc;
System.out.print(“codigo articulo….. “) ;
ar = Leer.datoInt( ) ;
System.out.print(“cantidad comprada……”) ;
cc = Leer.datoInt( ) ;
System.out.print(“precio unitario…………”) ;
pu = Leer.datoFloat( ) ;
System.out.println( ) ;
if( cc > 100)
Desc = 40F; // descuento 40%
else if (cc >= 25)
Desc = 20F; // descuento 20%
else if (cc >= 10)
Desc = 10F; // descuento 10%
Else
Desc = 0.0F; // descuento 0%
System.out.println(“descuento....”+ desc + “%”);
System.out.println(“total........”+Cc * pu *(1- desc/ 100));
}
}
SENTENCIA SWITCH
La sentencia switch permite ejecutar una de varias acciones, en función del valor de una expresión. Es una sentencia especial para decisiones múltiples.
La sintaxis a utilizar esta dada en la siguiente expresión sentencia es:
switch (expresión)
{
Case expresión – constante 1:
[sentencia 1;]
[case expresión-constante 2:]
[sentencia 2;]
[case expresión- constante 3:]
[sentencia 3;]
.
.
.
[default:]
[sentencia n;]
}
donde expresión es una entera de tipo char, byte, short o int y expresión-constante es una constante también entera y de los mismos tipos. Tanto la expresión como las expresiones constantes son convertidas implícitamente a int. Por ultimo, sentencia es una sentencia simple o compuesta. En el caso de tratarse de una sentencia compuesta, no hace falta incluir las sentencias simples entre {}.
La sentencia switch evalúa la expresión entre paréntesis y compara su valor con las constantes de cada case. La ejecución de las sentencias del bloque de la sentencia switch, comienza en el case cuya constante coincida con el valor de la expresión y continua hasta el final del bloque o hasta una sentencia que transfiera el control fuera del bloque de switch; por ejemplo, break. La sentencia switch puede incluir cualquier numero de cláusulas case.
Si no existe una constante igual al valor de la expresión, entonces se ejecutan las sentencias que están a continuación de default, si esta cláusula ha sido especificada. La cláusula default puede colocarse en cualquier parte del bloque y no necesariamente al final.
En una sentencia switch es posible hacer declaraciones en el bloque de cada case, igual que en cualquier otro bloque, pero no al principio del bloque switch, antes del primer case. Por ejemplo:
switch (m)
{
int n = 0, k = 2 // declaración no permitida
case 7 :
Int i = 0 ; // declaración permitida
while (i < m)
{
n += (k + i)*3;
i++;
}
break;
case 13:
//…
break;
//…
}
El error se ha presentado en el ejemplo anterior puede solucionarse así:
int n= 0, k=2;
switch (m)
{
//…
}
Para ilustrar la sentencia switch, vamos a realizar un programa que lea una fecha representada por dos enteros, mes y año. Y de cómo resultado los días correspondientes al mes. Esto es:
Introducir mes (##) y año (####): 5 2002
El mes 5 del año 2002 tiene 31 días
Hay que tener en cuenta que febrero puede tener 28 días, o bien 29 si el año es bisiesto. Un año es bisiesto cuando es múltiplo de 4 y no de 100 o cuando es múltiplo de 400. por ejemplo, el año 2000 por las dos primeras condiciones no seria bisiesto, pero si lo es porque es múltiplo de 400; el año 2100 no es bisiesto porque aunque sea múltiplo de 4, también lo es de 100 y no es múltiplo de 400.
La solución de este problema puede ser de la siguiente forma:
- Primero definimos las variables que vamos a utilizar en los cálculos.
int dias = 0, mes = 0, año = 0;
- A continuación leemos los datos mes y año.
System.out.print(“mes (##) ; “) ; mes = Leer .datoInt( ) ;
System.out.print(“año (####) : “) ; año = Leer .datoInt( );
- Después comparamos al mes con las constantes 1, 2, ….., 12. Si mes es 1, 3, 5, 7, 8, 10 o 12 asignamos a días el valor 31. Si mes es 4, 6, 9, u 11 asignamos q días el valor 30. Si mes es 2, verificamos si el año es bisiesto, en cuyo caso asignamos a días el valor 29 y si no es bisiesto, asignamos a días el valor 28.
Si mes no es ningún valor de los anteriores enviaremos un mensaje al usuario indicándole que el mes no es valido. Todo este proceso lo realizaremos con una sentencia switch.
switch (mes)
{
Case 1: case 3: case 5: case 7: case 8: case 10: case12:
Dias = 31;
Break;
case 4: case6: case 9: case 11:
Días = 30;
break;
case 2
// ¿ es el año bisiesto?
if((año %4==0)&&(año%100¡= o)||(año%400== 0))
Dias = 29;
Else
Dias = 28;
break;
default:
System.out.println(“\nElmes no es valido”);
break;
}
Cuando una constante coincidan con el valor de mes, se ejecutan las sentencias especificadas a continuación de la misma, siguiendo la ejecución del programa por los bloques de las siguientes cláusulas case, a no ser que se tome una acción explicita para abandonar el bloque de la sentencia switch. Esta es precisamente la función de la sentencia break al final de cada bloque case.
- Por ultimo si el mes es valido, escribimos el resultado solicitado.
If (mes >= 1 && mes <= 12)
System.out.printhn(“\ nEl mes “+ mes + “ del año “ + año +“tiene”+ dias + “dias”);
El programa completo se muestra a continuación:
// la clase leer debe estar en alguna carpeta de las especificadas
// por la variable de entorno CLASSPATH.
//
public class CDiasMes
{
// Dias correspondientes a un mes de un ano dado
public static void main(String [] args)
{
int dias = 0, mes = 0, año = 0;
System.out.print(“mes (##); mes = leer.datoint( );
System.out.print(“año (####): “); año = leer.datoint( );
switch (mes)
{
case 1: // enero
case 3: //marzo
case 5: //mayo
case 7: //Julio
case 8: //agosto
case 10: //octubre
case 12: //diciembre
días = 31
break;
case 4: //abril
case 6: // junio
case 9: //septiembre
case11: //noviembre
días = 30;
break;
case 2: //febrero
// ¿ es el año bisiesto?
if((año%4==0)&&(año%100¡=0)||(año%400== 0))
dias = 29;
Else
dias = 28;
break;
default:
System.out.println(“\nElmesnoes valido”);
break;
}
If (mes >= 1 && mes <=12)
System.out.println(“\nEl mes +”+ mes “del año” + año + “tiene “+ días + “días”);
}
}
El que las cláusulas case estén una a continuación de otra o una debajo de otra no es mas que una cuestión de estilo, ya que java interpreta cada carácter nueva línea como un espacio en blanco; esto es, el código al que llega el compilador es el mismo en cualquier caso.
La sentencia break que se ha puesto a continuación de la cláusula default no es necesaria; simplemente obedece a un buen estilo de programación. Así, cuando tengamos que añadir otro caso ya tenemos puesto break, con lo que hemos eliminado una posible fuente de errores.
return
La palabra clave return tiene dos propósitos: especifica que valor de retorno tendrá un método (si no tiene un tipo void como retorno) y produce un retorno inmediato de ese valor. El método test() anterior puede ser reescrito para tomar ventaja de esto.
public class IfElse {
static int test(int testval, int t) {
int result = 0;
if(testval > t)
return +1;
else if(testval < t)
return -1;
else
return 0; // Match
}
public static void main(String[] args) {
System.out.println(test(10, 5));
System.out.println(test(5, 10));
System.out.println(test(5, 5));
}
} ///:~
Aquí no hay necesidad de la palabra else ya que el método no continúa luego de ejecutar un return.
Estructuras de Iteración.
Los bucles de control while, do-while y for son clasificados como instrucciones de interacción. Una instrucción se repite hasta que la expresión de control booleana evaluada es falsa. La forma del bucle while es
while(expresión booleana){
instrucción1.
Instrucción2.
Instrucción3.
.
.
.
Instrucción n
}
La expresión booleana es evaluada una vez al inicio del bucle y nuevamente cada nueva iteración de la instrucción. He aquí un simple programa ejemplo que genera números al azar hasta que una condición particular es encontrada:
public class WhileTest {
public static void main(String[] args) {
double r = 0;
while(r < 0.99d) {
r = (Math.random());
System.out.println(r);
}
}
} ///:~
Utiliza un método estático llamado random() en la librería Math, que genera un valor double entre 0 y 1 (Esto incluye 0 pero no 1). La expresión condicional para el while dice “manténgase haciendo este bucle hasta que el numero sea mayor a 0.99 o mayor”. Cada vez que se ejecute este programa obtendremos una lista de números de diferente tamaño dado que se generan números de manera aleatoria.
El siguiente ejemplo, que visualiza el codigo ASCII de cada uno de los caracteres de una cadena de texto introducida por el teclado, da ligar a un bucle infinito, porque la condicion es siempre cierta(valor trae). Para salir del bucle infinito tiene que pulsar las teclas ctrl. + C.
import java.io.*;
public class CAscii
{
// codigo ASII de cada uno de los caracteres de un texto
public static void main(String[] args )
{
char car = 0; //car = character nulo (\0)
try
{
System.out.print(“Ingrese una cadena de texto: “) ;
while (true)// condicion siempre cierta
{
car = (char)System.in.read( ); // leer el siguiente carácter
if ( car ¡= ‘ \r’ && car ¡= ‘\n’)
System.out.println(“el codigo ASCII de “+ car + “ es “ + (int)car);
// si no hay datos disponibles, solicitarlos
if (System.in.available( ) = = 0 )
System.out.print(“Introduzca una cadena de texto: “);
}
}
catch(I0Exception ignorada) { }
}
}
A continuación ejecutamos la aplicación. Introducimos, por ejemplo, el carácter ‘a’ y observamos los siguientes resultados:
Introduzca una cadena de texto: a [entrar]
El código ASCII de a es 97
Introduzca una cadena de texto:
Este resultado demuestra que cuando escribimos ‘a’ y pulsamos la tecla entrar para validar la entrada, solo se visualiza el código ASCII de ese carácter; los caracteres \r y \n introducidos al pulsar Entrar son ignorados porque así se ha programado. Cuando se han leído todos los caracteres del flujo de entrada, se solicitan nuevos datos. Lógicamente, habrá comprendido que aunque se lea carácter a carácter se pueda escribir, hasta pulsar Entrar, un texto cualquiera. Por ejemplo:
Introduzca una cadena de texto: hola[entrar]
El código ASCII de h es 104
El código ASCII de o es 111
El código ASCII de l es 108
El código ASCII de a es 97
Introduzca una cadena de texto:
El resultado obtenido permite observar que el bucle while se esta ejecutando sin pausa mientras hay caracteres en el flujo de entrada. Cuando dicho flujo queda vacío y se ejecuta el método read de nuevo, la ejecución se detiene a la espera de nuevos datos.
Modifiquemos ahora el ejemplo anterior con el objetivo de eliminar el bucle infinito. Esto se puede hacer incluyendo en el while una condición de terminación; por ejemplo, leer datos hasta alcanzar la marca de fin de fichero. Recuerde que para el flujo estándar de entrada, esta marca se produce cuando se pulsan las teclas ctrl.+D en UNIX, o bien ctrl.+Z en aplicaciones Windows de consola, y que cuando read lee una marca de fin de fichero, devuelve el valor -1.
import java.io.*
public class CAscii
{
// Codigo ASCII de cada uno de los caracteres de un texto
public static void main (String[] args)
{
final char eof = (char) -1;
char car = 0; // car character nulo (\0)
try
{
System.out.println(“introduzca una cadena de texto.”);
System.out.println(“para terminar pulse ctrl.+z\n”);
while (( car = (char)System.in.read()) != eof)
{
If (car != ‘\r’ && car != ‘\n’)
System.out.println(“el código ASCII de “+ car + “es” + (int) car);}
}
}
}
Una solución posible de esta aplicación es la siguiente:
Introduzca una cadena de texto.
Para terminar pulse ctrl. + z
Hola [entrar]
El código ASCII de h es 104
El código ASCII de o es 111
El código ASCII de l es 108
El código ASCII de a es 97
Adiós [entrar]
El codigo ASCII de a es 97
El codigo ASCII de d es 100
El codigo ASCII de i es 105
El codigo ASCII de o es 162
El codigo ASCII de s es 115
[Ctrl.] [z]
do-while
la forma del do-while es:
do {
instrucción1.
Instrucción2.
Instrucción3.
.
.
.
Instrucción n
}
while(expresion booleana)
la única diferencia entre while y do-while es que la instrucción en do-while se ejecuta siempre por lo menos una vez, aún si la expresión se evalúa como falsa la primera vez. En un while, si la condición es falsa la primera vez la instrucción nunca se ejecuta. En la práctica, do-while es menos común que while.
for
Un bucle for realiza un inicialización antes de la primera iteración. Luego realiza pruebas condicionales y, al final de cada iteración, alguna forma de “adelantamiento de a pasos”. La forma del bucle for es:
for (inicialización; expresión booleana; paso)
instrucción
Cualquiera de las expresiones inicialización, expresión booleana o n pueden ser vacías. La expresión es probada luego de cara iteración, y tan pronto como se evalúa en false la ejecución continúa en la línea seguida por la instrucción for. En el final de cada bucle, paso se ejecuta. Los bucles for usualmente son utilizados para tareas de “cuenta”.
// Demuestra los bucles "for" listando
// todos los caracteres ASCII.
public class ListCharacters {
public static void main(String[] args) {
for( char c = 0; c < 128; c++)
if (c != 26 ) // Borrado de pantalla ANSI
System.out.println("value: " + (int)c +" character: " + c);
}
}
Se puede ver que la variable c esta definida en el punto donde va a ser utilizada, dentro de la expresión de control del bucle for, antes que al comienzo de el bloque indicado por la llave de apertura. El alcance de c es la expresión controlada por el for.
Los lenguajes tradicionales como C requiere que todas las variables sean definidas en el comienzo del bloque así es que cuando el compilador crea un bloque puede asignar el espacio para esas variables. En Java y en C++ se pueden declarar las variables por todo el bloque, de código definiéndolas en el punto en que se necesiten. Esto permite un estilo de código mas natural y hace el código mas fácil de entender.
Se pueden definir múltiples variables con la instrucción for, pero estas deben ser del mismo tipo:
for(int i = 0, j = 1;i < 10 && j != 11;i++, j++)
/* cuerpo del bucle */;
la definición del tipo int en la instrucción for cubre i y j. La habilidad para definir variables en la expresión de control está limitada por el bucle for. No se puede utilizar este método con ninguna otra instrucción de selección o iteración.
Otros casos del operador for:
En el siguiente ejemplo se puede observar la utilización de la coma como separador de las variables de control y de las expresiones que hacen evolucionan los valores que intervienen en la condición de finalización.
int f, c;
for (f=3,c=6;f+c<40; f++, c += 2)
System.out.println(“f=“+f+“\tc = “ + c);
Este otro ejemplo que va continuación, imprime los valores desde 1 hasta 10 con incrementos de 0.5.
for (float i = 1; i <= 10; i += 0.5)
System.out.print(i + “”);
El siguiente ejemplo imprime las letras del abecedario en orden inverso.
char car;
for ( car = ‘z’; car >= ‘a’; car - - )
System.out.print(car + “”);
El ejemplo siguiente indica como realizar un bucle infinito. Para salir de un bucle infinito tiene que pulsar las teclas ctrl.+ c.
El operador coma
Hasta hora el operador coma (no el separador coma, que es utilizado para separar definiciones y argumentos de funciones) le hemos dado un solo un uso en Java:
En la expresión de control de un bucle for. En la inicialización y en la parte de pasos de la expresión de control se pueden tener varias instrucciones separadas por comas, y aquellas instrucciones serán evaluadas de forma secuencial. El trozo de código anterior utiliza esta definición.
public class CommaOperator {
public static void main(String[] args) {
for(int i = 1, j = i + 10; i < 5;i++, j = i * 2) {
System.out.println("i= " + i + " j= " + j);
}
}
}
Y su salida:
i= 1 j= 11
i= 2 j= 4
i= 3 j= 6
i= 4 j= 8
Como se puede ver en ambos en la inicialización y en las parte de pasos las instrucciones son evaluadas en orden secuencial. Además, la parte de la inicialización puede tener cualquier número de definiciones de un tipo.
break y continue
Dentro del cuerpo de cualquiera de las instrucciones de la iteración se puede tener control del flujo del bucle utilizando break y continue. break se sale del bucle sin ejecutar el resto de las instrucciones en el bucle. continue detiene la ejecución de la actual iteración y regresa al comienzo del bucle para comenzar en la siguiente iteración. Este programa muestra ejemplos de break y continue con bucles for y while:
// Demonstrates break and continue keywords.
public class BreakAndContinue {
public static void main(String[] args) {
for(int i = 0; i < 100; i++) {
if(i == 74) break; // Fuera del bucle
if(i % 9 != 0) continue; // Siguiente iteración
System.out.println(i);
}
int i = 0;
// Un “bucle infinito":
while(true) {
i++;
int j = i * 27;
if(j == 1269) break; // fuera del bucle
if(i % 10 != 0) continue; // Arriba en el bucle
System.out.println(i);
}
}
} ///:~
Explicación .-
En el bucle for el valor de i nunca llega a 100 porque la instrucción break sale del bucle cuando i es 74. Normalmente, se usará una línea break como esta solo si no se conoces cuando va a suceder la condición de terminación. La instrucción continue produce que la ejecución regrese a el comienzo de la iteración del bucle (de esta manera se incrementa i) cuando quiera que i no sea divisible entre 9. Cuando esto se sucede el valor es impreso.
La segunda parte muestra un “bucle infinito” que puede, en teoría, continuar para siempre. Sin embargo, dentro del bucle hay una instrucción break que saldrá del bucle. Además, se puede ver que continue regresa a el inicio del bucle sin completar el resto (Estas impresión se sucede en el segundo bucle solo cuando el valor de i es divisible entre 10).
La salida es:
0
9
18
27
36
45
54
63
72
10
20
30
40
El valor de 0 es impreso porque 0 % 9 produce 0.
Una segunda forma de bucle infinito es for(;;). El compilador trata while(true) y for(;;) de la misma forma así es que cualquiera que se use es por preferencias de programación.
| En eumed.net: |
 1647 - Investigaciones socioambientales, educativas y humanísticas para el medio rural Por: Miguel Ángel Sámano Rentería y Ramón Rivera Espinosa. (Coordinadores) Este libro es producto del trabajo desarrollado por un grupo interdisciplinario de investigadores integrantes del Instituto de Investigaciones Socioambientales, Educativas y Humanísticas para el Medio Rural (IISEHMER). Libro gratis |
15 al 28 de febrero |
|
| Desafíos de las empresas del siglo XXI | |
15 al 29 de marzo |
|
| La Educación en el siglo XXI | |
Enlaces Rápidos
