Na „Drodze programisty” poznaliśmy już czym są zmienne oraz jakie mogą mieć typy. Wiemy, że są zmienne typu liczbowego całkowitego oraz zmienne typu tekstowego. Dziś poznamy kolejny typ: zmienne logiczne Boolean.

Określa się je jako zmienne typu logicznego, bo przechowują informacje tylko o dwóch wartościach logicznych: PRAWDA (true) / FAŁSZ (false). Jeżeli przypomnisz sobie reprezentację zmiennej liczbowej w pamięci i zapis jej za pomocą systemu dwójkowego na wielu bitach, to dla zmiennych Boolean potrzebujemy tylko jednego bitu. Jeżeli jest 0, to jest to FAŁSZ a jeżeli 1 to PRAWDA.

Definiujemy je bardzo podobnie do innych typów (używamy typu o nazwie Boolean):

public class ZmienneLogiczne {
    public static void main(String args[]) {
        Boolean prawda = true;
        Boolean falsz = false;

        System.out.println("Prawda ma wartosc " + prawda);
        System.out.println("Falsz ma wartosc " + falsz);
    }
}

l0

Możemy używać nazwy typu pisanej z dużej litery (Boolean) lub z małej (boolean) lub formy skróconej (bool). Dostępne opcje różnią się od języka w którym piszemy program. Zwracaj uwagę na komunikaty jakie daje Ci kompilator podczas kompilowania programu 🙂

Na zmiennych logicznych możemy przeprowadzać różne operacje. Obowiązują tutaj matematyczne zasady tak zwanej algebry Boolowskiej. Mając do dyspozycji dwie zmienne typu logicznego możemy wykonać na nich operację i uzyskać trzecią wynikową zmienną (również typu logicznego).

Mamy do dyspozycji takie operacje:

Działanie Ang. Operator Kiedy wynik działania będzie prawdą
Suma AND && Obie wartości muszą być prawdą
Iloczyn OR || Przynajmniej jedna wartość musi być prawdą
Ekskluzywny iloczyn XOR != Dokładnie jedna wartość musi być prawdą
Porównanie EQUALS == Obie wartości są takie same
Negacja NOT ! Wartość jest fałszem

A jaki jest wynik takich operacji? W tabelkach poniżej widać dokładnie jak działa logika Boolowska.

AND : obie wartości muszą być prawdą

x y x AND y
fałsz fałsz fałsz
fałsz prawda fałsz
prawda fałsz fałsz
prawda prawda prawda
public class ZmienneLogiczne {
    public static void main(String args[]) {

        System.out.println("x AND y");
        System.out.println(false && false);
        System.out.println(false && true);
        System.out.println(true && false);
        System.out.println(true && true);
    }
}

l1

OR : przynajmniej jedna wartość musi być prawdą

x y x OR y
fałsz fałsz fałsz
fałsz prawda prawda
prawda fałsz prawda
prawda prawda prawda
public class ZmienneLogiczne {
    public static void main(String args[]) {

        System.out.println("x OR y");
        System.out.println(false || false);
        System.out.println(false || true);
        System.out.println(true || false);
        System.out.println(true || true);
    }
}

l_OR

XOR : dokładnie jedna wartość musi być prawdą

x y x XOR y
fałsz fałsz fałsz
fałsz prawda prawda
prawda fałsz prawda
prawda prawda fałsz
public class ZmienneLogiczne {
    public static void main(String args[]) {

        System.out.println("x XOR y");
        System.out.println(false != false);
        System.out.println(false != true);
        System.out.println(true != false);
        System.out.println(true != true);
    }
}

l_XOR

EQUALS : obie wartości muszą być takie same

x y x EQUALS y
fałsz fałsz prawda
fałsz prawda fałsz
prawda fałsz fałsz
prawda prawda prawda
public class ZmienneLogiczne {
    public static void main(String args[]) {

        System.out.println("x EQUALS y");
        System.out.println(false == false);
        System.out.println(false == true);
        System.out.println(true == false);
        System.out.println(true == true);
    }
}

l_EQ

NOT : zaprzeczenie wartości

x NOT x
fałsz prawda
prawda fałsz
public class ZmienneLogiczne {
    public static void main(String args[]) {

        System.out.println("NOT x");
        System.out.println(!false);
        System.out.println(!true);
    }
}

l_not

Bardzo przydatnym operatorem jest operator porównania (==). Spotykamy się z nim po raz pierwszy, więc może się mylić z operatorem przypisania, który stosujemy już od dawna (=). Operator porównania jest operatorem dwuargumentowym to znaczy, że potrzebuje dwóch argumentów (po lewej i prawej stronie). Porównuje ten po lewej z tym po prawej i jeżeli są sobie równe, to zwraca wartość logiczną PRAWDA (true). Jeżeli natomiast są od siebie różne to zwraca wartość FAŁSZ (false). Wynik tej operacji (i każdej innej operacji logicznej) możemy przypisać do kolejnej zmiennej logicznej.

Na koniec dodam, że dla operatorów logicznych obowiązują pewne zasady, tak samo jak dla operatorów matematycznych. Ważna jest kolejność wykonywania poszczególnych działań. Weźmy na przykład takie matematyczne działanie (jakiś czas temu bardzo popularne na Facebooku:)):

1 + 2 * 3 = x

Ile wynosi x? Otóż idąc po kolei od lewej do prawej wykonalibyśmy takie działania:

  • 1 + 2 = 3
  • 3 * 3 = 9

I niestety podalibyśmy błędną odpowiedź. Dla działań matematycznych mnożenie (*) ma większy priorytet niż dodawanie (+) i zostanie wykonane w pierwszej kolejności:

  • 2 * 3 = 6
  • 1 + 6 = 7

I to właśnie 7 jest poprawną odpowiedzią.

Dla operatorów logicznych również mamy odpowiednią kolejność działań. Weźmy takie wyrażenie i sprawdźmy co zostanie wypisane na ekran:

System.out.println(false != false && true != true);

Idąc od lewej do prawej wykonalibyśmy takie działania:

  • false != false daje nam false
  • false && true daje nam false
  • false != true daje nam true

Wychodzi nam true i jak zapewne się domyślasz, jest to odpowiedź błędna. Otóż operator XOR (!=) ma większy priorytet niż operator AND (&&) oraz OR (||). Poprawna kolejność będzie taka:

  • false != false daje nam false
  • true != true daje nam false
  • false && false daje nam false

Czyli poprawną odpowiedzią będzie false. Dużo łatwiej to sobie wyobrazić stosując odpowiednie nawiasy z zachowaniem kolejności działań:

System.out.println( (false != false) && (true != true) );

Od razu lepiej 🙂 A kolejność działań operatorów logicznych przedstawia się następująco:

  1. NOT (!)
  2. EQUALS (==)
  3. XOR (!=)
  4. AND (&&)
  5. OR (||)

Czasami można się zapomnieć i błędnie zinterpretować działanie. Dlatego najbezpieczniej stosować nawiasy.

Poza tym, że zmienne typu logicznego pozwalają na ciekawą zabawę z kolejnością działań to także wykorzystujemy je między innymi do sterowania logiką naszego programu. Na przykład, jeżeli chcemy wyświetlić jakiś napis tylko jeżeli obecny miesiąc to kwiecień, to skorzystamy właśnie z operatora porównania oraz instrukcji sterującej. O czym dowiemy się w kolejnym poście na „Drodze programisty”.

Jedna uwaga do wpisu “Zmienne typu logicznego

Skomentuj

Wprowadź swoje dane lub kliknij jedną z tych ikon, aby się zalogować:

Logo WordPress.com

Komentujesz korzystając z konta WordPress.com. Wyloguj /  Zmień )

Zdjęcie na Google

Komentujesz korzystając z konta Google. Wyloguj /  Zmień )

Zdjęcie z Twittera

Komentujesz korzystając z konta Twitter. Wyloguj /  Zmień )

Zdjęcie na Facebooku

Komentujesz korzystając z konta Facebook. Wyloguj /  Zmień )

Połączenie z %s