Operatory i równość

Operatory arytmetyczne

Służą do wykonywania działań na liczbach:

val a = 17
val b = 5

println("Suma:     ${a + b}")   // 22
println("Różnica:  ${a - b}")   // 12
println("Iloczyn:  ${a * b}")   // 85
println("Iloraz:   ${a / b}")   // 3  (dzielenie całkowite)
println("Reszta:   ${a % b}")   // 2

Operatory przypisania

Znak = przypisuje wartość. Operatory złożone (+=, -=…) to skrót: „weź obecną wartość, wykonaj działanie, zapisz wynik z powrotem”. Działają tylko na zmiennych var.

var suma = 0
suma += 5     // 5
suma += 3     // 8
suma *= 2     // 16

var licznik = 0
licznik++       // 1
licznik++       // 2
licznik--       // 1

Operatory porównania

Porównują dwie wartości i zwracają wynik logiczny Boolean (true albo false):

val a = 5
val b = 8

println(a < b)    // true
println(a > b)    // false
println(a == b)   // false
println(a != b)   // true

Wyniki porównań wykorzystamy w instrukcjach warunkowych (temat z bloku o sterowaniu przepływem).

== kontra === – dwa rodzaje równości

Kotlin rozróżnia dwa pytania o „równość”, które łatwo pomylić:

Dwa różne pudełka mogą zawierać identyczną zawartość. == sprawdza zawartość, === sprawdza, czy to fizycznie to samo pudełko.

val imie = "Anna"

val czesc = "An"
val zlozone = czesc + "na"   // "Anna" zbudowane z kawałków = nowy obiekt

println(imie == zlozone)    // true  – ta sama treść ("Anna")
println(imie === zlozone)   // false – to dwa różne obiekty w pamięci

Operatory logiczne

Łączą lub odwracają warunki (wartości Boolean). Pozwalają zbudować bardziej złożone pytania niż pojedyncze porównanie.

val wiek = 17

// && – oba warunki muszą być spełnione
println(wiek >= 13 && wiek <= 19)   // true – nastolatek

// || – wystarczy jeden warunek
val pora = "noc"
println(pora == "dzień" || pora == "noc")   // true

// ! – zaprzeczenie
println(!(wiek >= 18))   // true – NIE jest pełnoletni

Kolejność (priorytet) operatorów

Tak jak w matematyce, niektóre operatory wykonują się przed innymi. Od najwyższego do najniższego priorytetu:

println(2 + 3 * 4)       // 14  (* przed +)
println((2 + 3) * 4)     // 20  (nawiasy zmieniają kolejność)

Częste błędy

❌ Błąd 1: = zamiast == w porównaniu

val x = 5
println(x = 5)
// Błąd! = to przypisanie,
// nie porównanie

val x = 5
println(x == 5)
// true

❌ Błąd 2: === gdy chodzi o wartość

val a = "An" + "na"
val b = "An" + "na"
println(a === b)
// może dać false –
// to różne obiekty

val a = "An" + "na"
val b = "An" + "na"
println(a == b)
// true – ta sama treść

❌ Błąd 3: brak powtórzenia zmiennej w warunku

val w = 15
println(13 <= w <= 19)
// Błąd! tak się nie da

val w = 15
println(w >= 13 && w <= 19)
// true

❌ Błąd 4: dzielenie całkowite przez zero

val x = 10 / 0
// Błąd w czasie działania!
// nie można dzielić
// liczb całkowitych przez 0

val dzielnik = 0
if (dzielnik != 0) {
    println(10 / dzielnik)
}
// dzielimy tylko gdy != 0

Podsumowanie

• Arytmetyczne: + - * / oraz % (reszta). Pamiętaj o dzieleniu całkowitym.
• Przypisania: = oraz skróty += -= *= /=; ++ zwiększa, -- zmniejsza o 1.
• Porównania < > <= >= == != zwracają Boolean.
• == – równość wartości (strukturalna); === – ten sam obiekt (referencyjna). Na co dzień używasz ==.
• Logiczne: && (oba), || (co najmniej jeden), ! (zaprzeczenie). Każdy warunek to osobne porównanie.
• Operatory mają priorytet (* przed + itd.); w razie wątpliwości używaj nawiasów.

Zadania do wykonania

Zadania wykonaj w Kotlin Playground (play.kotlinlang.org).