SCJP Study Guide: lectura terminada

Hace poco que terminé de leer el libro "SCJP Sun Certified Programmer for Java 6 Study Guide" para presentar el examen de certificación de Java (que ahora se llama OCPJP). 

Me ha motivado mucho el hecho de haberlo terminado, ya que falta más de un mes para presentar el examen, así que ahora dedicaré mucho tiempo a hacer muchos simuladores y mejorar mis conocimientos.

Sin embargo aún tengo algunas dudas que iré estudiando poco a poco. Algunas de esas dudas las publicaré en esta entrada.

Asignación a una variable de instancia o local final

A una variable de instancia o local marcada como final, se le puede asignar su valor después de haber sido declarada una sola vez, es decir, si al momento de haber sido declarada la variable final no se le asignó algún valor ó referencia, se tendrá una única oportunidad para hacerlo después de su declaración.

1. final int x;
2.
3. x = 5;   //Correcto 

4. x = 7;   //Incorrecto

La línea 4 provocaría un error de compilación debido a que x es final y ya se le asignó un valor en la línea 3.

Esto también es válido para un constructor de alguna clase:

1. public class Prueba{
2.     private final double z;
3. 
4.     public Prueba(double z) {
5.          this.z = z;    //(1)
6.     }
7. }

La línea 5 es válida aunque la variable de instancia z tenga el modificador final, ya que al momento de su declaración no se le asignó ningún valor y en esta línea se realiza esa asignación debidamente.

Acceso a enum de una clase externa

Para acceder a los elementos de un enum que se encuentra en una clase externa a la que necesitamos dicho elemento, se realiza de la siguiente forma: 

1.  class A{
2.      enum B{C, D, E};
3.  }
4.
5.  public class Test{
6.     public static void main(String [] v){
7.          A.B ab = A.B.C;
8.       
9.          System.out.println(ab);
10.   }
11. } 
 
Con la línea 7 se accede al enum de la clase A de forma correcta.

Etiquetas en los bucles

Las etiquetas en los bucles son algo que vi en las preguntas del libro y en los simuladores que he hecho, y he aquí algo importantísimo de estás etiquetas.

Cuando  hay bucles anidados y el bucle más interno realiza un break hacia una etiqueta del exterior de los bucles, se rompen todos los bucles que antecedían al más interno, es decir:

1.  public class Test{
2.      public static void main(String [] v){
3.          String o = "";
4.     
5.          z:               
6.          for(int i = 0; ++i < 5; ){
7.              for(int j = 0; j < 5; j++){
8.                  if(i == 1)
9.                      break;
10.                
11.                 if((i == 2) && (j == 2))
12.                     break z;
13.                    
14.                 o = o + i + j;
15.             }
16.         }
17.        
18.         System.out.println("\n" + o);
19.     }
20. }

El código anterior generará en la salida:

Debido a que el break de la línea 12 rompe con ambos bucles lo que involucra que ya no se acceda más a ambos bucles y continuar con la ejecución del programa en la línea 18. 

Las etiquetas en los bucles deben ser precisamente definidas, es decir, después de colocar una etiqueta debe ir inmediatamente el bucle al que se le dará el salto, de no ser así, se tendrá un error de compilación.

1.  public class Test{
2.      public static void main(String [] v){
3.          String o = "";
4.     
5.          z:   //Error, debido a que no
6.               //está antes del bucle
7.          System.out.println();

8.
9.          for(int i = 0; ++i < 5; ){
10.              for(int j = 0; j < 5; j++){
11.                  if(i == 1)
12.                      break;
13.                
14.                 if((i == 2) && (j == 2))
15.                     break z;
16.                    
17.                 o = o + i + j;
18.             }
19.         }
20.        
21.         System.out.println("\n" + o);
22.     }
23. }

Iniciar Thread dentro de un método

Es válido iniciar un Thread dentro de un método de la clase que extiende Thread:

1.  public class Test extends Thread{
2.      public void run(){
3.          for(int i = 0; i < 5; i++){
4.              try{
5.                  Thread.sleep(1000);
6.              }catch(InterruptedException ie){}
7.             
8.              System.out.println(i);
9.          }
10.     }
11.
12.     public static void main(String [] v args){
13.         new Test().go();
14.     }
15.    
16.     public void go(){
17.         System.out.println("Starting thread...");
18.         start();
19.     }
20. }
 
La línea 18 inicia el hilo a través del método start, y como se puede ver, están dentro de un método: go().