Java Academy · Lección

Ámbito y ciclo de vida

Comprenda dónde son visibles las variables (ámbito) y cuánto tiempo existen (ciclo de vida): bloques, bucles, métodos, campos, ocultación y parámetros final.

Ámbito y ciclo de vida es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 3 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 3 lecciones en total.

Alcance frente a ciclo de vida

Alcance = dónde es visible un nombre (variable). Ciclo de vida = cuánto tiempo existe la variable. Verá el alcance de bloques y bucles, las variables locales de métodos, los campos de clase y las reglas de ocultación.

Alcance de bloque

Alcance de bloque: una variable declarada dentro de llaves solo es visible dentro de esas llaves.

public class Main {
  public static void main(String[] args) {
    int a = 10; // visible in main
    {
      int b = 20; // visible only inside this block
      System.out.println("inside block: a=" + a + ", b=" + b);
    }
    System.out.println("outside block: a=" + a);
    // System.out.println(b); // would NOT compile: b is out of scope
  }
}

Alcance de bucle

Alcance de bucle: un índice de bucle declarado en la cabecera de for solo es visible dentro del cuerpo del bucle.

public class Main {
  public static void main(String[] args) {
    for (int i = 0; i < 3; i = i + 1) {
      System.out.println("i in loop = " + i);
    }
    // System.out.println(i); // would NOT compile: i is scoped to the loop

    int j;
    for (j = 0; j < 2; j = j + 1) {
      System.out.println("j in loop = " + j);
    }
    System.out.println("j after loop = " + j); // OK: j declared outside
  }
}

Campos frente a variables locales

Ciclo de vida: los campos de clase/estáticos viven durante varias llamadas; las variables locales se vuelven a crear en cada llamada y después se descartan cuando termina el método.

public class Main {
  // static field (class-level): lives for the program lifetime
  static int counter = 0;

  static void tick() {
    int local = 100; // local: created each call, dies when method returns
    counter = counter + 1;
    System.out.println("tick: counter=" + counter + ", local=" + local);
  }

  public static void main(String[] args) {
    tick();
    tick();
    tick();
    System.out.println("final counter=" + counter);
  }
}

Ocultación

Ocultación: una declaración interna (por ejemplo, un parámetro o una variable local) puede ocultar un nombre externo con el mismo identificador. Use ClassName.field (o this.field en métodos de instancia) para acceder al campo oculto.

public class Main {
  static String label = "FIELD"; // class field

  static void demo(String label) { // parameter shadows field name
    System.out.println("param label = " + label); // uses parameter
    {
      String labelInner = "INNER"; // new name in inner block
      System.out.println("inner block labelInner = " + labelInner);
      System.out.println("still param label = " + label);
    }
    System.out.println("field via class name = " + Main.label); // refer to field explicitly
  }

  public static void main(String[] args) {
    demo("PARAM");
  }
}

Final y paso por valor

Los parámetros final no se pueden reasignar. Java utiliza el paso por valor: reasignar el parámetro no cambia la variable del código que realizó la llamada.

public class Main {
  // final parameter cannot be reassigned inside the method
  static int inc(final int n) {
    // n = n + 1; // would NOT compile if uncommented
    return n + 1; // safe: return a new value
  }

  static void reassign(int x) {
    x = 999; // reassignes the local copy; caller variable is unchanged
  }

  public static void main(String[] args) {
    int a = 5;
    int b = inc(a);
    System.out.println("a=" + a + ", b=inc(a)=" + b);

    reassign(a);
    System.out.println("after reassign(a): a is still " + a);
  }
}

Comprobación de alcance y ciclo de vida

Comprobación rápida: ¿Qué afirmación sobre el alcance y el ciclo de vida es VERDADERA?

Repaso y siguiente paso

Repaso: Practicó el alcance de bloques y bucles, los campos frente a las variables locales, la ocultación y los parámetros final. Siguiente paso: avanzar a los patrones de diseño y reutilización en A2.2.

Preguntas frecuentes

¿La lección «Ámbito y ciclo de vida» es gratis?

Sí — el texto completo de «Ámbito y ciclo de vida» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 3 lecciones en total.

¿Qué aprenderé en «Ámbito y ciclo de vida»?

Comprenda dónde son visibles las variables (ámbito) y cuánto tiempo existen (ciclo de vida): bloques, bucles, métodos, campos, ocultación y parámetros final. Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 3.

¿Cuánto tiempo toma la lección «Ámbito y ciclo de vida»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Java Academy