Estructuras de Control en Java y C#
Breve introduccion
Antes de escribir un programa que de solucion a un problema, es necesario tener una idea detallada del problema, asi como la comprensión de los bloques para la construcción de diagramas de flujo.
Cualquier problema de computación puede resolverse ejecutando una serie de acciones en un orden especifico, a esto se le conoce con el nombre de algoritmo y depende de dos cosas principales:
1.- Las acciones a ejecutar
2.- El orden en el que se ejecutan las acciones.
Definicion de Pseudocodigo: Es un lenguaje informal que ayuda a los programadores a desarrollar algoritmos sin tener que preocuparse por los estrictos detalles de la sintaxis de un lenguaje de programación. El pseudocódigo es semejante al lenguaje cotidiano, es amigable con el usuario y ayuda a organizar un programa.
Estructuras de Control
Por lo general, en un programa las instrucciones se ejecutan una después de otra en el orden en que están escritas, este proceso se conoce como ejecución secuencial. Varias instrucciones en Java y C# permiten al programador especificar que la siguiente instrucción a ejecutarse tal vez no sea la siguiente secuencia. Esto se conoce como transferencia de control.
Java tiene solo tres estructuras de control: la secuencia de estructura, la estructura de selección (tres tipos) y la estructura de repetición (tres tipos), en C# tenemos la estructura de selección (tres tipos) y la estructura de repetición (cuatro tipos). Cada programa se forma combinando tantas estructuras de secuencia, selección y repetición como sea apropiado para el algoritmo que implemente el programa.
Estructura de Selección if Simple
Esta intruccion sirve para elegir entre entre los cursos alternativos de acción, por ejemplo:
Supongamos el siguiente pseudocódigo:
Si la edad de un individuo es mayor a 18
Imprimir “Mayor de edad”
Codigo en Java
if (edad > 18 )
System.out.println(“Mayor de edad”);
Codigo en C#
if (edad > 18)
Console.WriteLine(“Mayor de edad”);
Estructura de Selección if… else…
La estructura de selección if… else permite al programador especificar una acción cuando la condición es verdadera y otra cuando la condición es falsa, como en el siguiente pseudocodigo:
Si edad de una persona es mayor a 18
Imprimir “Mayor de Edad”
De lo contrario
Imprimir “Menor de Edad”
Codigo en Java
if (edad > 18)
System.out.println(“Mayor de Edad”);
else
System.out.println(“Menor de Edad”);
Codigo C#
if (edad > 18)
Console.WriteLine (“Mayor de Edad”);
else
Console.WriteLine (“Menor de Edad”);
Instrucciones if… else Anidadas
Un programa puede evaluar varios caso colocando if… else… anidados, por ejemplo el siguiente pseudocódigo:
Si la calificación del estudiante es mayor o igual a 90
Imprimir “Excelente”
De lo contrario
Si la calificación es mayor o igual a 70
Imprimir “Aceptable”
De lo contrario
Imprimir “Reprobado”
Codigo Java
if ( calificación >= 90 )
System.out.println(“Excelente”);
else
if (calificación >= 70 )
System.out.println(“Aceptable”);
else
System.out.println(“Reprobado”);
Codigo C#
if ( calificación >= 90 )
Console.WriteLine(“Excelente”);
else
if (calificación >= 70 )
Console.WriteLine (“Aceptable”);
else
Console.WriteLine (“Reprobado”);
Hay que tener cuidado de no caer en el error de no adidar correctamente el else, en Java y C# el ultimo else es asociado con el if que precede inmediatamente. Por ejemplo el siguiente código en Java.
if ( x > 5 )
if( y > 5 )
System.out.println(“x e y son > 5”);
else
System.out.println(“x es >= 5”);
En realidad el compilador lo interpreta de la siguiente manera:
if ( x > 5 )
if( y > 5 )
System.out.println(“x e y son > 5”);
else
System.out.println(“x es >= 5”);
Para lograr que la instruccion se ejecute como se pensaba en un principio se utiliza las {} para indicar que la intruccion else se ejecuta con la primer sentencia if.
if ( x > 5 ){
if( y > 5 )
System.out.println(“x e y son > 5”);
}
else
System.out.println(“x es >= 5”);
Tambien es forzoso usar las {} cuando se ejecutan mas de una instruccion dentro de cada if… else
Por ejemplo:
if (edad > 18){
Console.WriteLine(“Ya eres mayor de edad”);
Console.WriteLine(“Y puedes sacar tu licencia de manejo”);
}
else{
Console.WriteLine(“Aun eres menor de edad”);
Console.WriteLine(“No puedes sacar tu licencia de manejo hasta después de los 18 anios”);
}
NOTA: Cuando no ponga los dos ejemplos para Java y C# quiere decir que la sintaxis es parecida en este caso lo único que diferencia es System.out.println y Console.WriteLine, ya que tienen el mismo fin.
Instrucción de Selección Multiple switch
La instrucción switch permite tomar una decisión en base a los posibles valores de una variable o expresión, cada acción se asocia con un valor integral constante (es decir un valor de tipo byte, short, int o char pero no long) que la variable o expresión pueda asumir.
Por ejemplo pedir la orden de un menú en base a lista formada por los menus 1, 2, 3
Codigo Java
switch (myOpcion) { //inicio de switch
case 1:
System.out.println(“-Sopa de letras \n –Pechuga empanizada\n –Gelatina \n -Agua de fruta”);
break;
case 2:
System.out.println(“-Crema de zanahoria \n –Costillas en salsa roja\n –Helado \n -Agua de fruta”);
break;
case 3:
System.out.println(“-Torta de Milaneza \n –Papas a la francesa\n –Refresco de cola”);
break;
default:
System.out.println(“Debe de elegir un menú de la lista”);
} //fin de switch
Codigo C#
switch opcion (myOpcion) { //inicio de switch
case 1:
Console.WriteLine(“-Sopa de letras \n –Pechuga empanizada\n –Gelatina \n -Agua de fruta”);
break;
case 2:
Console.WriteLine (“-Crema de zanahoria \n –Costillas en salsa roja\n –Helado \n -Agua de fruta”);
break;
case 3:
Console.WriteLine (“-Torta de Milaneza \n –Papas a la francesa\n –Refresco de cola”);
break;
default:
Console.WriteLine (“Debe de elegir un menú de la lista”);
} //fin de switch
Nota: Para Java no se pone la instruccion break despues de default, en C# si.
Estructura de Repeticion while
Una estructura de repetición (también llamada estructura ciclo) permite al programador especificar que un programa debe repetir una acción mientras cierta condición sea verdadera. Por ejemplo el siguiente pseudocódigo para una persona que sale de compras:
Mientras existan mas artículos en mi lista de compras
Comprar el siguiente articulo y quitarlo de mi lista
Ahora veamos un ejemplo:
Encontrar la primera potencia que sea mayor a 1000, suponiendo que la variable la inicializamos en 2.
int producto = 2;
while( producto <= 1000 )
producto = 2 * producto;
//Java
System.out.println(producto);
//C#
Console.WriteLine(producto);
Instrucción de Repeticion do… while
Es similar a la instrucción while, y la única diferencia es que en la istruccion while la condición se evalua al principio, por lo que si la condición es falsa el ciclo no se ejecuta y en la condición do…while por lo menos se ejecuta una vez el ciclo ya que la condición se evalua al final. Cuando termina una estructura do… while el programa continua inmediatamente después de la instrucción while.
El siguiente ejemplo imprime de el numero 0 al 9, notemos como si inicializamos la variable en 10 el ciclo se ejecuta por lo menos una vez.
int myVariable = 0;
do {
System.out.println(myVariable);
//C#
//Console.WriteLine(myVariable);
myVariable++;
} (while myVariable < 10);
Notemos que debemos de terminar con punto y coma (;) al finalizar la condición del while.
Instrucción for
La instrucción for es la instrucción de iteración mas potente. El código de control de la instrucción for se divide en tres partes:
- Un indicador. Que fija las condiciones iniciales de la instrucción de bucle for.
- Una condición que especifica la expresión booleana que mantiene ejecutándose la instrucción for.
- Un iterador que especifica las instrucciones que se ejecutan al final de cada paso por las instrucciones incrustadas
A continuación vemos un ejemplo que imprime también los números del 0 al 9:
int myVariable;
For(myVariable = 0; myVariable < 10; myVariable++)
{
System.out.println(myVariable);
//C#
//Console.WriteLine(myVariable);
}
El iniciador, la condicion y el iterador de un bucle for son opcionales. Si prefiere no usar alguna de estas partes, simplemente escriba un punto y coma sin especificar la instrucción. Por ejemplo:
int myVariable = 0;
For(; myVariable < 10; myVariable++)
{
Console.WriteLine(myVariable);
//Java
//System.out.println(myVariable);
}
//------------------------
//O también
int intVaribale;
For (myVariable = 0; ; myVariable++ )
{
Console.WriteLine(myVariable);
//Java
//System.out.println(myVariable);
myVariable++;
}
Hay que tener cuidado cuando se omita la parte de la condición en un bucle for. El siguiente código es un ejemplo de los problemas que pueden surgir.
for(int myVariable = 0; ; myVariable++)
{
Console.WriteLine(myVariable);
}
Este código se ejecuta hasta que myVariable provoca un error porque contiene un numero demasiado largo para ser almacenado.
Instrucción foreach (Solo C#)
Se puede usar la instrucción foreach para repetir varias veces los elementos de una colección. Las matrices de C# admiten la instrucción for each y pueden usarse para trabajar fácilmente con cada elemento de la matriz.
La sintaxis es la siguiente:
Foreach (tipoDato nombreVariable in Colleccion)
{
}
Por ejemplo:
int[] myArray;
myArray[0] = 0;
myArray[1] = 1;
myArray[2] = 2;
myArray[3] = 3;
myArray[4] = 4;
foreach( int ArrayElement in myArray)
{
Console.WriteLine(ArrayElement);
}
Instrucciones de salto para moverse por el código
Hago mención de estas instrucciones ya que por lo regular se utilizan en estructuras de ciclos o repetición.
La instrucción break
Como ya vimos en la estructura switch la instrucción break sirve para salir de un bloque de instrucciones en el que se encuentre.
int myVariable = 0;
while(myVariable < 10)
{
Console.WriteLine(myVariable);
//Java
//System.out.println(myVariable);
if( myVariable == 5 )
break;
myVariable++;
}
El código anterior se sale cuando myVariable = 5, Imprime en pantalla del 0 al 4
La instrucción break suele usarse con bloques de instrucciones switch, while, do… while, for y foreach(solo C#).
La Instrucción continue
La instrucción continue devuelve el control a la expresión booleana que controla una instrucción de iteración, por ejemplo:
int myVariable;
For (myVariable = 0; myVariable < 10; myVariable++ )
{
if (myVariable == 5)
continue;
Console.WriteLine(myVariable);
//Java
//System.out.println(myVariable);
}
El codigo anterior imprime del 0 al 9, excepto el 5, es decir “Si el valor de myVariable es 5”, continua con la siguiente iteración sin ejecutar ninguna instrucción después del continue”. Al igual que break, continue se usa en instrucciones switch, while, do… while, for y foreach(solo C#).
Instrucción goto (C#)
La instrucción goto transfiere sin condiciones el control a una instrucción etiquetada. Puede etiquetarse cualquier instrucción de C#. Las etiquetas de instrucción son identificadores que preceden a una instrucción. Despues de una etiqueta se colocan dos puntos(:). Un identificador de etiqueta sigue a la palabra clave goto y la instrucción goto transfiere el control a la instrucción designada por el identificador de etiqueta. Por ejemplo:
int myVariable = 0;
while(myVariable < 10 )
{
Console.WriteLine(myVariable);
if ( myVariable == 5 )
goto done;
myVariable++;
}
done: Console.WriteLine(“Fuera del ciclo”);
El código anterior escribe del 0 al 4 y a continuación la leyenda “Fuera del ciclo”
break etiquetado(Java)
En Java tambien tenemos una opcion para poder hacer lo que se hace con goto de C#. A continuacion muestro un ejemplo:
String salida = "";
alto: { //bloque etiquetado
// contar 10 filas
for ( int fila = 1; fila <=10; fila++){
for ( int columna = 1; columna <= 5; columna++) {
if ( fila == 5 ) // si la fila es 5.
break alto; //saltar al final del bloque alto
salida += "* ";
} // fin de for interno
salida += "\n";
} // fin de for externo
// la siguiente linea se evita
salida += "\nLos ciclos terminaron normalmente";
} // fin del bloque etiquetado
// en el codigo anterior cuando fila es 5 se ejecuta break de la etiqueta y termina tanto el bloque interno del for como el externo, el for externo nunca se completa
Instruccion foreach (Java)
Hago una correccion a peticion de un amigo
Tonat , que como bien es cierto desde la version 1.5 del jdk incorporo una estructura de control en Java que tiene la misma funcion que el ciclo foreach de C#, y a continuacion muestro un ejemplo sencillo y la sintaxis que maneja.
Sintaxis:
for (TipoBase variable: ArrayDeTiposBase)
{..}
Ejemplo:
List
list = new ArrayList();
// Añadimos elementos
list.add("Primitivo");
list.add("Roman");
list.add("Montero");
for (String nombre: list)
System.out.println(nombre);
Pues como podemos ver la sintaxis de Java y C# para estructuras de control es muy parecida, a excepcion del ciclo foreach. Y de antemano agradezco sus comentarios y tambien si alguien quisiera que publicara algo en especifico me haga sus comentarios de lo que les parece este blog, Y el motivo de no incluirlo es debido a que actualmente desarrollo en C# y VB 2005, y como comentaba en la introduccion de esta serie de blogs dedicados a Java y C#. Que es solo una guia para no olvidarnos de la sitaxis de cada lenguaje ya que la vida nos lleva por rumbos distintos, pero tambien no hay que olvidarnos de lo que sabemos...
