Operadores y Estructuras de Control

Operadores:

• Suma: (+)
• Resta: (-)
• Multiplicación: (*)
• División: (/)
• Módulo: (%)
• Incremento: (++)
• Decremento: (--)
• Otras operaciones: +=,-=,*=,/=;%=

Operadores Lógicos

·     
And ó “y lógico” (&&)
Or u “o lógico” (||)
Not o negado (!)

Relacionales

Cualquier tipo de dato: Igual a (==), distinto de (!=)

      Tipos Numéricos: Mayor que (>), mayor o igual a (>=),menor que (<),menor o igual que (<=)

Estructuras de control

       Las estructuras de control determinan el comportamiento de un programa; permiten combinar instrucciones o sentencias individuales en una simple unidad lógica con un punto de entrada y otro de salida, se organizan en tres tipos que sirven para controlar el flujo de la ejecución: secuencia, selección o decisión y repetición.

Sentencia if

       En Java, la estructura de control de selección principal es una sentencia if; la cual, tiene dos alternativas o formatos posibles, el más sencillo tiene la sintaxis siguiente:

                                                  if (expresión) Acción

      La sentencia if funciona de la siguiente manera: cuando se alcanza, se evalúa la siguiente expresión entre paréntesis; si expresión es verdadera se ejecuta Acción, en caso contrario no se efectúa y sigue la ejecución en la siguiente sentencia.
*
Prueba de divisibilidad. Éste es un programa en el que se introducen dos números enteros y mediante una sentencia de selección se determina si son divisibles.

import java.util.Scanner; class Divisible { public static void main(String[] a) { int n, d; Scanner entrada = new Scanner(System.in); System.out.println("Introduzca dos enteros:"); n = entrada.nextInt(); d = entrada.nextInt(); if (n%d == 0) System.out.println(n +" es divisible por "+d); } }

      Este programa lee dos números enteros y comprueba cuál es el valor del resto de la división n entre d (n%d)

   Sentencia if de dos alternativas: if-else

  Un segundo formato de if es if-else, cuyo formato tiene la siguiente sintaxis:

if (expresión)

acción 1

else

acción 2

        En este formato acción 1 y acción 2 son, de forma individual, una única sentencia que termina en un punto y coma, o un grupo de sentencias entre llaves; expresión se evalúa cuando se ejecuta la sentencia: si es verdadera, se efectúa acción 1; en caso contrario se ejecuta acción 2, la figura 5.2 muestra su semántica.

Por ejemplo:

if (salario > 100000) salario_neto = salario - impuestos; else salario_neto = salario;

     Si salario es mayor que 100 000, se calcula el salario neto restándole los impuestos; en caso contrario (else), el salario neto es igual al salario bruto.

Sentencias if-else anidadas

      Hasta este momento, las sentencias if implementan decisiones que implican una o dos opciones; pero en esta sección, se mostrará que una sentencia if es anidada cuando alguna de las ramas, sin importar si es verdadera o falsa, también es if; entonces se puede utilizar para tomar decisiones con varias opciones o multiopciones.

Sintaxis:

if (condición 1) sentencia 1 else if (condición 2) sentencia 2 ... else if (condición n) sentencia n else sentencia e

Ejemplo:

Se incrementan contadores de números positivos, números negativos o ceros.

if (x > 0) num_pos = num_pos + 1; else if (x < 0) num_neg = num_neg + 1; else num_ceros = num_ceros + 1;

      La sentencia if que está anidada tiene tres variables (num_pos, num_neg y num_ceros), incrementa una de ellas en 1, dependiendo de si x es mayor que cero, menor que cero o igual a cero, respectivamente; su ejecución se realiza de la siguiente forma: se comprueba la primera condición (x > 0) y, si es verdadera, num_pos se incrementa en 1 y se omite el resto de la sentencia; si es falsa, se comprueba la segunda condición (x < 0) y, si ésta es verdadera, num_neg se incrementa en uno; en caso contrario num_ceros se aumenta en uno. Observe que la segunda condición sólo se comprueba si la primera condición es falsa.

Sentencia de control switch

       En Java, switch es una sentencia que se utiliza para elegir una de entre múltiples opciones; es especialmente útil cuando la selección se basa en el valor de una variable simple o de una expresión simple denominada expresión de control o selector; el valor de dicha expresión puede ser de tipo int o char pero no de tipo doublé.

Sintaxis:

switch (selector) { case etiqueta1 : sentencias1 ; break; case etiqueta2 : sentencias2 ; break; . . . case etiquetan : sentenciasn ; break; default: sentenciasd ; // opcional }

         Sentencia break

Para alterar el flujo de control de una sentencia de selección múltiple o de los bucles, existe la sentencia break la cual termina el bucle.

Sintaxis:

break; break etiqueta;

Una sentencia break consta de la misma palabra reservada seguida por un punto y coma; cuando la computadora ejecuta las sentencias siguientes a una etiqueta case, continúa hasta que se alcanza una sentencia break; al hacerlo, la computadora termina la sentencia switch. Si se omiten las sentencias break después de ejecutar el código case, la computadora ejecutará el código siguiente hasta el próximo case.

Ejemplo:

switch (opcion) { case 0: System.out.println("Cero!"); break; case 1: System.out.println("Uno!"); break; case 2: System.out.println("Dos!"); break; default: System.out.println("Fuera de rango!"); }

Caso particular de case 

Está permitido tener varias expresiones case en una alternativa dada en switch; por ejemplo, se puede escribir:

switch(c) { case '0':case '1': case '2': case '3': case '4': case '5':case '6': case '7': case '8': case '9': num_digitos++; // se incrementa en 1 el valor de num_digitos break; case '': case '\t': case '\n': num_blancos++; // se incrementa en 1 el valor de num_blancos break; default: num_distintos++; }

Uso de switch en menús

if-else es más versátil que switch y se pueden utilizar if-else anidadas en cualquier parte de una sentencia case; sin embargo, normalmente switch es más clara; por ejemplo, es idónea para implementar menús como el de un restaurante, el cual presenta una lista para que el cliente elija entre diferentes opciones. Un menú en un programa de computadora hace lo mismo: presenta una lista de alternativas en pantalla para que el usuario elija.

 Expresiones condicionales, operador?:

Java mantiene, a semejanza de C, un tercer mecanismo de selección, una expresión que produce uno de dos valores como resultado de una expresión lógica o booleana, también llamada condición; este mecanismo es realmente una operación ternaria denominada expresión condicional y tiene el formato C ? A : B, en el que C, A y B son tres operandos y ? es el operador.

Este ejemplo determina y escribe el mayor y el menor de dos números reales; se realiza de dos formas, con la sentencia if-else, y con el operador?:.

import java.util.Scanner; class MayorMenor { public static void main(String[] a) { float n1,n2; Scanner entrada = new Scanner(System.in); System.out.println("Introduzca dos números reales"); n1 = entrada.nextFloat(); n2 = entrada.nextFloat(); // Selección con if-else if (n1 > n2) System.out.println(n1 + " > " + n2); else System.out.println(n1 + " < " + n2); // operador condicional n1 > n2 ? System.out.println(n1 + " > " + n2); : System.out.println(n1 + " < " + n2); } }

Bucles:

Un bucle o lazo es cualquier construcción de programa que repite una sentencia o secuencia de sentencias determinado número de veces.

Sentencia while 

Un bucle while tiene una condición, una expresión lógica que controla la secuencia de repetición; su posición es delante del cuerpo del bucle y significa que while es un bucle pretest, de modo que cuando éste se ejecuta, se evalúa la condición antes de ejecutarse el cuerpo del bucle.

El comportamiento o funcionamiento de una sentencia o bucle while es:

1.      Se evalúa condición bucle.

2.      Si es verdadera:

a) La sentencia especificada, denominada cuerpo del bucle, se ejecuta.

b) El control vuelve al paso 1.

3.      En caso contrario: el control se transfiere a la sentencia posterior al bucle o sentencia while.

Por ejemplo:

// cuenta hasta 10 int x = 0; while (x < 10) System.out.println("X: " + x++);

Usos de bucles for

Java permite

· Que el valor de la variable de control se modifique en valores diferentes de 1.
· Utilizar más de una variable de control

Las variables de control se pueden incrementar o decrementar en valores de tipo int, pero también es posible hacerlo en valores de tipo float o double y, en consecuencia, se incrementaría o decrementaría en cantidad decimal; por ejemplo:

for (int n = 1; n <= 121; n = 2*n + 1) System.out.println("n es ahora igual a " + n); int n, v=9; for (int n = v; n >= -100; n -= 5) System.out.println("n es ahora igual a " + n); for (double p= 0.75; p<= 5; p += 0.25) System.out.println("Perímetro es ahora igual a " + p);

Repetición: bucle do...while

           La sentencia do-while se utiliza para especificar un bucle condicional que se ejecuta al menos una vez; cuando se desea realizar una acción determinada al menos una o varias veces, se recomienda este bucle.

Aplicación simple de un bucle while: seleccionar una opción de saludo al usuario dentro de un programa.

class Saludo { public static void main(String[] a) { char opcion; do { System.out.println("Hola"); System.out.println("¿Desea otro tipo de saludo?"); System.out.println("Pulse s para si y n para no,"); System.out.print("y a continuación pulse intro: "); opcion = System.in.read(); }while (opcion == 's'|| opcion == 'S'); System.out.println("Adiós"); } }

                      Salida de muestra:

Hola ¿Desea otro tipo de saludo? Pulse s para si y n para no, y a continuación pulse intro: S Hola ¿Desea otro tipo de saludo? Pulse s para si y n para no, y a continuación pulse intro: N Adiós