2.1.2.-Programación en Android - Unos Conceptos IV

2.1.2.- Programación en Android: Unos conceptos IV

Vamos a continuar en este capítulo con algunos conceptos básicos de programación, en este capítulo hablaremos sobre las expresiones en Java, así como de las sentencias para control de flujo del programa.

Las expresiones son un conjunto de variables, operadores y llamadas a métodos que son evaluadas a un valor sencillo. P. Ej: unEntero=valoruno*valordos+x;

Con las expresiones podemos calcular valores, asignarlos, controlar el flujo de un programa (junto con las sentencias de control), etc.

Las expresiones se pueden dividir en dos partes: Una encargada de realizar los cálculos y otra que devuelve algún valor. El tipo de dato que devuelve la expresión depende de los elementos que sean utilizados en la misma.

Las expresiones que se utilizen para llamar a los métodos devolverán el valor del método y el tipo de dato será el mismo tipo que el que está indicado como retorno de ese método.

Todas las expresiones devuelven un valor. En caso de que tengan múltiples operandos, se evalúan primero los operadores de mayor precedencia y en claso de igual precedencia se aplica la regla de la asociatividad.

Java, al igual que otros lenguajes de programación, permite la construcción de expresiones complejas a partir de varias expresiones sencillas, con la condición de que los tipos de datos sean del mismo tipo o se conviertan al mismo. En caso de que no sean compatibles, siempre se puede hacer un casting explícito para los tipos que lo permitan. El casting se utiliza para convertir valores de un tipo a otro, o incluso objetos a un tipo compatible, normalmente se utiliza porque el compilador no nos lo permitiría de otra manera.

Vamos a mostrar una tabla con la precedencia de operadores utilizados en las expresiones, recordar que en caso de querer que se evalúen otros antes y no tengan preferencia, se pueden utilizar los paréntesis. En la tabla se muestran de mayor a menor preferencia, y a igual preferencia se evalúan antes los de la izquierda que los de la derecha:

Tipo de operador	Operador
Operadores sufijo	[] . (params) expr++ expr--
Operadores unarios	++expr -–expr +expr -expr ~ !
Creación o tipo	New (type)expr
Multiplicadores	* / %
Suma y resta	+ -
Desplazamiento	<< >> >>>
Relacionales	< > <= >= instanceof
Igualdad	== !=
Operación AND a nivel de bits	&
Operación XOR a nivel de bits	^
Operación OR a nivel de bits	|
AND lógico	&&
OR lógico	||
Condicional (ternario)	?:
Asignación	= += -= *= /= %= ^= &= |= <<= >>= >>>=

Sentencias de control de flujo

Con las sentencias de control de flujo determinamos el orden en que se ejecutarán nuestras sentencias y expresiones en el programa. Modifican la ejecución de las instrucciones.

Con estas sentencias podemos hacer entre otras cosas:

Tipo de control de flujo	Sentencia
Ejecutar un grupo de sentencias según una condición.	If-else, switch case.
Ejecutar un grupo de sentencias mientras se cumpla una condición o hasta que se cumpla. (Bucles o iterativas)	For, while, do-while
Manejo de excepciones	Try-catch-finally, throw
Varias	Break, continue, label:, return
Aunque goto es una palabra reservada en Java, no se soportada esa sentencia. En su lugar se pueden utilizar las rupturas etiquetadas: break etiqueta;

Sentencia if-else

La sentencia if-else permite la ejecución selectiva del código según los criterios que se establezcan. En su forma más sencilla sólo consta de una sentencia que será ejecutada en caso de que la condición sea verdadera. Pero también podemos utilizar otra sentencia en caso de que la condición sea falsa, esta sentencia se pondría enmarcada en el else.

Y también hay otra forma de la sentencia else, que es else if, que ejecuta una sentencia basándose en otra expresión. A diferencia de la forma que sólo tiene un else, puede haber multitud de sentencias else if, en este caso cuando se cumpla una de las condiciones se sale del conjunto de sentencias sin evaluar las restantes.

// Ejemplo para las sentencias If int a = 2, b = 5, c = 10, d = 14; //Forma más simple: en caso de ser true se ejecuta la condición if (a > 1) a = d / b; //En caso de que pusieramos más condiciones dentro, irían con corchetes. if (a > 1) { a = d / b; b++; d--; System.out.println("a=d/b, b++ y d--"); } //Forma con else if (a > 1) { //Esto se ejecutaría en caso de que la expresión a>1 fuera true a = d / b; System.out.println("a=d/b"); } else { //Esto se ejecutaría en caso de que a>1 fuera false b--; System.out.println("b--"); } //Ahora el caso con else if if (a > 1) { // a>1= true a++; System.out.println("a++"); System.out.println("a:" + a + " b:" + b + " c:" + c + " d:" + d); } else if (b > a) { b--; System.out.println("b++"); } else if (c + b > d) { //Esta expresión también se cumple, pero al cumplirse primero // la expresión de a>1 entonces se sale del conjunto de sentencias y // esta no es ejecutada. b = d / a; System.out.println("b=d/a"); }

Sentencia switch

La sentencia switch se utiliza para realizar sentencias condicionales basadas en alguna expresión. Estas sentencias, enmarcadas en el case correspondiente, pueden terminar con la sentencia break que hará que se salte a la siguiente línea despues del switch, ya que de lo contrario seguiría ejecutando todas las demas sentencias case hasta terminar la sentencia switch. También se podría poner un break etiquetado, para poder ir a cualquier otro lugar.

Y por último, también podemos añadir la sentencia default al final de la sentencia switch para manejar los valores que no fueron controlados explícitamente.

int mes; mes = 2; switch (mes) { case 1: { //No son necesarios los corchetes: { } System.out.println("Enero"); break; } case 2: { System.out.println("Febrero"); } case 3: { //como no pusimos el break antes, tambien ejecuta esto. System.out.println("Marzo"); break; } case 4: System.out.println("Abril"); break; case 5: System.out.println("Mayo"); break; case 6: System.out.println("Junio"); break; default: System.out.println("Me canse de escribir ;)"); }

Bucles

Las sentencias iterativas o de bucles nos permiten hacer un conjunto de acciones repetidas veces, estas sentencias pueden ser el while, el do-while o la sentencia for.

La sentencia while realiza una acción mientras se cumpla la condición, osea mientras la evaluación de la expresión sea true. La sentencia puede ser una sóla o puede ser un conjunto de ellas enmarcadas dentro de los corchetes { }.

//Un pequeño bucle. while (a++<10) System.out.println("A="+a); //Ahora con más sentencias a=0; while (a<=10) // { System.out.println("Cinco por "+a+" = "+5*a); a++; }

Bucles con for

Estos bucles se suelen utilizar cuando se saben los criterios que limitan el mismo. Si sabes el valor de su inicialización, la condición que debe cumplirse para su finalización y las instrucciones de incremento o decremento.

El bucle for es a menudo utilizado para recorrer elementos de arrays o listas.

La forma general sería: for (inicialización; condición de terminación; incremento o decremento)

Inicialización: Se ejecuta una sóla vez al iniciar el bucle.

La condición de terminación se evalúa en cada iteración en caso de ser true se continúa en el bucle, si no se termina.

Incremento o decremento es como aumentamos la variable que utilizamos de "contador" y se ejecuta en cada iteración.

Alguno de estos parámetros o incluso todos pueden ser una sentencia vacía: for(;;) .

También es posible ejecutar la sentencia break para salir en cualquier momento del for en base a otras comprobaciones o expresiones.

//Creamos un array con 10 enteros. (De 0 a 9=10 elementos) int arrayInts[]=new int [10]; // for (inicialización; terminación; incremento/decremento) for (int i=0;i<arrayInts.length;i++) { arrayInts[i]=i; System.out.println("Valor de ArrayInts["+i+"]="+arrayInts[i]); }

Iteraciones con do-while

Esta tipo de bucle es similar al while, pero con la salvedad de que la expresión es evaluada al final del bucle. Este tipo de sentencias son poco utilizadas, y se suele limitar a casos en los que es necesario que el bucle se ejecute al menos una vez.

do{ System.out.println("Bucle do"+b); }while ((b+=10)<100);