A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

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 66

Preguntas 7

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta 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)

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

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

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

Tambi茅n podemos hacer ifs anidados

Hola Platzinautas

String profe ="Anah铆 Salgado";
   
      if(profe == "Anah铆 Salgado"){
          System.out.println("Excelente curso");
      } else {
          System.out.print("Tambi茅n excelente curso :D");
      }
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!

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

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)

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);
    }
}

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 { }.

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

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

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.