Niniejsza lekcja to Kurs Java #5 Operatory matematyczne i logiczne. W piątej części kursu Java zagłębimy się w świat operatorów – podstawowych narzędzi, bez których trudno wyobrazić sobie jakikolwiek program. Dowiesz się, jak działa dodawanie, odejmowanie, mnożenie czy dzielenie w Javie, oraz jak używać operatorów porównania i logicznych do podejmowania decyzji w kodzie. To właśnie one pozwalają programowi „myśleć” i reagować na różne sytuacje.
Wprowadzenie
Zanim przejdziemy do bardziej złożonych konstrukcji programistycznych, warto poznać symbole, które pozwalają na wykonanie operacji na jednej, dwóch lub więcej wartościach (operandach). To dzięki nim możemy dodawać liczny, porównywać wartości, przypisywać dane do zmiennych, czy sterować przepływem logiki w programie.
Operatory arytmetyczne
Służą do wykonywania podstawowych działań matematycznych na liczbach typu: int, double i float.
| OPERATOR | OPIS | PSEUDOKOD |
| + | dodawanie | a = 3 + 7 a = 10 |
| – | odejmowanie | b = 10 – 4 b = 6 |
| * | mnożenie | c = 2 * 3 c = 6 |
| / | dzielenie | d = 8 / 2 d = 4 |
| % | modulo (reszta z dzielenia) | e = 10 % 3 e = 1 |
Przykład:
public class OperatoryArytmetyczne {
public static void main(String[] args) {
int a = 2;
int b = 7;
int c = 3;
int add = a + b;
int sub = b - a;
int mult = a * b;
int div = b / a;
int mod = b % c;
System.out.println("Dodawanie: " + add);
System.out.println("Odejmowanie: " + sub);
System.out.println("Mnozenie: " + mult);
System.out.println("Dzielenie: " + div);
System.out.println("Modulo: " + mod); //reszta dzielenia, 7 % 3 daje 1, bo 7 dzieli się przez 3 dwa razy, a reszta to 1.
}
}
Operatory porównania
Umożliwiają porównanie dwóch wartości — często używane w instrukcjach warunkowych. Zwracają one wynik typu boolean.
| OPERATOR | OPIS | PSEUDOKOD |
| == | równość | a == b |
| != | nierówność | a != b |
| > | większe niż | a > b |
| < | mniejsze niż | a < b |
| >= | większe lub równe | a >= b |
| <= | mniejsze lub równe | a <= b |
Przykład:
public class OperatoryPorownania {
public static void main(String []args){
int a = 12;
int b = 5;
System.out.println("a == b " + (a == b)); //false
System.out.println("a != b " + (a != b)); //true
System.out.println("a > b " + (a > b)); //true
System.out.println("a < b " + (a < b)); //false
System.out.println("a >= b " + (a >= b)); //true
System.out.println("a <= b " + (a <= b)); //false
}
}
Operatory logiczne
Używane do łączenia wielu warunków logicznych.
| OPERATOR | OPIS | PSEUDOKOD |
| && | i (AND) | a > 5 && a < 10 |
| || | lub (OR) | a > 5 || a < 10 |
| ! | negacja (NOT) | !(a == 10) |
Przykład:
public class OperatoryLogiczne {
public static void main(String[] args){
boolean a = true;
boolean b = false;
System.out.println("a && b " + (a && b)); //false - oba muszą być true
System.out.println("a || b " + (a || b)); //true - wystarczy jedno true
System.out.println("!a " + (!a)); //false - negacja: true lub false
System.out.println("!b " + (!b)); //true - negacja false lub true
}
}
Operatory przypisania
Służą do przypisywania wartości do zmiennych.
| OPERATOR | OPIS | PSEUDOKOD |
| = | przypisanie | x = 10 |
| += | dodanie i przypisanie | x += 5 (czyli x = x + 5) |
| -= | odjęcie i przypisanie | x -= 2 |
| *= | mnożenie i przypisanie | x *= 3 |
| /= | dzielenie i przypisanie | x /= 2 |
| %= | modulo i przypisanie | x %= 3 |
Przykład:
public class OperatoryPrzypisania{
public static void main (String[] args){
int a = 10; //oryginalne przypisanie
System.out.println("a = " + a); //10
a += 5; //a = a + 5
System.out.println("a += 5 => " + a); //15
a -= 3; //a = a - 3
System.out.println("a -= 3 => " + a); //12
a *= 2;
System.out.println("a *= 2 => " + a); //24
a /=4;
System.out.println("a /= 4 => " + a); //6
a %=4;
System.out.println("a %= 4 => " + a); //2
}
}
Operatory inkrementacji i dekrementacji
Zwiększają lub zmniejszają wartość zmiennej o 1.
| OPERATOR | OPIS | PSEUDOKOD |
| ++ | inkrementacja | x++ x = x + 1 |
| – | dekrementacja | x– x = x – 1 |
Przykład:
public class OperatoryInkrementacjiDekrementacji {
public static void main(String[] args) {
int a = 5;
System.out.println("Początkowa wartość a: " + a);
// POST-inkrementacja: najpierw używa wartości, potem zwiększa
System.out.println("a++: " + (a++)); // wypisze 5, a stanie się 6
System.out.println("Po a++ a = " + a); // 6
// PRE-inkrementacja: najpierw zwiększa, potem używa wartości
System.out.println("++a: " + (++a)); // zwiększy do 7 i wypisze 7
// POST-dekrementacja
System.out.println("a--: " + (a--)); // wypisze 7, a stanie się 6
System.out.println("Po a-- a = " + a); // 6
// PRE-dekrementacja
System.out.println("--a: " + (--a)); // zmniejszy do 5 i wypisze 5
}
}
Operator warunkowy (ternarny)
Jest to jednolinijkowa forma warunku, która działa według schematu:
wynik = (warunek) ? wartość_jeśli_true : wartość_jeśli_false;
Skrócona wersja instrukcji if-else (Instrukcje warunkowe)
Przykład:
public class OperatorWarunkowy {
public static void main(String[] args) {
int liczba = 7;
String wynik = (liczba % 2 ==0) ? "parzysta" : "nieparzysta";
System.out.println("Liczba " + liczba + " jest " + wynik + ".");
}
}
Operatory bitowe (zaawansowane)
Działają bezpośrednio na bitach liczb całkowitych (np. int, long). Umożliwiają manipulację poszczególnymi bitami liczby binarnej.
| OPERATOR | OPIS | PSEUDOKOD |
| & | AND bitowy – 1 tylko jeśli oba bity są 1 | a & b Porównaj bity a i b: 1 & 1 = 1, inaczej 0 |
| \| | OR bitowy – 1 jeśli przynajmniej jeden bit to 1 | a | b0 | 1 = 1, 1 | 1 = 1 |
| ^ | XOR bitowy – 1 jeśli bity są różne | a ^ b1 ^ 0 = 1, 1 ^ 1 = 0 |
| ~ | NOT bitowy – negacja każdego bitu | ~a~0101 = 1010 (dla intów: zwraca -a – 1) |
| << | Przesunięcie w lewo – mnożenie przez 2ⁿ | a << n5 << 1 = 10 |
| >> | Przesunięcie w prawo – dzielenie przez 2ⁿ, zachowuje znak | a >> n-8 >> 1 = -4 |
| >>> | Przesunięcie w prawo bez znaku – zawsze uzupełnia zerami | a >>> n-8 >>> 1 daje dużą liczbę dodatnią |
Obecnie nie załączam przykładu dla operatorów bitowych, ponieważ są to bardziej zaawansowane operacje, rzadziej wykorzystywane w podstawowym testowaniu czy programowaniu.
Kolejność operacji
Ponownie jak w matematyce w Java stosuje się kolejność działań, a brak jej zrozumienia może skutkować błędnymi wynikami działań. Jeśli w jednym wyrażeniu znajduje się kilka operatorów, kompilator Java ocenia je według ustalonego priorytetu operatorów. Operatory o tym samym priorytecie są oceniane od lewej do prawej.
int num = 5 * (10 - 4) + 4 / 2;
Kolejność operatorów w Java (od najwyższego do najniższego priorytetu):
- Post-ikrementacja a++ oraz post-dekrementacja a–
- Pre-inkrementacja ++a, pre-dekrementacja –a, operatory jednoargumentowe +a, -a, !a (negacja logiczna) oraz ~a (negacja bitowa)
- Rzutowanie typu
- Modulo %, mnożenie *, dzielenie /
- Dodawanie +, odejmowanie –
- Przesunięcia bitowe <<, >>, >>>
- Operatory porównania <, >, <=, >=
- Porównanie równości ==, !=
- Operatory bitowe &, ^, |
- Operatory logiczne &&, ||,
- Operator warunkowy (ternary) ?:
- Operatory przypisania =, +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=, >>>=
Przykłady obliczeń według kolejności operatorów:
5 * (10 - 4) + 4 / 2 // najpierw nawiasy (najwyższy priorytet) → 10 - 4 = 6 5 * 6 + 4 / 2 // mnożenie → 5 * 6 = 30 30 + 4 / 2 // dzielenie → 4 / 2 = 2 30 + 2 // dodawanie → wynik: 32
Podsumowanie
Java oferuje bogaty zestaw operatorów, dzięki którym możemy tworzyć warunki, wykonywać obliczenia i budować logikę aplikacji. Ich znajomość jest niezbędna nie tylko dla programistów, ale również dla testerów automatyzujących testy, którzy piszą skrypty i asercje.
Poza podstawowymi operatorami omówionymi w tym artykule, Java oferuje również bardziej zaawansowane mechanizmy, takie jak: operatory rzutowania typów, przesunięcia bitowego, instance of, czy też operator używany w wyrażeniach lambda. Są one przydatne głównie w bardziej skomplikowanych scenariuszach programistycznych.
Kurs Java #5 Operatory matematyczne i logiczne to powrót do lekcji dot. Javy. Więcej artykułów o Javie będzie w sekcji kursu Javy. Artykuły będą ukazywać się sukcesywnie byś mógł poznać język Java, lub mieć pewne informacje pod ręką – łącznie z pseudokodem.
O autorze
Tester oprogramowania z pasją do jakości i technologii. Łączy doświadczenie w testach manualnych i automatycznych, koncentrując się przede wszystkim na aplikacjach webowych oraz usługach SOAP i REST. Testowanie to dla niego nie tylko szukanie błędów, ale przede wszystkim kwestionowanie przyjętych założeń i usprawnianie tego, co nie działa – również w samym procesie testowym. Lubi zmieniać, angażować się i aktywnie budować proces testowy, tak by miał sens, a nie tylko formę. Prywatnie fan rocka, biwakowania, podróży.
