Alcance de las variables y Sentencia ELSE

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

el “scope” (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.

Deberia ser fileSent hehe 😃

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!

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

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(“denme 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 “scope” 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 “”"""“Inteligencia 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 “i” 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’m 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.