Operatory logiczne w Javie

Cześć, w poprzedniej lekcji kursu poznałeś instrukcje warunkoweif, else if, switch oraz operator ? (trójargumentowy). Przykłady były naprawdę suche, dzisiaj dzięki nowemu zagadnieniu – operatorach logicznych i porównawczych w języku java – dowiesz się do czego mogą być przydatne instrukcje warunkowe.

Jeżeli jakieś zagadnienie dla Ciebie z poprzedniej lekcji kursu jest niejasne, to nie zaczynaj tej lekcji tylko jeszcze raz postaraj się zrozumieć instrukcje warunkowe. Mając wiedzę na ten temat dopiero wtedy wyciągniesz 100% z tej lekcji! W razie problemów napisz komentarz pod lekcją.

Operatory porównawcze

Operatory porównawcze służą głównie do wszelkiego porównywania wartości, dzięki jednemu z operatorów możemy np. sprawdzić czy dwie liczby są równe. Ewentualnie sprawdzić, która z podanych liczb jest większa. Przejdźmy więc do samych operatorów.

Operator ==

Operator == będzie służył nam do sprawdzania czy dwie podane wartości są sobie równe. Możemy zbudować naprawde bardzo dużo fajnych warunków, za pomocą tego operatora.

Na początku sprawdźmy sobie czy liczba podana przez użytkownika jest równa 10.

package com.company;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in); // Scanner do wczytywanie z klawiatury
        int numberFromUser = 0; //tu będzie wczytana wartość od użytkownika, na początku ustawimy 0, żeby później przypadkiem nie porównywać do nulla

        System.out.println("Podaj wartość całkowitą: ");
        numberFromUser = scanner.nextInt(); // wczytanie liczby
        
        if(numberFromUser==10){
            System.out.print("Podana liczba jest równa 10!");
        }else{
            System.out.print("Podana liczba jest różna od 10!");
        }


    }
}

Program jest prosty, wczytuje liczbę od użytkownika i sprawdza czy jest równa 10. Trochę abstrakcyjne, zastosujmy tę metodę do obsługi dzielenia dwóch liczb. Już wiesz do czego?

package com.company;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in); // Scanner do wczytywanie z klawiatury
        float dzielna;
        float dzielnik;

        System.out.println("Podaj dzielną: ");
        dzielna = scanner.nextFloat(); // wczytanie liczby

        System.out.println("Podaj dzielnik: ");
        dzielnik = scanner.nextFloat(); // wczytanie liczby

        if(dzielnik==0){
            System.out.print("Stop, stop, stop! Nie można dzielić przez 0!");
        }else{
            System.out.print("Wynik dzielenia to: " + dzielna / dzielnik);
        }


    }
}

Jak widzisz instrukcja warunkowa ratuje nas tutaj przed złośliwym użytkownikiem. Użyjmy może teraz operatora matematycznego, niech to będzie modulo. Za pomocą tego operatora sprawdźmy czy podana liczba jest podzielna przez 3.

Liczba będzie podzielna przez 3, jeżeli wynik modulo przez 3 będzie równy 0, czyli liczba podzielona przez 3 nie da nam reszty!

package com.company;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in); // Scanner do wczytywanie z klawiatury
        int numberFromUser = 0;

        System.out.println("Podaj liczbę całkowitą: ");
        numberFromUser = scanner.nextInt(); // wczytanie liczby


        if(numberFromUser%3 == 0){
            System.out.print("Liczba jest podzielna przez 3.");
        }else{
            System.out.print("Liczba nie jest podzielna przez 3.");
        }


    }
}

I o to w taki prosty sposób możemy sprawdzić czy liczba jest podzielna przez 3. 😉

Operator !=

Operator != niewiele się różni od poprzedniego operator ==. Tak jak poprzedni operator nam sprawdzał czy podane wartości są równe, to operator != sprawdza czy dwie wartości są różne! Przykładów będzie już mniej, z takiego względu, że operator nie różni się wiele od poprzedniego.

Sprawdźmy sobie czy podana liczba jest zerem, za pomocą operatora !=.

package com.company;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in); // Scanner do wczytywanie z klawiatury
        int numberFromUser = 0;

        System.out.println("Podaj liczbę całkowitą: ");
        numberFromUser = scanner.nextInt(); // wczytanie liczby


        if(numberFromUser != 0){
            System.out.print("Liczba nie jest zerem");
        }else{
            System.out.print("Tak, tak to jest zero!");
        }


    }
}

Jak zauważyłeś to przykłady z poprzedniego operatora == można łatwo zamienić na operator !=. Wystarczy tak naprawdę tylko zmienić operator i wiadomości w blokach if i else.

Operator > i >=

Wrzuciłem te dwa operatory razem, ze względu, że różnią się niewiele. Jeden z nich sprawdza, czy wartość jest większa, drugi zaś czy jest większa bądź równa. Przejdźmy lepiej do implementacji tych operatorów.

package com.company;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in); // Scanner do wczytywanie z klawiatury
        int numberFromUser = 0;

        System.out.println("Podaj liczbę większą od 10: ");
        numberFromUser = scanner.nextInt(); // wczytanie liczby


        if(numberFromUser > 10){
            System.out.print("Podałeś dobrą wartość.");
        }else{
            System.out.print("Stop, stop, miałeś podać liczbę większą od 10!");
        }


    }
}

Jak widzisz za pomocą tego operatora łatwo określić z jakiego przedziału jest dana liczba.

Użycie operatora >= będzie wyglądało następującą dla sytuacji, gdy chcemy aby użytkownik podał liczbę naturalną (czyli liczby dodatnie z zerem).

 

package com.company;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in); // Scanner do wczytywanie z klawiatury
        int numberFromUser = 0;

        System.out.println("Sprawdź czy liczba jest liczbą naturalną: ");
        numberFromUser = scanner.nextInt(); // wczytanie liczby


        if(numberFromUser >= 0){
            System.out.print("Gratulacje! Ta liczba jest naturalna.");
        }else{
            System.out.print("To nie jest liczba naturalna!");
        }


    }
}

Czyli jeżeli w naszym programie użytkownik poda wartość większą bądź równą 0 to wyświetli mu się oczywiście komunikat: „Gratulacje! Ta liczba jest naturalna.”. Mam nadzieję, że na razie wszystko rozumiesz? 😉

Operator < i <=

Zasada tych operatorów jest znowu odwrotna, sprawdza on czy wartość jest mniejsza od innej lubmniejsza bądź równa od innej. Jeżeli zrozumiałeś zasadę działania poprzedniego, to umiesz i te operatory. Przekształćmy sobie ostatnie przykłady, aby używały one operatorów < i <=.

package com.company;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in); // Scanner do wczytywanie z klawiatury
        int numberFromUser = 0;

        System.out.println("Podaj liczbę większą od 10: ");
        numberFromUser = scanner.nextInt(); // wczytanie liczby


        if(numberFromUser < 11){
            System.out.print("Stop, stop, miałeś podać liczbę większą od 10!");

        }else{
            System.out.print("Podałeś dobrą wartość.");
        }


    }
}

Jak widzisz warunek się tylko trochę różni, jeżeli chcemy, aby liczba była większa od 10, to możemy również sprawdzić czy podana liczba jest mniejsza od 11, wtedy blok else będzie odpowiedzialny za liczby większe od 10. Sytuacja jest zapisana odwrotnie do poprzedniego przykładu. 😉

Przekształćmy również przykład dla operator <=.

package com.company;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in); // Scanner do wczytywanie z klawiatury
        int numberFromUser = 0;

        System.out.println("Sprawdź czy liczba jest liczbą naturalną: ");
        numberFromUser = scanner.nextInt(); // wczytanie liczby


        if(numberFromUser <= -1){
            System.out.print("To nie jest liczba naturalna!");
        }else{
            System.out.print("Gratulacje! Ta liczba jest naturalna.");
        }


    }
}

Ponownie musimy zmienić wartości, aby wykluczyć zero, które jest liczbą naturalną.

Jak widzisz wygodniejsze i czytelniejsze jest raczej stosowanie operatorów > i >= w tych przykładach, ponieważ potrzebujemy liczb naturalnych. Gdybyśmy zaś potrzebowali liczb całkowitych ujemnych to czytelniejsze byłoby zastosowanie operatorów < i <=.

Operatory logiczne

Przejdźmy teraz do operatorów logicznych, pozwalają one nam negować warunki oraz tworzyć bardziej skomplikowane (czyli łączyć warunki ze sobą).

Operator negacji !

Operator negacji jest stosowany do zanegowania czyli „odwrócenia” wartości logicznej. Prosty przykład: stosując negację na prawdę otrzymujemy zawsze fałsz. I vice versa. Negację stosuje się poprzez użycie wykrzynika „!”.

Zapiszmy naprawdę prosty przykład jak możemy zastosować negację.

package com.company;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        

       if(!false){
           System.out.print("Jasne, że się to wyświetli!");
       }else{
           System.out.println("To nigdy się nie wyswietli!");
       }

    }
}

Wyświetli się oczywiście napis z bloku if, ponieważ zapis !false, jest równy zawsze true, więc warunek w nawiasie if jest spełniony.

Zapiszmy teraz troszkę bardziej skomplikowany warunek. Będziemy chcieli sprawdzić czy podana liczba nie jest podzielna przez 2. Łatwo sprawdzić to właśnie za pomocą negacji.

package com.company;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        int numberFromUser = 0;

        numberFromUser = scanner.nextInt();

       if(!(numberFromUser%2 == 0)){
           System.out.print("Liczba nie jest podzielna przez 2.");
       }else{
           System.out.println("Liczba jest podzielna przez 2.");
       }

    }
}

Zaczynamy od sprawdzania czyli liczba jest podzielna przez dwa, a ze względu, że chcemy liczbę niepodzielną przez dwa to po prostu negujemy to wyrażenie.

Operator OR ||

Operator OR jest zapisywany jako dwie rurki (kreski pionowe). Służy on do łączenia wyrażeń i oznacza on lub. Czyli wystarczy, aby choć jeden warunek był spełniony, aby całe wyrażenie było prawdą. Poniżej przedstawiam tablicę prawdy operacji OR.

X Y F
0 0 0
0 1 1
1 0 1
1 1 1

X i Y są tak wyrażeniami, 1 oznacza prawdę0 oznacza fałsz. Analizując tabelę zauważamy, że wystarczy jedna prawda, aby wyrażenie (F) miało również wartość true.

Przejdźmy do przykładu, sprawdźmy czy podana liczba jest podzielna przez 2 lub podzielna przez 3.

package com.company;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        int numberFromUser = 0;

        numberFromUser = scanner.nextInt();

       if(numberFromUser%2 == 0 || numberFromUser%3 == 0){
           System.out.print("Liczba jest podzielna przez 2 lub przez 3.");
       }else{
           System.out.println("Nie wiem!");
       }

    }
}

Tak jak widać, warunek będzie sprawdzony gdy liczba będize podzielna przez 2 lub 3. Tak naprawdę nie wiemy w tym przypadku, przez co tak naprawdę liczba jest podzielna, ale mamy pewność, że liczba jest podzielna albo przez 2, albo przez 3.

Operator AND &&

Operator AND oznacza się dwoma ampersantami. Możliwe, że spotkałeś się w języku angielskim z użyciem ampersanta jako słówka and. I to samo oznacza w programowaniu, jednak jak działa? Działa on tak, że wszystkie warunki muszą być prawdziwe, aby całe wyrażenie było prawdą. Poniżej jest tabela prawdy dla operacji AND.

X Y F
0 0 0
0 1 0
1 0 0
1 1 1

Tak jak napisałem, wyrażenie F przyjmuje true, tylko wtedy, gdy X i Y są także true. Przejdźmy może do prostego przykładu, modyfikując lekko poprzedni.

package com.company;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        int numberFromUser = 0;

        numberFromUser = scanner.nextInt();

       if(numberFromUser%2 == 0 && numberFromUser%3 == 0){
           System.out.print("Liczba jest podzielna przez 6.");
       }else{
           System.out.println("Nie wiem!");
       }

    }
}

Dzięki użyciu operatora &&, mamy pewność, że liczba jest podzielna przez 2 i 3. Z prostej matematyki wynik również, że liczba też podzielna przez iloczyn jej podzielników tzn. 2*3 = 6.

Wnioskując operatora && używamy, gdy chcemy mieć pewność, że każdy warunek został spełniony.

Operator XOR ^

Operator XOR jest zapisywany jako daszek (^). Jest to już operator wbudowany w język, jeżeli chcemy użyć jego właściwości możemy również zastosować operator !=. Poniżej przedstawię Ci tabelę prawdy operator XOR.

X Y F
0 0 0
0 1 1
1 0 1
1 1 0

Jak widzisz wyrażenie F jest prawdą, tylko wtedy gdy tylko jedno jedno wyrażenie jest prawdą! Więcej o tej operacji możesz przeczytać na wikipedii.

Zrób to samo

Po dzisiejszej lekcji jest przygotowane kilka interesujących zadań.

  1. Sprawdź czy liczba podana przez użytkownika mieści się w przedziale (0; 20) (nawiasy okrągłe tzn. że liczby nie należą do przedziału)
  2. Sprawdź czy podana liczba jest podzielna przez 5 oraz mieści się w przedziale [100;200] (nawiasy kwadratowe tzn. że liczby należą do danego przedziału)
  3. Niech użytkownik wpiszę 10 liczb. Twoim zdaniem jest policzenie ile liczb jest podzielnych przez 2, ile podzielnych przez 3. Wynik wypisz na ekran.

Zakończenie

Jak co lekcję, gorąco zachęcam Cię do rozwiązania ww. zadań, abyś miał pewność, że w 100% rozumiesz lekcję. Pamiętaj, że programowanie to głównie praktyka, dlatego nie czytaj tylko książek, artykułów – tylko pracuj z kodem!

Jeżeli jakieś zagadnienie było niezrozumiałe lub gdzieś popełniłem błąd to napisz o tym w komentarzu.