Ett föreläsningsutdrag med en mentor som en del av Codegym University-kursen. Anmäl dig till hela kursen.

"Hej, Amigo. Låt mig berätta om en ny datatyp. Den booleska . Variabler av denna typ kan bara ha två värden: sant och falskt . "

"Hur använder vi det?"

"Denna typ används implicit på många ställen. Precis som varje additionsoperation ger ett tal, är resultatet av en jämförelse ett booleskt värde . Här är några exempel:"

Koda Förklaring
1 
boolean m;
 Dessa två uttryck är likvärdiga. Standardvärdet för en boolesk variabel är false .
2 
boolean m = false;
3 
if (a > b)
    System.out.println(a);
 Resultatet av jämförelsen (antingen sant eller falskt ) kommer att tilldelas variabeln m. Villkoret är uppfyllt om uttrycket evalueras till sant .
4 
boolean m = (a > b);
if (m)
    System.out.println(a);
5 
boolean m = (a > b);
if (m == true)
    System.out.println(a);
 Det finns inget behov av att jämföra en logisk ( boolesk ) variabel med sant eller falskt . Resultatet av jämförelsen blir en boolean som matchar den andra variabeln. Till exempel, true == true evalueras till sant; true == false utvärderas till falskt .
6 
boolean m = (a > b);
if (m)
    System.out.println(a);
Java university

"Fler exempel:"

Koda Förklaring
1 
public boolean isALessThanB (int a, int b)
{
    if (a < b)
        return true;
    else
        return false;
}
 Denna metod verifierar att nummer a är mindre än nummer b.

Här är fyra likvärdiga jämförelser. Den sista är den mest kompakta och korrekta. Försök alltid att använda kompakt notation.
2 
public boolean isALessThanB (int a, int b)
{
   boolean m = (a < b);
    if (m)
        return true;
    else
        return false;
}
3 
public boolean isALessThanB (int a, int b)
{
    boolean m = (a < b);
    return m;
}
4 
public boolean isALessThanB (int a, int b)
{
    return a < b;
}

"Tänk om jag vill skriva 0<a<b?"

"Java har inte en jämförelseoperator som tar tre operander. Så du skulle behöva göra det så här: (0<a) OCH (a<b) ."

"Skriver jag ordet OCH?"

"Vänta. Jag ska förklara det. Java har tre logiska operatorer: AND , OR och NOT . Du kan använda dem för att konstruera villkor av varierande komplexitet. Du kan bara använda dessa operatorer med booleska uttryck. Så du kan inte skriva ( a+1) OCH (3) , men (a>1)OCH (a<3) är OK."

" NOT- operatorn är unär: den påverkar endast uttrycket till höger. Det är mer som ett minustecken före ett negativt tal snarare än ett multiplikationstecken mellan två tal."

"Du kan utföra olika operationer på booleska (logiska) variabler."

"Som vad?"

"Låt oss ta en titt:"

Logisk operatör Java-notation Uttryck Resultat
OCH && sant  &&  sant Sann
sant &&  falskt falsk
falskt  &&  sant falsk
falskt && falskt falsk
ELLER || sant || Sann Sann
sant || falsk Sann
falskt || Sann Sann
falskt || falsk falsk
INTE ! ! Sann falsk
! falsk Sann
Vanliga kombinationer och uttryck m && !m falsk
m || !m Sann
! (a && b) !a || !b
! (a || b) !a && !b

"Kan du ge mig fler exempel?"

"Säker:"

Java-notation Logisk notation
(a<3) && (a>0) (a < 3) OCH (a>0)
(a>10) || (a<100) (a>10) ELLER (a<100)
(a<b) && (!(c<=d)) (a<b) OCH (INTE (c<=d))

"Nu, gör några uppgifter."