Estructuras de Control

If

if(condicion)          if (condicion)               if(condicion)

instruccion 1;          {                                  {

instruccion 2;            instrucciones;             instruccion;

if(a>b)                      }                                  }

>=                          if (a>b)&&(a<b)             {

<=                             (a>b)||(b>c)                     else;

<                                                                       instruccion;

!=

==

La estrutura de control IF permite decidr entre dos opciones resultantes de la evaluación de una sentencia. Si la evaluación es positiva hace una cosa, también podemos especificar accioens para realizar en caso de que la evaluación sea negativa. Veamos cómo funciona en VBscript. 

IF (expresion) then       Sentencias       .... END IF

Vemos que en primer lugar tenemos la sentencia IF, luego una expresión, que puede o no ir entre paréntesis, y más tarde la parabra THEN. Vemos que luego hay un salto de línea antes de colocar las sentencias asociadas a la evaluación positiva de la sentencia. En VBScript las líneas si que importan. 
Después de poner las sentencias del asociadas a la evaluación positiva colocamos un END IF, para acabar la estructura del IF. 

If-Else

La sentencia if else
La sentencia if else nos permite ejecutar un bloque de código o no, dependiendo de una condición que se evalúa justo antes de este bloque. Esta condición se evalúa a un valor booleano, es decir, su resultado solo puede tomar dos valores, true o false. A continuación podréis verlo en un ejemplo:

int edad = 21;
if(edad >= 18) {
    System.out.println("Eres mayor de edad.");
} else {
    System.out.println("Eres menor de edad.");
}

Como podrás prever, si la condición es evaluada como true como es el caso, se ejecutará el primer println() mostrando que eres mayor de edad, si la condición fuese false, se ejecutaría el segundo println(). Siempre se ejecuta uno de los bloques si está presente el else, sino se ejecutará un bloque o ninguno.

También podemos añadir un nuevo bloque if en la sentencia else, formando los denominados if encadenados, pudiendo hacer todos los que queramos:

int edad = 50;
if(edad <= 14) {
    System.out.println("Eres un niño.");
} else if(edad > 14 && edad < 18){
    System.out.println("Eres adolescente.");
} else if(edad >= 18 && edad < 65) {
    System.out.println("Eres un adulto.");
} else {
    System.out.println("Eres anciano.");
}

En este caso la salida por pantalla será "Eres un adulto.", de esta manera podemos colocar tantos else if como queramos, además como vemos, en la última opción se puede obviar el if, y colocar solo el else, ya que no hay mas posibilidades que tener en cuenta.

También se pueden colocar bloques if else, dentro de otros bloques if else, y encadenar tantos como necesitemos, eso si, teniendo en cuenta que hacer esto muchas veces puede dificultar la lectura de nuestro código:

char sexo = 'f';
int edad = 25;
if(edad >= 18) {
    if(sexo == 'm') {
        System.out.println("Eres un hombre mayor de edad.");
    } else {
        System.out.println("Eres una mujer mayor de edad.");
    }
} else {
    if(sexo == 'm') {
        System.out.println("Eres un niño menor de edad.");
    } else {
        System.out.println("Eres una niña menor de edad.");
    }
}

For}

for (j=0;j<=10;j++)

for  (j=0;j>=10;j--) Inicio/Mientras/incremento\decremento.

cout<<"Hola";

}

La estructura de control for permite ejecutar un bloque de instrucciones un número determinado de veces mientras se cumpla una condición. Es una de las estructuras de control repetitivas más utilizadas a pesar de que cualquier bucle for puede reescribirse facilmente como un bucle while y viceversa.

La sintaxis básica de la estructura de control for es la siguiente:

for(inicialización;condicion;incremento)
{
    //instrucciones
}

La ejecución de la estructura de control for comienza con la instrucción de inicialización. Esta instrucción suele realizar la inicialización de una variable de control que suele conocerse como centinela. A continuación se comprueba la condición cuyo resultado tiene que ser un valor booleano true o false.

Si la condición se evalúa como true se ejcuta el bloque de instrucciones delimitadas por las llaves que solo son necesarias si hay más de una instrucción. Después se ejcuta la instrucción de incremento y vuelve a comprobarse la condición. Así sucesivamente hasta que la condición no se cumple.

La inicialización, la condición y el incremento son instrucciones opcionales. Aún así sino se utilizan debe de estar presente el delimitador punto y coma (;). Por ejemplo si omitimos la condición y el incremento, la estructura de control for quedaría así:

for(int i=0;;)
{
   //instrucciones
}

Además si declaramos una variable en la instrucción de inicialización como en el ejemplo anterior, ésta solo será accesible desde el interior de la estructura de control for. Remarco esto porque todavía no hemos visto el ámbito de las variables y puede llevar a confusiones, así que de momento saber que solo puede utilizarse dentro del bucle for.

Switch

switch (a) intn:                        switch (a) char:                         

{                                               {  

case 1: Instruction;                   case a: Instruction;

            Break;  }                                     Break;

case 2: Instruction;                    case b: Instruction;

             Break;                                        Break;

                                                   default: Instruction;}

 default: Instruction;

}

La estructura de control switch nos permite ejecutar diferentes bloques de instrucciones en función del resultado de una expresión.

La sintaxis básica es la siguiente:

switch(expresion)
{
    case valor1:
            instrucciones
            break;
    case valor2:
            instrucciones
            break;
    default:
            instrucciones
            break;

}

Si la expresión coincide con el valor1 se ejecutan todas las instrucciones definidas en ese bloque, sino se compara con el valor2 y así sucesivamente. Si el resultado de la expresión no coincide con ningún caso se ejecuta el bloque de instrucciones del caso default.

Cabe destacar que el único valor que puede evaluar la estructura de control switch son números enteros de tipo int y cualquier tipo que pueda convertirse implicitamente a tipo int, es decir, byte, char, short. Además a partir de la versión 5, Java permite evaluar también enumeraciones (las veremos más adelante) y las clases envolventes (wrappers) de los tipos antes mencionados, es decir, Character, Short, Int y Byte (también las veremos más adelante).

Pueden haber tantos cases como sean necesarios siempre y cuando no hayan dos con el mismo valor.

La sentencia break es opcional y se utiliza para finalizar el switch tras la ejecución de un case. Si la sentencia break no estuviera, al salir de un bloque case entraría en el siguiente aunque el valor de ese case no coincidiera con el evaluado en la expresión.

El case default se ejecuta si el resultado de la expresión no coincide con ningún case. Su uso también es opcional.

While

La estructura de control while permite ejecutar un bloque de instrucciones mientras se cumpla una condición que se evañúa a un booleano true o false. Como en el caso de la estructura de control if, las llaves solo son obligatorias si el bloque de instrucciones está formado por más de una instrucción.

La sintaxis básica de la estructura de control while es la siguiente:

while(condicion)
{
    //instrucciones
}

Do -While

Existe también una versión diferente, la estructura de control do…while. La diferencia está en que en la estructura while primero comprueba la condición y si se cumple ejecuta el bloque de instrucciones, en cambio en la estructura de control do…while primero se ejecutan las instrucciones y después se comprueba la condición. De esta forma se garantiza que el bloque de instrucciones se ejecute al menos una vez.

La sintaxis básica de la estructura de control do…while es la siguiente:

do
{
   //instrucciones   

} while(condicion);

Vamos a ver unos ejemplos sencillos que utilizen estas dos estructuras de control por ejemplo, mostrar en la salida estándar los números del 1 al 10 con un while y mostrar los números del 10 al 1 con un do…while:

public class EjemploWhile
{
     public static void main(String[] args)
     {
          int numero = 1;
          //Con un while imprimimos mientras numero sea menor que 11
          while (numero < 11)
          {
               System.out.println("Número: " + numero);
               numero++;
          }

          //Con un do...while imprimimos mientras numero sea mayor que 1
          do {
               System.out.println("Número: " + --numero);;
          } while(numero > 1);
     }
}

Si la condición no deja de cumplirse se producirá un bucle infinito y eso es un problema grave que tendremos que evitar a toda costa, a no ser que la lógica del programa lo necesite. Por eso en el bloque de instrucciones tiene que haber un punto de inflexión donde cambie el valor de la condición. En nuestro caso aumentamos y disminuimos la variable numero sabiendo que en algún momento dejará de cumplirse las condiciones.