Java básico #6

1.6 Estructuras de control

          Las estructuras de control determinan la secuencia de ejecución de las sentencias de un programa. Se dividen en 3 categorías:

• Estructura secuencial
• Estructura condicional, alternativa o selectiva
• Estructura iterativa o repetitiva

Estructura secuencial:

          Las sentencias se ejecutan una detrás de otra

1. {
2.     Instrucción 1;
3.     Instrucción 2;
4.     Instrucción 3;
5. }

Estructura condicional, alternativa o selectiva:

     Determina si se ejecutan unas instrucciones u otras según una condición

• Instrucción if:

1. if(condicion){}
2. if(condicion){}else{}
3. if(condicion){}else if(){}

La condición tiene que ser una expresión booleana.

• Instrucción switch

      Se usa para seleccionar una de entre múltiples alternativas:

           

1. switch(condicion){
2.      case valor1:
3.             instrucciones;
4.             break;
5.      case valor 2:
6.             instrucciones;
7.             beak;
8. default:
9.             instrucciones;

    Primero se evalúa la condición y salta al case cuyo identificador es igual al resultado de la condición. Si ninguno de estos casos se cumple, se ejecuta el default (si existe).

Estructura iterativa o repetitiva:

    Permite ejecutar de forma repetitiva un bloque de instrucciones, estas se repiten según una condición. Hay 3 ciclos repetitivos:

• Ciclo while

        Se repite si la condición es true, se cmprueba al principio del bloque y se ejecuta 0 o más veces.

  1. while(condicion){}

• Ciclo do-while

        Se repite si la condicion es true, se comprueba al final y se ejecuta como mínimo una vez.

1. do{
2.      codigos;
3. }while(condicion);

• Ciclo for

      Se repite un determinado de veces mientras se cumpla una condición:

1. for(int i = 1; i <= 10; i++){
2.       System.out.println("La variable i vale:"+i);
3. }

   Se repetira 10 veces por la condición central, 'i'  irá incrementando de uno en uno (i++) hasta que sea <= 10. Solo se puede incrementar(++) o decrementar(--).

   La salida de este ciclo es:

    Bucles infinitos:

       Se ejecutan indefinidamente, a no ser que provoquemos su interrupcion

        for(;;){}

        for(;true;){}

    while(true){}


    Se pueden anidar bucles:
       

1. for(int i = 1; i <= 10; i++){
2.      
3.              for(int j = 10; j <= 2; j--){
4.              }
5. }

Ejercicio del post anterior:

1. package com.tutorial;
2.  
3. public class Operadores {
4.    
5.     public static void main(String arg[]){
6.        
7.         int a =4, b = 5, res;
8.  
9.         @SuppressWarnings("unused") //Ignora los mensajes de que la variables no esta usada
10.         double c = 4.5;
11.         double d = 8.4;
12.         double e = 7.4;
13.        
14.         if(d > e && a == 4){
15.             res = a+b;
16.             System.out.println(res);
17.         }else{
18.             System.out.println("No se ha cumplido ninguna opción");
19.         }
20.     }
21.  
22. }

   Como veis en el código uso @SuppressWarnings("unused") esto se llama anotación y entre parentesis va el tipo de anotacion.

   Una anotación es una forma de añadir metadatos al código fuente del programa disponible desde Java 5.

   La anotación @SuppressWarnings esconde los avisos de eclipse. Con esta anotación podemos usar:

• all para suprimir todos los avisos
• boxing para suprimir los avisos relativos a las operaciones de empaquetado/desempaquetado
• cast para suprimir avisos relativos a las operaciones de conversión temporal
• dep-ann para suprimir avisos relativos a las anotaciones de desuso
• deprecation para suprimir avisos relativos al desuso
• fallthrough para suprimir avisos relativos a los enlaces faltantes en las sentencias switch
• finally para suprimir avisos relativos al bloque finally que retornan
• hiding para suprimir avisos relativos a locales que ocultan la variable
• incomplete-switch para suprimir avisos relativos a entradas faltantes en una sentencia switch (caso enum)
• javadoc para suprimir avisos relativos a avisos javadoc
• nls para suprimir avisos relativos a literales de serie no nls
• null para suprimir avisos relativos a análisis nulos
• rawtypes para suprimir avisos relativos al uso de tipos raw
• resource para suprimir avisos relativos al uso de recursos del tipo Closeable
• restriction para suprimir avisos relativos a la utilización de referencias en desuso o prohibidas
• serial para suprimir avisos relativos al campo serialVersionUID faltante para una clase serializable
• static-access para suprimir avisos relativos al acceso estático incorrecto
• static-method para suprimir los avisos relativos a lo métodos que podrían declararse como estáticos
• super para suprimir los avisos relativos a la alteración temporal de un método sin superinvocaciones
• synthetic-access para suprimir avisos relativos al acceso no optimizado desde clases internas
• sync-override para suprimir avisos debidos a la falta de sincronización al alterar temporalmente un método sincronizado
• unchecked para suprimir avisos relativos a operaciones no comprobadas
• unqualified-field-access para suprimir avisos relativos al acceso a campo no calificado
• unused para suprimir avisos relativos a código no utilizado y código muerto

   Si suprimimos esta anotación eclipse nos dará un aviso de que la variable c no esta usada, para solucionarlo podemos o añadir esta anotación o eliminar la declaración de la variable.

Ejercicios:

 1. Crea un bucle que se ejecute 10 veces y que imprima "Este es mi primer código: ", concatenando el valor de la variable declarada en el bucle.

NOTA: Acuérdate que una concatenación se ase así "cadena de texto"+variable,

2. ¿Para que crees que se usa el bucle while?¿y el do-while?

Cualquier duda a los comentarios.