No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Curso de Introducci贸n a Java SE

Curso de Introducci贸n a Java SE

Anah铆 Salgado D铆az de la Vega

Anah铆 Salgado D铆az de la Vega

Alcance de las variables y Sentencia ELSE

23/39
Recursos

**Mientras m谩s crecen nuestros programas, m谩s l贸gica, complejidad y niveles a帽adimos. Estos niveles son el alcance que tienen nuestras variables, es decir, los lugares d贸nde pueden ejecutarse o no.

Estos niveles (en parte) son representados por las llaves ({ ... }) que envuelven nuestro c贸digo. Por lo tanto, entre m谩s llaves envuelvan nuestro c贸digo, estaremos m谩s niveles dentro y el alcance de las variables que definimos ser谩 un poco m谩s limitado.

Solo podemos usar una variable si la definimos antes, en el mismo nivel o alguno anterior. Pero si declaramos una variable en un nivel posterior al resto de nuestro c贸digo, no podremos modificarla a menos que el c贸digo est茅 en su mismo nivel.

Por ejemplo:

// Primer nivel:
boolean condicion = true;
int numero1 = 1;

// Segundo nivel:
if (condicion) {
  // podemos modificar variables del primer nivel,
  // incluso desde el segundo nivel:
  numero1++;

  // Tambi茅n podemos crear y modificar 
  // nuevas variables en este nivel:
  int numero2 = 10;
  numero2++;
}

// Si volvemos al primer nivel, podemos seguir usando
// y modificando las primeras variables:
numero1--;

// Pero si salimos del segundo nivel no podemos volver a acceder
// a las variables que creamos all铆:
System.out.println(numero2); // ERROR!

La sentencia ELSE es todo lo contrario a la sentencia IF: en vez de ejecutar una parte del c贸digo si la condici贸n es verdadera, solo lo har谩 si la condici贸n NO se cumple:

boolean isBluetoothEnabled = false;
int filesSended = 3;

if (isBluetoothEnabled) {
  fileSended++;
  System.out.println("Archivo enviado");
} else {
  System.out.println("El Bluetooth no est谩 activado");
}
```**

Aportes 86

Preguntas 8

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

A lo que se refiere con Alcance/Scope es que existen dos tipos de declaracion para variables:

  1. Las variables globales: Se definen antes de entrar a una funcion o proceso y que como su nombre indica pueden ser llamadas a procesos en cualquier lugar ya que fueron previamente declaradas. (USO PUBLICO PODRIA DECIRSE)

  2. Las variables locales: Son las que se definen para un proceso en especifico en un funcion especifica y solo van a ser reconocidas para esa funcion o proceso, es decir que si intentamos hacer la llamada a una variable local en otra funcion que no sea la de origen no la reconocera como declarada.(USO PRIVATIZADO)

Lo que pasa en las Vegas se queda en las Vegas鈥
Lo que pasa dentro de el scope se queda en el scope.

java tiene algo muy parecido a un if, se utiliza principalmente para asignaci贸n ya que devuelve un dato.

Sintaxis:

condicion ? (lo que pasa si es verdadero) : (lo que pasa si es falso);

Eje:

boolean par = true;
int a;
a = par ? 2 : 3;
//ahora  a vale 2

par = false;
a = par ? 2 : 3;
//ahora  a vale 3

Resumen
Variables globales: Las que se pueden utilizar en todo el programa, no se encuentran declaradas dentro del cuerpo de alguna funci贸n o m茅todo.
Variables locales: Se encuentran declaradas en el cuerpo de alguna funci贸n o m茅todo y s贸lo se utilizan dentro de la misma.

hay una forma de anidar la sentencia if y else en una sola pero no se si es una buena practica

        int edad =12;
        boolean adulto;
        adulto = (edad >= 18)? true: false;
        System.out.println("es mayor de edad :"+adulto);
``

Tambien existe en java, else if, que permite una nueva validacion del codigo,

if (condicion 1)
{

}
else if (condicion 2)
{

}
else // en caso que no se cumplan ninguna de las 2 condiciones previas
{
}

muchas veces esas preguntas de por qu茅 pasa esto si est谩 declarada, sin tomar en cuenta el alcance

No puedo con el Sended ajaja

Hola Platzinautas

String profe ="Anah铆 Salgado";
   
      if(profe == "Anah铆 Salgado"){
          System.out.println("Excelente curso");
      } else {
          System.out.print("Tambi茅n excelente curso :D");
      }

Deberia ser fileSent hehe 馃槂

Digamos que las llaves act煤an como una prisi贸n y las variables contenidas dentro de ellas, solo existen en el 谩mbito de las llaves que las contienen. Mientras que las que est谩n fuera, tienen un alcance global y pueden ser accedidas en cualquier parte del c贸digo. En el caso de condici贸n est谩 libre y es de acceso global... como dumbo aqui todo feliz y volando![](https://static.platzi.com/media/user_upload/image-11999a9e-e50d-43b3-9418-bc38adce35ce.jpg)Mientras que i est谩 presa dentro de las llaves de nuestro condicional como dumbo aqui todo triste y encerrado ![](https://static.platzi.com/media/user_upload/image-2811bdef-376a-463e-8565-428c06398a0c.jpg)

A lo que se refiere con Alcance/Scope es que existen dos tipos de declaracion para variables:

Las variables globales: Se definen antes de entrar a una funcion o proceso y que como su nombre indica pueden ser llamadas a procesos en cualquier lugar ya que fueron previamente declaradas. (USO PUBLICO PODRIA DECIRSE)

Las variables locales: Son las que se definen para un proceso en especifico en un funcion especifica y solo van a ser reconocidas para esa funcion o proceso, es decir que si intentamos hacer la llamada a una variable local en otra funcion que no sea la de origen no la reconocera como declarada.(USO PRIVATIZADO)

Pr谩ctica con if / else

A lo que se refiere con Alcance/Scope es que existen dos tipos de declaracion para variables:

Las variables globales: Se definen antes de entrar a una funcion o proceso y que como su nombre indica pueden ser llamadas a procesos en cualquier lugar ya que fueron previamente declaradas. (USO PUBLICO PODRIA DECIRSE)

Las variables locales: Son las que se definen para un proceso en especifico en un funcion especifica y solo van a ser reconocidas para esa funcion o proceso, es decir que si intentamos hacer la llamada a una variable local en otra funcion que no sea la de origen no la reconocera como declarada.(USO PRIVATIZADO)

Si este concepto es confuso hay otros cursos que lo abarcan de otra forma como para entenderlo mejor

Escelente explicar scope

No s茅 si existe en Java, pero en c++, el switch es bastante 煤til para condicionales anidados 馃槃

ALCANCE:

1- Variables miembro(脕mbito a nivel clase) : Se puede acceder a estas variables desde cualquier parte de clase , pero no dentro de alg煤n m茅todo de clase.

2- Variables locales(脕mbito a nivel de m茅todo): Solo tienen alcance a nivel de m茅todo y no se puede acceder fuera de el.

3- Variables de bloque: Estas variables solo tienen alcance dentro de { }.

Tambi茅n podemos hacer ifs anidados

public class SentenciaIf {
    public static void main(String[] args) {
        
        boolean validacion = true;
        int contador = 0;

        if (validacion) {
            contador++;
            System.out.println("Enviado");
        }

        System.out.println(contador);


        boolean validar = true;
        if (validar) { 
            int i = 10;
            i++;
            System.out.println(i);
        }
    }
}


馃懢 El alcance permite delimitar el uso de la variable en un determinado bloque de c贸digo.

Gracias a la programaci贸n estructurada xd aprend铆 esto tambi茅n.

Genial! Vamos repasando todo

Si declaramos una variable dentro de un ciclo o bucle solo podremos modificarla o usarla dentro del mismo, pero si deceamos utilizar la mas general no deve de ir dentro de uno de estos ciclos y bucles

<public class IfStatement {
    public static void main(String[] args) {
        boolean isBluetootEnabled = true;
        int fileSendde=3;
        if (isBluetootEnabled){
            //SEND FILE
            fileSendde++;
            System.out.println("el archivo se envio");
        }else {
            System.out.println("el archivo no se envio");
        }
    }
}>

隆S煤per animado con el curso!

Gracias Ana铆s!
```js public class IfStatement { public static void main(String[] args) { boolean isActive = false; if (isActive == true){ System.out.println("is active"); } else { System.out.println("no is active"); } } } ```public class IfStatement { public static void main(String\[] args) { boolean isActive = false; if (isActive == true){ System.*out*.println("is active"); } else { System.*out*.println("no is active"); } } }
\## Descubriendo los Secretos de Java: Variables, Operadores y Alcance La programaci贸n en Java es un vasto universo de posibilidades, y en este viaje, nos sumergiremos en los secretos de las variables, operadores condicionales y el alcance en Java. Desde entender los fundamentos hasta explorar pr谩cticas recomendadas, este art铆culo es tu gu铆a definitiva en el fascinante mundo del desarrollo en Java. \### Variables en Programaci贸n: Pilares Fundamentales Las variables son como las piezas fundamentales de un rompecabezas en el mundo de la programaci贸n. En Java, estas se dividen en dos categor铆as principales: globales y locales. \#### 1. Variables Globales: M谩s All谩 de las Fronteras Las variables globales son declaradas antes de entrar a una funci贸n o proceso. Su caracter铆stica distintiva es que pueden ser llamadas desde cualquier lugar, ya que se han declarado previamente. Son como ciudadanos del mundo Java, de "uso p煤blico", y entender su alcance es crucial. \#### 2. Variables Locales: Privatizadas y Espec铆ficas Las variables locales, en cambio, se definen para un proceso espec铆fico, en una funci贸n determinada. Su visibilidad se limita a ese espacio, y si intentamos accederlas desde otra funci贸n, se nos mirar谩 con desconcierto. Son privadas, destinadas a un "uso privatizado", como si tuvieran su propio mundo aislado. \### Operador Ternario en Java: La Magia del Condicional Compacto En el vasto arsenal de Java, el operador ternario es una joya que facilita la asignaci贸n condicional. Es como un "if" condensado que devuelve un valor en funci贸n de la condici贸n. ```java boolean par = true; int a = par ? 2 : 3; ``` Este peque帽o fragmento de c贸digo ilustra la simplicidad y elegancia del operador ternario. Si "par" es verdadero, "a" ser谩 2; de lo contrario, ser谩 3. \### Estructuras de Control de Flujo: Navegando por las Decisiones Las decisiones son cruciales en cualquier programa, y Java nos ofrece herramientas poderosas para manejarlas. \#### 1. "if-else": Gestionando Casos La estructura "if-else" es como el guardi谩n de las decisiones en Java. Permite gestionar diferentes casos seg煤n condiciones espec铆ficas. Es la br煤jula que gu铆a al programa por diferentes caminos dependiendo de las circunstancias. \#### 2. "Switch": Navegaci贸n Eficiente El "switch" es el navegante eficiente de Java. Perfecto para manejar m煤ltiples opciones de manera concisa, es como un director de tr谩fico que canaliza el flujo del programa hacia diferentes destinos. \### Alcance (Scope) en Java: El Mapa de Visibilidad El alcance en Java es como el mapa que define la visibilidad y accesibilidad de variables y m茅todos. Entender sus cuatro tipos es clave. \#### 1. Alcance Global: Para Todos Las variables y m茅todos a nivel de clase est谩n disponibles para todas las instancias de la clase. Son como las celebridades de Java, reconocidas por todos. \#### 2. Alcance de Clase: Limitado a la Familia El alcance de clase se limita a una clase espec铆fica, sin extenderse a sus subclases. Es la privacidad dentro de la familia Java. \#### 3. Alcance de Objeto: Para el Individuo El alcance de objeto se refiere a la visibilidad dentro de un objeto. Cada objeto tiene su propio mundo y sus propias reglas. \#### 4. Alcance Local: En el Vecindario Las variables locales tienen un alcance limitado a un bloque de c贸digo espec铆fico. Son como residentes temporales, visibles solo dentro de su vecindario. \### Pr谩cticas Recomendadas: El Camino Hacia un C贸digo Elegante El arte de la programaci贸n en Java se perfecciona con pr谩cticas recomendadas. \#### 1. Declaraci贸n Antes de Uso Declarar las variables antes de su uso es como establecer las reglas antes de un juego. Evita confusiones y errores. \#### 2. Comprender el Alcance Entender el alcance es como conocer las leyes del territorio. Evita conflictos de nombres y mejora la estructura del c贸digo. \### Operador Incremento "++": Un Paseo por el Aumento El operador "++" es como el ascensor que lleva el valor de una variable hacia arriba. ```java int fileSended = 3; fileSended++; ``` En este breve fragmento, el valor de "fileSended" aumenta en 1. Una herramienta simple pero poderosa para manipular variables eficientemente. \### Entrada de Usuario: Cuando el Usuario Toma el Tim贸n Simular condiciones con entrada de usuario es como darle el tim贸n al usuario. Las acciones espec铆ficas se desencadenan seg煤n sus decisiones. \### Condiciones en Programaci贸n: Las Claves del Camino Las condiciones son como las se帽ales en una encrucijada. Claves para decisiones basadas en condiciones, los operadores l贸gicos como "&&" y "||" son las herramientas que gu铆an el camino del programa. \### Manejo de Errores Comunes: Evitando Tropiezos Evitar repeticiones innecesarias de c贸digo es como despejar el camino de obst谩culos. Entender y aplicar correctamente el concepto de alcance en programaci贸n es el faro que gu铆a contra los errores comunes. En resumen, la programaci贸n en Java es un viaje emocionante lleno de decisiones, estructuras y secretos. Desde las variables que forman la base hasta las estructuras de control que dirigen el flujo, cada concepto es una herramienta poderosa en manos del programador.

Mis anotaciones:

public class _008_IFStatement {
    public static void main(String[] args) {
        boolean isBluetoothEnabled=false;
        int fileSended=3;
        if(isBluetoothEnabled){
            fileSended++;
            System.out.println("Archivo Enviado");
        }else{
            System.out.println("Por favor enciende tu Bluetooth para iniciar el envio.");
        }
        System.out.println(fileSended);
    }
}

el 鈥渟cope鈥 (alcance) se refiere a la visibilidad y accesibilidad de las variables, m茅todos y clases dentro de un programa. El alcance determina desde qu茅 partes del programa se puede acceder a una variable o invocar un m茅todo y durante cu谩nto tiempo se mantendr谩 su valor.

Java define varios niveles de alcance, que incluyen:

Alcance de clase (Class scope): Las variables y m茅todos declarados a nivel de clase est谩n disponibles para todas las instancias de la clase. Estas variables se conocen como variables de instancia y pueden ser accedidas utilizando una instancia de la clase.

Alcance de m茅todo (Method scope): Las variables declaradas dentro de un m茅todo solo son visibles y accesibles dentro de ese m茅todo. Estas variables se conocen como variables locales y se crean cuando se entra al m茅todo y se destruyen cuando se sale de 茅l.

Alcance de bloque (Block scope): Las variables declaradas dentro de un bloque de c贸digo delimitado por llaves ({}) solo son visibles y accesibles dentro de ese bloque. Esto incluye bloques de c贸digo dentro de m茅todos, bucles, condicionales y otros bloques anidados.

Alcance de par谩metro (Parameter scope): Los par谩metros de un m茅todo tienen un alcance limitado al interior del m茅todo. Estos par谩metros son variables locales que reciben valores cuando el m茅todo es llamado y cesan de existir una vez que el m茅todo se completa.

Es importante comprender y manejar correctamente el alcance en Java para evitar conflictos de nombres, proteger la integridad de los datos y promover una buena estructura de programaci贸n. Al delimitar adecuadamente el alcance de variables y m茅todos, se mejora la claridad, mantenibilidad y eficiencia del c贸digo.

public static void main(String[] args) {
boolean yacomi = true;
int arroz = 2;
if (yacomi) {
// manda mensaje
arroz++;
System.out.println(" si ya comio");
System.out.println(arroz);
}else{
System.out.println(鈥渄enme comida que me muero de hambre鈥);
arroz鈥;
System.out.println(arroz);
}
}


algo no me cuadraba, pero bueno鈥 x

Mi c贸digo de la clase (NetBeans):

En Java, el alcance o 鈥渟cope鈥 se refiere a la visibilidad y alcance de una variable, m茅todo o cualquier otro identificador en un programa. En otras palabras, el alcance determina d贸nde en un programa un identificador puede ser utilizado.

Hay cuatro tipos de alcance en Java:

  1. Alcance global: se refiere al alcance de una variable, m茅todo o cualquier otro identificador en todo el programa.

  2. Alcance de clase: se refiere al alcance de una variable, m茅todo o cualquier otro identificador en una clase, pero no en sus subclases.

  3. Alcance de objeto: se refiere al alcance de una variable, m茅todo o cualquier otro identificador en un objeto.

  4. Alcance local: se refiere al alcance de una variable, m茅todo o cualquier otro identificador en un bloque de c贸digo espec铆fico, como un m茅todo o un bloque if.
    .

  • Alcnace/scope
  • La variable se declara antes de usarse.
import java.util.Scanner;

public class NotasAlumno4 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("Ingrese las 3 notas del alumno: ");
        var nota1 = s.nextDouble();
        var nota2 = s.nextDouble();
        var nota3 = s.nextDouble();

        var promedioNotas = (nota1 + nota2 + nota3) / 3;
        if (promedioNotas >= 7.0){
            System.out.println("Promocionado, su promedio fue: " + promedioNotas);
        } else {
            System.out.println("No fuiste Promocionado, su promedio fue: " + promedioNotas);
        }


    }
}

visto en clase

Esta profesora es excelente, explica con suma facilidad y se le entiende todo muy claro.

public class If {
    public static void main(String[] args) {

        int x = 10;
        int y = 10;
        if(x>y){
            System.out.println("'x' es mayor a 'y'");
        }
        else if(x<y){
            System.out.println("'x' es menor a 'y'");
        }
        else{
            System.out.println("'x' es igual a 'y'");
        }
        

    }

el c贸digo que se us贸 en la clase

public class IfSentence {
    public static void main(String[] args) {
        //necesitamos enviar un archivo v铆a bluethoot
        //vamos a verificar si est谩 habilitado o no

        boolean isBluethootEnabled = false;
        int fileSended = 0;

        //preguntamos si esa verificaci贸n es verdadera
        if(isBluethootEnabled == true){
            //enviar el archivo

            fileSended++;
            System.out.println("Archivo enviado con 茅xito <3");
        }else {
            System.out.println("Porfi enciende el bluethoot para poder enviarlo :c");
        }
        System.out.println(isBluethootEnabled);
        System.out.println(fileSended);
    }
}

Todos los Operadores:

/* La sentencia if

    if (condicion) {
        instruccion1;
    }else{
        instruccion2;
    }

*/

/*
Operadores:

==  : Igualdad
!=  : Diferencia
<   : menor que
>   : mayor que
<=  : menor o igual que
>=  : mayor o igual que

*/

package condicionales;

import javax.swing.JOptionPane;

public class Condicionales {

public static void main(String[] args) {
    //Declaro variables
    int numero, dato=5;
    
    /* Capturo el dato del usuario en modo Stream con la clase JOptionPane, 
    y lo convierto a int con la ayuda del m茅todo de la clase Integer.parseInt.
    */
    numero= Integer.parseInt(JOptionPane.showInputDialog("Digite un n煤mero: "));
    
    /*Valido si el valor escrito por el usuario con la ayuda de la condicional if*/
    
    //Operador de la igualdad
    

    if (numero == dato) {
        JOptionPane.showMessageDialog(null, "El n煤mero es igual a "+dato);
    }else{
        JOptionPane.showMessageDialog(null, "El n煤mero es diferente de "+dato);
    }

    
    //Operador de la desigualdad
    
    /*
    if (numero != dato) {
        JOptionPane.showMessageDialog(null, "El n煤mero es diferente de "+dato);
        
    }else{
        JOptionPane.showMessageDialog(null, "El n煤mero es igual a "+dato);
    }
    */
    
    //Operador de mayor
    
    /*
    if (numero > dato) {
        JOptionPane.showMessageDialog(null, "El n煤mero es mayor que "+dato);
        
    }else{
        JOptionPane.showMessageDialog(null, "El n煤mero es "+dato+" o menor que "+dato);
    }
    */
    
    //Operador de menor
    
    /*
    if (numero < dato) {
        JOptionPane.showMessageDialog(null, "El n煤mero es menor que "+dato);
        
    }else{
        JOptionPane.showMessageDialog(null, "El n煤mero es "+dato+" o mayor que "+dato);
    }
    */
    
    //Operador mayor o igual
    
    /*
    if (numero >= dato) {
        JOptionPane.showMessageDialog(null, "El n煤mero es mayor o igual que "+dato);
        
    }else{
        JOptionPane.showMessageDialog(null, "El n煤mero es menor que "+dato);
    }
    */
    
    //Operador de menor o igual
    
    /*
    if (numero <= dato) {
        JOptionPane.showMessageDialog(null, "El n煤mero es menor o igual que "+dato);
        
    }else{
        JOptionPane.showMessageDialog(null, "El n煤mero es mayor que "+dato);
    }
    */
    
}

}

Operador Ternario ?
public class EjemploIF {
public static void main(String args[]) {
int i = 1;
int j = 2;
int numeroMayor = 0;
numeroMayor = i > j ? i : j;
System.out.println("numeroMayor: " + numeroMayor);
}
}

Entiendo mmm

interesante el alcance de variables al momento de declararlo en
scope {}

Una variable es accesible dentro del bloque de c贸digo en que se declara {}, un bloque de c贸digo esta limitada por las llaves de apertura 鈥渰鈥 y cierre 鈥渳鈥.

Alguien mas amo esta clase?? 鉂わ笍
boolean isBluethoothEnabled = false;
int fileSended = 3;

 if (isBluethoothEnabled){
     //Send file
     fileSended++;
     System.out.println("Archivo Enviado");

 } else {
     fileSended--;
     System.out.println("Por favor enciende tu Blootooth, para iniciar la transferencia");
 }

 System.out.println(isBluethoothEnabled);
 System.out.println(fileSended);
 System.out.println();

Muy bien explicado 馃榿

Interesante!

variable global y parametro sin modificador de acceso vendria a ser lo mismo?

Genial.

Excelente!!

    boolean bluetoothOn = true;
    int fileSent = 4;
    if (bluetoothOn && fileSent < 4){
        fileSent++;
        System.out.println("Archivo enviado");
    }else {
        System.out.println("Se alcanzo el Limite de archivos enviados");
    }

public static void main(String[] args) {
boolean isBooleanOn = false ;
// SCOPE: ALCANCE DE LA VARIABLE DE ACUERDO A LAS LLAVES, O A LA ZONA EN DONDE ESTA DECLARADA
// O CREADA, SE PUEDE ACCESAR A LA VARIABLE SI EL SCOPE LO PERMITE
int cont=0;

    if (isBooleanOn==true){
        cont++;
        System.out.println("ENVIANDO ARCHIVO NUMERO: "+cont);
    }
    else{
        System.out.println("ARCHIVO NO ENVIADO");
    }

}
`<code>

MI practica :3

public class Experimento {
    public static void main(String[] args) {

        boolean estado = true;

        if (estado){
            System.out.println("El Pc se prende");
        }
        else {
            System.out.println("El pc se apaga");
        }
    }
}

conocer el alcance de las variables nos puede evitar algunos dolores de cabeza

Scope!

muy bien explicado 馃槂

Todos iniciamos en 鈥溾"""鈥淚nteligencia Artificial鈥"""" con puros if y else jajajaja. Los condicionales son una herramienta muy 煤til en la programaci贸n, yo dir铆a que es lo que mas us茅 cuando aprend铆 a programar en C++

De los t茅cnicas de programaci贸n que yo he visto esta es la m谩s utilizada, ya que permite tomar f谩cilmente decisiones entre dos caminos y es ideal para representar, por ejemplo al realizar un diagrama de flujo. Por cierto, estuvo buena la explicaci贸n del alcance/scope de una variable instructora Anah铆.

Esto es genial鈥!!!

Tener muy en claro lo de las variables dentro de los scots y sus alcances.

if (isBluethoothEnable == true){

            fileSended++;
            System.out.println("el archivo enviado");

        }


else {
                System.out.println("no enviaste nada");
            }```
public class SentenciaIf {
    public static void main(String[] args) {
        boolean sentencia = true;
        int var = 3;

        if (sentencia){
            var++;
            System.out.println("Archivo enviado");
        } else {
            System.out.println("Archivo no enviado");
            var--;
        }
        System.out.println(var);
    }
}```

alcance ok 馃槂

Todo claro.

Alcance de las variables y Sentencia Else
.
Variables:
Variables globales: se encuentran fuera de las llaves (de un encapsulamiento) y puede ser usado de manera global en el c贸digo.
Variables locales: se encuentran dentro de las llaves (de un encapsulamiento) y solo puede ser usada de manera local en el c贸digo, es decir, que solo es reconocida dentro de las llaves.
.
Else: se ejecuta no si la condici贸n es verdadera, si no se ejecuta cuando no se cumple la condici贸n.

Excelente explicaci贸n,
realice un prueba que imprime la variable 鈥渋鈥 en la seccion del if y del else y solo funciona exclusivamente en la secci贸n del if

public class IfStatement {
public static void main(String[] args) {
boolean isBluetoothEnabled = true; //variable Global
int fileSended = 3;

    if (isBluetoothEnabled) {
        //send file
        fileSended++;
        System.out.println(fileSended);
        System.out.println("Archivo Enviado");
        int i = 0;     //variable local
        i++;
        System.out.println("Contador: " + i);             //IMPRIME EL VALOR
    }
    else {
        fileSended--;
        System.out.println("Por favor Turn ON BLUETOOTH");
        System.out.println(fileSended);

        System.out.println("salimos del if: " + i);            //GENERA ERROR!!
    }

}

}

si platzi

Todo clar铆simo. Gracias

public class ifStatement {
    public static void main(String[] args) {
        boolean isBluetoothEnable = true;
        int fileSended = 0;

        if(isBluetoothEnable){
            //Send file
            fileSended++;
            System.out.println("Archivo enviado");
        }else{
            System.out.println("Enciende el Bluetooth!");
        }
        //Cantidad de archivos enviados
        System.out.println("Archivos enviados: " + fileSended);

    }
}```

I鈥檓 ahead of my time x2 馃槑:

import java.lang.*;
import java.util.Scanner;

/**
 * IfPractice
 */

/**
 * basic structure of an if
 * if (condition) {
 *  //instructions
 * }
 */
public class IfPractice {

    public static void main(String[] args) {
        boolean bluetoothEnabled = false;
        //Boolean sendFile = null;
        int filesSended = 0;

        Scanner scanner = new Scanner(System.in);

        //mental note: == compares (for ex:) string objects, not their content
        //however, this does: if (myString.equals("text")) { //do something }

        //simulate wifi
        System.out.printf("Simulate wifi status (on/off): ");
        String bluetoothSimulation = scanner.next();

        if (bluetoothSimulation.equals("on") || bluetoothSimulation.equals("ON")) {
            bluetoothEnabled = true;
            System.out.println(bluetoothEnabled);
        } else if (bluetoothSimulation.equals("off") || bluetoothSimulation.equals("OFF")) {
            bluetoothEnabled = false;
            System.out.println(bluetoothEnabled);
        } else {
            //keeps it on false
            bluetoothEnabled = false;
        }

        System.out.printf("\n----//----//----\nDo you want to send a file? (y/n): ");
        char uAnswer = scanner.next().charAt(0);
        if (uAnswer == 'y' || uAnswer == 'Y') {
            System.out.printf("\n馃梼----File-Sender----馃梼\n\n");
            if (bluetoothEnabled == true) {
                try {
                    //send a file
                    //let user choose file
                    System.out.printf("Name of the file: ");
                    String fileName = scanner.next();
                    Thread.sleep(100);
                    System.out.printf("Name of the reciever: ");
                    String recieverName = scanner.next();
                    Thread.sleep(1000);
                    System.out.printf("\nSending file(s) to %s... 馃搫\n", recieverName);

                    Thread.sleep(1500);
                    filesSended++;
                    System.out.printf("File sent: %s\nTotal of files sent: %d馃敟\n", fileName, filesSended);
                } catch (InterruptedException e) {
                    //TODO: handle exception
                    ;
                }
            } else if (bluetoothEnabled == false) {
                System.out.printf("\nTo share files you need to have a bluetooth connection\nand this is mandatory\n\n");
                try {
                    System.out.printf("Do you want to turn on the bluetooth? (y/n): ");
                    char uAnswerBluetooth = scanner.next().charAt(0);
                    if (uAnswerBluetooth == 'y') {
                        System.out.printf("Turning on the bluetooth...\n");
                        Thread.sleep(1000);
                        System.out.println("Bluetooth is on! run this program again 馃槑馃嵎");
                    } else if (uAnswerBluetooth == 'n') {
                        System.out.printf("\nOkay, glad to helped!\nc ya later 馃槑\n");
                    } else {
                        System.out.printf("\nERROR: the only two valid answers are 'y' & 'n',\nhowever you entered %c (鉂)\n\n", uAnswerBluetooth);
                        System.exit(1);
                    }
                } catch (InterruptedException e1) {
                    //TODO: handle exception
                }
            } else {
                ; //booleans have only two states
            }

        } else if (uAnswer == 'n' || uAnswer == 'N') {
            System.out.printf("\nOkay, glad to helped!\nc ya later 馃槑\n");
            System.exit(0);
        } else {
            System.out.printf("\nERROR: the only two valid answers are 'y' & 'n',\nhowever you entered %c (鉂)\n\n", uAnswer);
            System.exit(1);
        }

    }
}

Output x2:

Simulate wifi status (on/off): off
false

----//----//----
Do you want to send a file? (y/n): y

馃梼----File-Sender----馃梼


To share files you need to have a bluetooth connection
and this is mandatory

Do you want to turn on the bluetooth? (y/n): y
Turning on the bluetooth...
Bluetooth is on! run this program again 馃槑馃嵎

Aqui les dejo una pagina donde Pueden resolver dudas sobre conceptos

https://www.w3schools.com/java/java_scope.asp

muchas gracias por el aporte

incre铆ble clase

Lo que est茅 dentro del bloque de c贸digo va a existir solo ah铆, tiene un alcance local.

El 谩mbito de una variable define su alcance de uso, o lo que es lo mismo, en que secciones de c贸digo una variable estar谩 disponible. Fuera de este 谩mbito, una variable no podr谩 ser accedida (no existe).

En Java tenemos tres tipos de 谩mbito que pueden aplicar a una variable:

  • Local
  • Global
  • Est谩tico

Variables de 谩mbito local

Las variables de 谩mbito local, o de bloque, son aquellas que s贸lo pueden ser accedidas desde el bloque de c贸digo en el que han sido declaradas (que no inicializadas).

Variables de 谩mbito global

Las variables de 谩mbito global, o de instancia, son aquellas que pertenecen a cada instancia concreta de la clase donde han sido declaradas, y dependiendo del modificador de visibilidad usado podr铆an ser s贸lo accedidas desde la propia instancia a la que pertenecen

Variables est谩ticas

Las variables est谩ticas, o de clase, son aquellas que pertenecen a la propia clase donde han sido declaradas, y dependiendo del modificador de visibilidad usado podr铆an ser s贸lo accedidas desde la propia clase en la que han sido declaradas

public class IfStatement {
    public static void main(String[] args) {
        boolean bluetoothActivo = false;
        int fileSendsed = 0;

        if(bluetoothActivo){
            fileSendsed ++;
            System.out.println("Archivo enviado ");
            System.out.println(fileSendsed);
        }else{
            System.out.println("Por favor enciende el bluetooth!");
            fileSendsed --;
            System.out.println("Archivo enviado ");
            System.out.println(fileSendsed);
        }
    }
}

Debemos tener presente el scope o alcance para que no usemos una variable que solo tiene un alcance limitado.