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

Operadores Lógicos y Expresiones booleanas

24/39
Recursos

Nuestros condicionales no solo pueden evaluar variables booleanas, también pueden evaluar si el resultado de una operación es verdadero o falso.

Por ejemplo:

boolean condicionA = true; // verdadero
boolean condicionB = false; // falso

boolean condicionC = 2 + 2 == 4; // verdadero
boolean condicionD = 2 + 2 == 5; // falso

boolean condicionE = "Pepito" == "Pepito"; // verdadero
boolean condicionF = "Pepito" == "Pepe"; // falso

Para esto debemos usar los operadores lógicos:

Operadores de equidad:

  • Igualdad: ==
  • Desigualdad: !=

Operadores Relacionales:

  • Menor que: <
  • Mayor que: >
  • Menor o igual que: <=
  • Mayor o igual que: >=

Operadores lógicos:

  • &&: AND (evaluar si dos o más condiciones son verdaderas).
  • ||: OR (evaluar si al menos una de las condiciones es verdadera).
  • !: NOT (evaluar que la condición NO sea verdadera).

Recuerda que además de las sentencias IF y ELSE, también podemos usarELSE IF. Esta la usamos cuando queremos evaluar alguna condición diferente a la condición delIF` pero no exactamente al revés.

Por ejemplo:

if (noHayInternet) {
  System.out.println("No hay Internet");
} else if (hayInternetPeroMuyPoquito) {
  System.out.println("Tienes muy poquito Internet");
} else if (hayBuenInternetPeroNoEsSuficiente) {
  System.out.println("Casi casi, falta solo un poquito más");
} else {
  System.out.println("¡Tienes suficiente Internet!");
}

Aportes 73

Preguntas 4

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Antes de que te partes la cabeza con el NOT (!):

Supongamos que quieres ejecutar una parte de tu código únicamente cuando no tienes internet, no sé, un dinosaurio esquivando árboles o algo por el estilo.

En este caso la lógica de tu programa sería algo así:

boolean hayInternet = true; // sí, hay internet

// ...  pasa un rato ...

hayInternet = false; // ya NO hay internet!

// Dino solo corre si no hay internet
if (!hayInternet) {
  // codigo para poner a correr a Dino
}

OR - Para que el resultado sea verdadero, A o B tienen que ser verdaderas (1)

A	B	OUT
0	0	0
0	1	1
1	0	1
1	1	1

AND - Para que el resultado sea verdadero, A y B tienen que ser verdaderas (1).

A	B	OUT
0	0	0
0	1	0
1	0	0
1	1	1

NOT - Invierte el resultado

A = 0	!A	=>	1
B = 1	!B	=>	0

Existen otros operadores lógicos
XOR, NOR y NAND.

XOR - Es verdadero cuando alguna entrada es verdadera, pero no ambas

A	B	OUT
0	0	0
0	1	1
1	0	1
1	1	0

NOR - Función inversa del operador OR, es decir, la salida es verdadera cuando ambas entradas(variables) son falso.

A	B	OUT
0	0	1
0	1	0
1	0	0
1	1	0

NAND - Función inversa del operado AND, la salida es verdadera en todos los casos excepto cuando las entradas (variables) son verdaderas

A	B	OUT
0	0	1
0	1	1
1	0	1
1	1	0

La prioridad en la ejecucion de las operaciones y operadores.

Operadores Java
.
Operadores Lógicos
.

.

Operadores Relacionales
.

Operadores Equidad
.

Hay que saber usar muy bien los if else, con un gran poder viene una gran responsabilidad. Si abusamos de ellos crearemos sin saber codigo espagueti que luego es muy dificil de mantener.

Operadores de equidad: ==, !=.
Operadores de relacionales: <, >, >=, <=.
Operadores logicos: &&, ||, !

Algo importante con respecto a else if que no veo explicado va asociado a cuando se ejecuta la verificación de cada una de las condiciones. Por ejemplo con:

public class IfStatement {
    public static void main(String[] args) {
        boolean bleState = true;
        boolean deviceOn = true;
        
        if (bleState){
            System.out.println("Bluetooth is enabled");
        }
        else if (bleState && deviceOn){
            System.out.println("Bluetooth is enabled again");
        }
        else {
            System.out.println("Bluetooth is not enabled");
        }
    }

La salida del sistema es:

Bluetooth is enabled

Es decir solo se verifican las condiciones hasta que alguna se cumpla (En caso de ninguna cumplirse se remite a else).

Con el uso de multiples sentencias if se obliga que cada una de las condiciones deba ser verificada como se muestra a continuación.

public class IfStatement {
    public static void main(String[] args) {
        boolean bleState = true;
        boolean deviceOn = true;

        if (bleState){
            System.out.println("Bluetooth is enabled");
        }
        if (bleState && deviceOn){
            System.out.println("Bluetooth is enabled again");
        }
        else {
            System.out.println("Bluetooth is not enabled");
        }
    }
}

Esta vez la salida del sistema verifica la primera y segunda condición.

Bluetooth is enabled
Bluetooth is enabled again

Algo que me ayudo bastante con los condicionales dobles y anidados, específicamente con eso de AND, OR, etc.

Fue la asignatura de “Matemáticas Discretas” de la universidad, pero aquí en Platzi también hay curso al respecto:

https://platzi.com/cursos/discretas/

Y

https://platzi.com/cursos/pensamiento-logico/

El “==” se utiliza para realizar comparaciones, mientras que, el “=” se utilizar para realizar asignaciones.

Esta informacion vale oro

Apuntes de la clase 👇
.

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

        int a = 8;
        int b = 5;

        if (a == b){
            System.out.println("a y b son iguales");
        }
        else if (a!=b){
            System.out.println("a es diferente de b");
            if (a >b){
                System.out.println("Ademas a es mayor que b");
            }
            else if(a < b){
                System.out.println("Ademas b es mayor que a");
            }
        }


    }
}

Optimice un poco el codigo añadiendo if anidados uno con otros

Falta el operador XOR, ^, que solo devuelve true cuando solo una de las dos opciones es true;

sólo les dire, mucho cuidado con los if anidados, si tienen más de dos asústensen. O(n^2)

public class LogicOperators {

    public static void main(String[] args) {

        int a = 1;
        int b = 3;
        int c = 5;
        System.out.println("Starting number comparation. . .");
        System.out.println("Determinating the higher number. . .");
        System.out.println("a is the higher number: " + ((a > b && a > c) ? "" + a : false));
        System.out.println("b is the higher number: " + ((b > a && b > c) ? "" + b : false));
        System.out.println("c is the higher number: " + ((c > a && c > b) ? "" + c : false));

    }
}

Los if ternarios son de gran utilidad pues, nos ayudan a ahorrar varias lineas de codigo a la vez que hacen mas sencilla la lectura de nuestro codigo.

Sino aplica para ninguna se cierra el if con un else; para tener en cuenta que nos pasa en la vida real. Pueden ocurrir que ninguna de las opciones aplique.

Gracias por compartir.

Comparto mi codigo de esta clase

public class LogicOperations
{
    public static void main(String[] args)
    {
        int a = 8;
        int b = 5;

        //Operadores de Asignacion
        System.out.println("a es igual a b -->" + (a == b));
        System.out.println("a es diferente a b -->" + (a != b));

        //Operadores Relacionales
        System.out.println("a es menor que b -->" + (a<b));
        System.out.println("a es mayor que b -->" + (a>b));
        System.out.println("a es menor o igual que b -->" + (a<=b));
        System.out.println("a es mayor o igual que b -->" + (a>=b));

        if ((a == b))
             {
            System.out.println("a es igual a b -->" + (a == b));
             } else
                 {
            System.out.println("a es diferente a b -->" + (a != b));
                 }

        if ((a<=b))
            {
            System.out.println("a es menor o igual que b -->" + (a<=b));
             } else
                {
            System.out.println("a es mayor o igual que b -->" + (a>=b));
                }

    }
}

Explicando los operadores lógicos

AND
Vamos a estar evaluando dos datos cuando dos variables son lógicas. Para que el resultado sea verdadero, ambas variables deben de ser verdaderas.

Como cuando analisas a tu crush y pasa la prueba de ser [email protected] e inteligente 😉.

OR
Solo hace falta que una de las variables sean true para que el resultado final sea verdadero.

Como cuando solo hiciste una de dos tareas pero es suficiente para pasar 😃.

NOT
Se encarga de negar el resultado de una variable. Si tu variable a es verdadera, pero tu la niegas utilizando !a, se convierte en falso.

Como cuando tienes unos ricos dulces pero les dices a todos que no tienes para no compartirlos 😈.

buen curso

😃

una pregunta chicos, que debo hacer para que no me compile el otro archivo anterior si no el de ahora? es que le doy compilar al nuevo archivo y me trae los resultados del anterior

Un tema muy importante porque se utiliza para evaluar los valores de las variables y poder modificar el flujo del sistema 💚

Cuando en una condición se tiene varios operadores AND (&&) y operadores OR (||) (eso si, contemplando la precedencia de operadores) el programa hace la validación de izquierda a derecha.

Por ejemplo, para la siguiente condición al detectarse que cond1 es FALSO, el sistema no evaluará cond2, cond3, y demás condiciones que existan; debido al “punto de quiebre” provodado por cond1.

boolean cond1 = false;
boolean cond2 = true;
boolean cond3 = true;
if (cond1 && cond2 && cond3 && ...) {
  // Acciones por realizar
}

Así mismo, si en vez de AND se usara OR, el sistema procedería a ejecutar el código que se encuentra dentro de la condición, sin importar las demás condiciones definidas.

boolean cond1 = true;
boolean cond2 = false;
boolean cond3 = false;
if (cond1 || cond2 || cond3 || ...) {
  // Acciones por realizar
}

Está bueno este curso. Sinceramente enseñan mucho mejor acá en Platzi que en mi instituto profesional, hice muy bien en invertir acá.

Aquí el ejemplo reducido. 😉
int a = 8;
int b = 10;

    if (a==b){
        System.out.println("Las variables son iguales");
    } else if (a>b){
        System.out.println("a es mayor que b");
    }   else {
        System.out.println("b es mayor que a");
    }

Sentencias aprendidas: if, else e else if

Puntes de clase

    int a = 8;
    int b = 5;

    //Estos son los operadores de asignacion
    System.out.println("a es = a b? -> " + (a == b));
    System.out.println("a es diferente a b? -> " + (a != b));

    //Y estos los operadores Relacionales
    System.out.println("a es meyor a b? -> " + (a > b));
    System.out.println("a es manor a b? -> " + (a < b));
    System.out.println("a es mayor o = a b? -> " + (a >= b));
    System.out.println("a es menor o = a b? -> " + (a <= b));

    if (a == b) {
        System.out.println("a es = a b?");

    }else if ((a != b) && (a < b)){
        System.out.println("a es diferente a b?");

    } else if (a > b) {
        System.out.println("a es mayor a b?");


    } else if (a < b) {
        System.out.println("a es menor a b?");

    } else if (a >= b) {
        System.out.println("a es mayor o igual a b?");

    } else if (a <= b) {
        System.out.println("a es menor o igual a b?");

Super!

Excelente la forma de manejar lo operadores logísticos en java

Logical Operators ! (NOT), && (AND), || (OR)
If you are learning to code or new to coding, you will be using logical operators, these are typically used with Boolean (logical) values. But you need to pay close attention to it, since && and || operators will return the value of the specified operand, so if the operand is using a non-Booleans value, the return will be a non-Boolean value.

Logical operators are used with any primitive value or object. Its result will be based in whether the value is truthy or falsy:

First, let’s identify that there are three logical operators in JavaScript: ! (NOT), && (AND), ||(OR) -represented with two vertical line symbols.

! (Logical NOT)

Using the ! operator in front of a value will convert it to a Boolean and return an opposite value. It means that a truthy value will return false, and a falsy will return true. Logical || (OR) is meant to manipulate boolean values only. This method is known as negation:

Example:

!true; // negating true returns false
<<false

!0; // 0 is a false value, so negating it returns true
<<true

Using double negation (!!) can help you to find if a value is truthy or falsy, specially when you are not an experienced coder and you need to verify, then you can first test out using this method and see if the value is truthy or falsy.

Example:

!! ‘ ’; // empty string value is false
<< false

!!“hello”;
<< true

!!3;
<< true

!!NaN;
<<False

!!“false”;
<< true

!!‘0’;  // Remember that a number 0 (zero) is false
<< true

Now, let’s define the operators && and || which represents the logical AND and OR logical operators.

Visual example:

// Logical AND operator
true  && true;  // true
true  && false; // false
false && true;  // false
false && false; // false

// Logical OR operator
true  || true;  // true
true  || false; // true
false || true;  // true
false || false; // false

&& (AND) Logical Operator

The logical operator is used with two or more values (operands), and only evaluates to true if all the operands are truthy. The value returned will be the last truthy value if they are all true, but it will return the first falsy value if at least one value is false.

Example:

const x = 7;
const y = 4;

(x < 10 && y > 1); // true 
(x < 10 && y < 1); // false

|| (OR) Logical Operator

The logical operator || (OR) also is used with two or more values, but it evaluates to true if any of the operands (values) are true, so only evaluates to false if both operands are falsy.

Example

const x = 7;
const y = 4;

(x == 5 || y == 5); // false 
(x == 7 || y == 0); // true
(x == 0 || y == 4); // true
(x == 7 || y == 4); // true
Conclusion

In JavaScript, && and || will not always return a Boolean value, but operators always will return the value of one of their operand expressions. And, using double negation !! your truthy and falsy values can be converted to Booleans.

Excelente lección. Y definitivamente muy util.

Me encantan las clases 😉

no funciono con la orden else if

Woow!

Operador Nombre Ejemplo
== igualdad a==b
!= Desigualdad a !=b
< Menor que a<b

mayor que a>b
<= menor o igual que a <= b
= Mayor o igual que a >=b
&& AND a&&b
|| OR a||b
! NOT !a

      int e=5;
      int y=7;
      int suma=e+y; 
  
      if (suma<4) {
          
          System.out.println("es factible");
      }else {
          
         suma=2*(e*y);
         
           System.out.println(suma);   
              
            if(suma>8){
                
               suma=e/y; 
                
            }  

Tengo una duda sobre el funcionamiento de ‘‘If else If’’’, ya que, en el ejemplo de esta clase al usarlos consecutivos sòlo muestra 1 impresiòn en pantalla partiendo del hecho que 3 ‘‘else if´’’ se cumplen. Entonces, ¿el funcionamiento de mencionada sentencia al encontrar la primera verdadera deja de ejecutar las consecutivas a esta? ¿Es entonces què existe una sentencia distinta que pueda mostrar ese lìmite de ‘‘else if’’? ¿Debe de anidarse de cierta manera? Espero su respuesta comunidad. Gracias.

public static void main(String[] args) {
/*
OPERADORES DE EQUIDAD
== IGUALDAD -------> A ES IGUAL A ----> B A==B
!= DIFERENCIA -------> A ES DIFERENTE A B —> A!=B

    RELACIONALES:
    <  MENOR QUE
    >  MAYOR QUE
    <= MENOR O IGUAL QUE
    >= MAYOR O IGUAL QUE

    OPERADORES LOGICOS: CON TABLAS DE VERDAD
    &&  AND:  DOS DATOS LOGICOS
    ||  OR
    !   NOT
    */
    int a = 8;
    int b = 5;
    System.out.println("OPERADORES DE ASIGNACION");
    System.out.println("A ES IGUAL a B "+ (a==b));
    System.out.println("A ES DIFERENTE de B "+ (a!=b));
    System.out.println(" ");
    System.out.println("OPERADORES DE RELACIONALES");
    System.out.println("A ES MAYOR a B "+ (a>b));
    System.out.println("A ES MENOR a B "+ (a<b));
    System.out.println("A ES MAYOR O IGUAL a B "+ (a>=b));
    System.out.println("A ES MENOR O IGUAL a B "+ (a<=b));

    // ifS ANIDADOS: VARIAS DONDICIONES:
    if ((a==b)){
        System.out.println("A ES IGUAL a B ");
    }
    else if((a!=b)){
        System.out.println("A ES DIFERENTE de B ");
    }
    if ((a>b)){
        System.out.println("A ES MAYOR a B ");
    }
    else if((a<b)){
        System.out.println("A ES MENOR a B ");
    }
    if ((a>=b)){
        System.out.println("A ES MAYOR O IGUAL a B ");
    }
    else if((a<=b)){
        System.out.println("A ES MENOR O IGUAL a B ");
    }
}

En el código los operadores de asignación son los operadores de equidad.

public static void main(String[] args) {
int a =8;
int b =9;
///OPERACIONES DE ACSINAION
System.out.println("el igual a "+(a == b));
System.out.println("el igual a "+(a != b));
///OPERACIONES LOGICAS
System.out.println(“a es mayor a b?”+(a > b));
System.out.println(“a es meno a b?”+(a < b));
System.out.println(“a es mayor igual a b?”+(a >= b));
System.out.println(“a es menor iguañ a b?”+(a <= b));
//SENTENCIA CON IF USNADO OPERADORES LOGICOS Y DE ASIGNACION
if((a == b)){
System.out.println("A ES IGUAL a B ");
}
else if((a!=b)){
System.out.println("A ES DIFERENTE de B ");
}
if((a > b)){
System.out.println("A ES MAYOR a B ");
}
else if((a<b)){
System.out.println("A ES MENOR A B ");

}

if((a >= b)){
System.out.println("A ES MAYOR IGUAL a B ");
}
else if((a<=b)){
System.out.println("A ES MENOR IGUAL A B ");
}
}
}

Buenisimo!!

Excelente clase de los operadores lógicos!

De pronto para ahorrar lineas, podemos declarar varias variables del mismo tipo en una sola linea:

int a =3, b= 5, Suma = a+b;

Simplemente separando cada variable con una coma (,)

Excelente clase 😃

Excelente clase instructora Anahí, con el uso de operadores lógicos, igualdad y relacionales junto a condicionales (if) anidados podemos establecer que una variable cumpla una serie de requisitos antes de que se le aplique un procedimiento.

En este ejemplo en particular no sólo “a” es diferente a “b”, sino también es mayor, y la afirmación “mayor o igual que” también es verdadera. Por lo cual nuestro programa debería imprimir un mensaje por cada uno de los tres casos. De igual forma, si “a” fuera menor que “b” debería imprimir tres mensajes. Esto lo he llevado a código aunque omito el uso de todos los operadores lógicos, lo cual es el propósito de ésta clase.

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

        int a= 8;
        int b= 5;


        if(a==b){
            System.out.println("a es igual a b");
        }else {
            System.out.println("a es diferente de b");
            if(a>b){
                System.out.println("a es mayor que b");
                System.out.println("a es mayor o igual b");
            }else{
                System.out.println("a es menor que b");
                System.out.println("a es menor o igual a b");
            }
        } //fin if-else

    } //Fin main
} //Fin Class

El famoso código espagueti jajaja 😛

buena clase

public class LogicOperations {
    public static void main(String[] args) {
        int a = 8;
        int b = 5;

        //operadores de equidad
        System.out.println("a es igual a b --> " + (a == b));
        System.out.println("a es diferente a b --> " + (a != b));

        //operadores relacionales
        System.out.println("a es mayor que b --> " + (a > b));
        System.out.println("a es menor que b --> " + (a < b));

        //con if anidados
        if (a == b) {
            System.out.println("a es igual a b");
        } else if (a != b) {
            System.out.println("a es diferente a b");
        } else if (a > b) {
            System.out.println("a es mayor a b");
        } else if (a < b) {
            System.out.println("a es menor a b");
        }
    }
}```

Todo claro.

To compare for equality we have == & .equal() , they both serve for comparing stuff, but they both do it in a different way…

==: this one compares references rather than values, which means that it compares the type of things. (conclusion: address comparison)

.equals(): compares the content of the variables rather than their type, which means it compares what they have inside. (conclusion: content comparison) (until I know, only works for strings)

<h3>Example</h3>

.equals():

String s1 = "foo";

if (s1.equals("foo")); {
	System.out.printf("'s1' var is equal to foo!\n");
} else {
	System.out.printf("'s1' var is not equal to foo \n");
}

//output
//'s1' var is equal to foo!\n

Un dato interesante es que cuando queremos evaluar una condición dentro de un (if( a ){ } como “a”) el if siempre es verdadero , la condicion en un if siempre se evalúa como verdadero. ahora esto cambia cuando usamos operadores logicos o booleans!!!
Se puede tener un sola variable y esta se evaluara como true

boolean isBlutoohEnabled = true;

    if (isBlutoohEnabled ) {
        System.out.println("se envio el archivo");
    }else {
        System.out.println("no se envio el archivo active el bluto");
    }
public class LogicOperations
{
    public static void main(String[] args)
    {
        int a = 8;
        int b = 5;
        //operadores de asignación
        System.out.println("a es igual a b? " + (a==b));
        System.out.println("a es diferente a b? " + (a!=b));

        //operadores relacionales
        System.out.println("a es menor a b? " + (a<b));
        System.out.println("a es mayor a b? " + (a>b));
        System.out.println("a es menor que  b? " + (a<=b));
        System.out.println("a es mayor que b? " + (a>=b));

        if (a==b){System.out.println("a es menor a b? ");}
        else if ((a!=b) && (a>b)){System.out.println("a es diferente a b y mayor " );}
        else if (a<b){System.out.println("a es menor a b? ");}
        else if (a>b){ System.out.println("a es mayor a b? ");}
        else if (a<=b){System.out.println("a es menor que  b? " );}
        else if (a>=b){System.out.println("a es mayor que b? ");}

        if ((a!=b) || (a>b)){System.out.println("a es diferente a b y mayor " );}
        
    }
}```

Todo clarísimo. Gracias

Aquí está un aporte, una demostración de las expresiones booleanas:

public class BooleanClass
{
    public static void main(String[] args)
    {
        boolean A = true;
        boolean B = true;

        //Compuerta AND
        System.out.println("Compuerta AND");
        System.out.println("");
        System.out.println("0 0  = "+(!A && !B));
        System.out.println("0 1  = "+(!A && B));
        System.out.println("1 0  = "+(A && !B));
        System.out.println("1 1  = "+(A && B));
        System.out.println();
        
        //Compuerta OR
        System.out.println("Compuerta OR");
        System.out.println("");
        System.out.println("0 0  = "+(!A || !B));
        System.out.println("0 1  = "+(!A || B));
        System.out.println("1 0  = "+(A || !B));
        System.out.println("1 1  = "+(A || B));
    }
}

Por si acaso, alguien necesita buscar info sobre este tema, también se conoce como tabla de verdad.
Son usadas tanto en informática, como la electrónica (por razones obvias).

Se deberia desarrollar un proyecto asi se aprende mejor…

Anahi es una gran instructora == True

Operadores lógicos explicados de la mejor manera que pude entenderlo fue éste

aprendiendo en clase

public class LogicOperation {
    public static void main(String[] args) {
        int a=8;
        int b=5;
        System.out.println("si a es igual a b ->"+ (a==b));
        System.out.println("a es diferente a b ->" +(a!=b));
        //Operadores relaconales
        System.out.println("si a es menor a b ->"+ (a<b));
        System.out.println("a es mayor a b ->" +(a>b));
        System.out.println("si a es menor igual a b ->"+ (a<=b));
        System.out.println("a es mayor igual a b ->" +(a>=b));

        if(a==b){
            System.out.println("si a es igual a b ->"+ (a==b));

        }else if(a!=b){
            System.out.println("a es diferente a b ->" +(a!=b));
        }
        else if(a<b){
            System.out.println("si a es menor a b ->"+ (a<b));
        }
        else if(a>b){
            System.out.println("si a es menor a b ->"+ (a<=b));
        }
        else if(a>=b){
            System.out.println("si a es mayor igual a b ->"+ (a>=b));

        }else if(a<=b){
            System.out.println("si a es menor igual a b ->"+ (a<=b));
        }
        else {
            System.out.println("no esta definido");
        }


    }
}

Cuantos dolores de cabeza me hubiese ahorrado si hubiera conocido el significa de los operadores logicos cuando estuve estudiando c++ en la universidad.

![](

Los operadores lógicos devuelven true o false, ya sea con los operadores de equidad o operadores relacionales, podemos comparar dos o mas condiciones al mismo tiempo con el operador lógico &&(and) y el operador lógico || (or), para que && sea “true” todas las condiciones deben ser verdaderas y parar que || sea “true” al menos una condición debe ser verdadera,y con el operador lógico !(not) negamos la condición.

excelente explicación




Me gusto esta clase, en donde de una manera muy sencilla se comprende el concepto de las tablas de verdad y como se asocian a las sentencias.

public class LogicOperators {
    public static void main(String[] args) {
        int a = 8;
        int b = 5;

        //operdores de asignacion
        System.out.println(" a es igual a b? -> " + (a ==b ));
        System.out.println(" a es diferente  de b? -> " + (a != b));

        //operadores relacionales
        System.out.println(" a es mayor a b? -> " + ( a > b));
        System.out.println(" a es menor a b? -> " + ( a < b));
        System.out.println(" a es mayor o igual a b? -> " + ( a >= b));
        System.out.println(" a es menor o igual a b? -> " + ( a <= b));

        if(a==b){
            System.out.println("a es igual a b");
        }else if(a != b){
            System.out.println("a es diferente de b");
        }else if(a > b){
            System.out.println("a es mayor  a b");
        }else if(a < b){
            System.out.println("a es menor a b");
        }else if(a >= b){
            System.out.println("a es moyor o igual a b");
        }else if(a <= b){
            System.out.println("a es menor o igual a b");
        }

    }
}```

Tantas clases de matematica discreta hicieron que me aprendiera las tablas de verdad…