Java Operatörleri: Aritmetik, Karşılaştırma, Mantıksal ve Atama

Operatörler Ne İşe Yarar

Operatörler, yeni değerler hesaplamak için değerleri birleştiren sembollerdir. Onları zaten gayriresmî biçimde kullanıyorsunuz - + toplar, > karşılaştırır - ve Java bunları birkaç aileye ayırır: aritmetik, karşılaştırma, mantıksal, atama ve artırma ile üçlü operatör gibi birkaç özel operatör.

Operatörlerin çoğu iki değer alır (biri sembolden önce, biri sonra) ve bir sonuç üretir. İşin püf noktası, bu sonucun türünün ne olduğunu ve hangi sırayla uygulandıklarını bilmektir - yeni başlayanların tökezlediği yer de burasıdır.

Aritmetik Operatörler

Beş aritmetik operatör sayılar üzerinde çalışır: +, -, *, / ve % (kalan).

public class Main {
    public static void main(String[] args) {
        int a = 17;
        int b = 5;

        System.out.println(a + b);   // 22
        System.out.println(a - b);   // 12
        System.out.println(a * b);   // 85
        System.out.println(a / b);   // 3  (tam sayı bölmesi!)
        System.out.println(a % b);   // 2  (kalan)
    }
}

% operatörü, bölmeden sonraki kalandır: 17 % 5 sonucu 2'dir çünkü 5, 17'nin içine üç kez girer ve geriye 2 kalır. Bölünebilirliği test etmek için günlük araçtır - n % 2 == 0, "n çift mi?" kontrolünün standart halidir.

Ayrıca +'nın çift görev gördüğünü unutmayın: sayılarla toplar, ama herhangi bir tarafında bir String olduğunda metni birleştirir.

public class Main {
    public static void main(String[] args) {
        System.out.println("Total: " + 3 + 4);   // Total: 34
        System.out.println("Total: " + (3 + 4));  // Total: 7
    }
}

İlk satır soldan sağa okunur: "Total: " + 3 zaten bir dizedir, bu yüzden 4 metin olarak eklenir. İşlemin önce hesaplanmasını istediğinizde matematiği parantez içine alın.

Tam Sayı Bölmesi Tuzağı

Bu, en sık karşılaşılan tek sürprizdir. / operatörünün her iki işleneni de tam sayı olduğunda, Java tam sayı bölmesi yapar ve kesirli kısmı atar - yuvarlamaz, sıfıra doğru keser.

public class Main {
    public static void main(String[] args) {
        System.out.println(5 / 2);        // 2, 2.5 değil
        System.out.println(9 / 10);       // 0
        System.out.println(5.0 / 2);      // 2.5  (bir double yeter)
        System.out.println((double) 5 / 2); // 2.5 (bir işleneni dönüştür)
    }
}

Ondalık bir sonuç almak için en az bir işleneni double yapın - ya .0 ile yazın ya da bir tarafı (double) ile dönüştürün. (double)(5 / 2) yapmak işe yaramaz, çünkü 5 / 2 tam sayı bölmesi dönüştürmeden önce zaten gerçekleşmiştir; sonucu değil, bir işleneni dönüştürmelisiniz.

Karşılaştırma Operatörleri

Karşılaştırma operatörleri evet/hayır sorusu sorar ve bir boolean döndürür. Altı tanedir: ==, !=, <, >, <=, >=.

public class Main {
    public static void main(String[] args) {
        int score = 75;

        System.out.println(score >= 60);   // true
        System.out.println(score == 100);  // false
        System.out.println(score != 0);    // true
    }
}

= (atama - "bu değeri buraya koy") ile == (karşılaştırma - "bunlar eşit mi?") arasındaki farka dikkat edin. Bunları karıştırmak klasik bir hatadır.

Önemli bir uyarı: ==, nesne referanslarını karşılaştırır, içerikleri değil. Dizeler için .equals() kullanın.

public class Main {
    public static void main(String[] args) {
        String a = "hi";
        String b = new String("hi");

        System.out.println(a == b);        // false - farklı nesneler
        System.out.println(a.equals(b));   // true  - aynı metin
    }
}

int ve boolean gibi ilkel türler için ==, String gibi nesnelerin içeriğini karşılaştırırken her zaman .equals() kullanın.

Mantıksal Operatörler

Mantıksal operatörler boolean değerleri birleştirir: && (ve), || (veya) ve ! (değil). "Yeterince büyük ve bileti var" gibi koşulları bu şekilde ifade edersiniz.

public class Main {
    public static void main(String[] args) {
        int age = 20;
        boolean hasTicket = true;

        System.out.println(age >= 18 && hasTicket);  // true
        System.out.println(age < 13 || hasTicket);    // true
        System.out.println(!hasTicket);                // false
    }
}

&& ve ||, kısa devre yapar: Java, cevap kesinleşir kesinleşmez değerlendirmeyi durdurur. && ile, sol taraf false ise sağ taraf hiç kontrol edilmez; || ile, sol taraf true ise sağ taraf atlanır. Bu sadece bir optimizasyon değildir - güvenlik için buna güvenebilirsiniz:

if (text != null && text.length() > 0) { ... }

text değeri null ise sol taraf false olur ve text.length() hiç çağrılmaz; böylece bir NullPointerException önlenir. Sırayı tersine çevirin, program çökerdi.

Atama ve Artırma

= atama yapar, ancak Java'nın bir işlemi atamayla birleştiren bileşik atamaları da vardır: +=, -=, *=, /=, %=. Ve ++ / -- bir artırır veya azaltır.

public class Main {
    public static void main(String[] args) {
        int count = 10;

        count += 5;   // count = count + 5  -> 15
        count -= 2;   // -> 13
        count *= 2;   // -> 26
        System.out.println(count);

        count++;      // -> 27
        count--;      // -> 26
        System.out.println(count);
    }
}

++ iki şekilde gelir: sonek (count++) eski değeri döndürür, sonra artırır; önek (++count) önce artırır, sonra yeni değeri döndürür. Fark yalnızca sonucu aynı ifade içinde kullandığınızda önemlidir:

public class Main {
    public static void main(String[] args) {
        int x = 5;
        System.out.println(x++);   // 5 yazdırır, sonra x 6 olur
        System.out.println(++x);   // x 7 olur, 7 yazdırır
    }
}

++ kendi satırındayken sonek ile önek arasında fark yoktur - bu yüzden hangisi daha açık okunuyorsa onu tercih edin ve artırmaları daha büyük ifadelerin içine sıkıştırmayın.

Üçlü (Ternary) Operatör

Üçlü operatör condition ? a : b, bir değer üreten kompakt bir if/else'tir: koşul true ise a'ya, aksi takdirde b'ye değerlenir.

public class Main {
    public static void main(String[] args) {
        int score = 72;

        String result = score >= 60 ? "pass" : "fail";
        System.out.println(result);   // pass

        int max = (score > 100) ? 100 : score;
        System.out.println(max);      // 72
    }
}

Kısa, bu-ya-da-o tarzı atamalarda parlar. Üçlü operatörleri üçlü operatörlerin içine yuvalamaktan kaçının - bu hızla okunmaz hale gelir ve sade bir if/else daha açıktır.

Öncelik ve Parantezler

Operatörler tıpkı matematikteki gibi sabit bir sırayla uygulanır: *, /, %, + ve -'den daha güçlü bağlanır; bunlar da karşılaştırmalardan daha güçlü bağlanır; karşılaştırmalar &&'den, en son da ||'dan daha güçlü bağlanır.

public class Main {
    public static void main(String[] args) {
        System.out.println(2 + 3 * 4);        // 14, 20 değil
        System.out.println((2 + 3) * 4);      // 20
        System.out.println(5 > 3 && 1 < 2);   // true
    }
}

Tablonun tamamını ezberlemenize gerek yok. Bir ifade aileleri karıştırdığında ya da sırayı çözmek için durup düşünmeniz gerektiğinde, parantez ekleyin - bir maliyetleri yoktur ve sonraki okuyucuya niyeti açıkça gösterirler.

Sonraki: Tür Dönüşümü (Casting)

Buradaki tuzakların birçoğu - tam sayı bölmesi, int ile double karıştırma - türlere dayanır. Sayı türleri arasında bilinçli olarak dönüşüm yapmaya casting denir ve sonraki sayfanın konusu budur.